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 //-----------------------------------------------------------------------------
37 //-----------------------------------------------------------------------------
39 static wxDataViewCtrlInternal
*gs_internal
= NULL
;
41 class wxGtkTreeModelNode
;
44 typedef struct _GtkWxTreeModel GtkWxTreeModel
;
47 //-----------------------------------------------------------------------------
48 // wxDataViewCtrlInternal
49 //-----------------------------------------------------------------------------
51 WX_DECLARE_LIST(wxDataViewItem
, ItemList
);
52 WX_DEFINE_LIST(ItemList
)
54 class WXDLLIMPEXP_ADV wxDataViewCtrlInternal
57 wxDataViewCtrlInternal( wxDataViewCtrl
*owner
, wxDataViewModel
*wx_model
, GtkWxTreeModel
*gtk_model
);
58 ~wxDataViewCtrlInternal();
61 GtkTreeModelFlags
get_flags();
62 gboolean
get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
);
63 GtkTreePath
*get_path( GtkTreeIter
*iter
);
64 gboolean
iter_next( GtkTreeIter
*iter
);
65 gboolean
iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
);
66 gboolean
iter_has_child( GtkTreeIter
*iter
);
67 gint
iter_n_children( GtkTreeIter
*iter
);
68 gboolean
iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
);
69 gboolean
iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
);
73 bool EnableDragSource( const wxDataFormat
&format
);
74 bool EnableDropTarget( const wxDataFormat
&format
);
76 gboolean
row_draggable( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
);
77 gboolean
drag_data_delete( GtkTreeDragSource
*drag_source
, GtkTreePath
* path
);
78 gboolean
drag_data_get( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
,
79 GtkSelectionData
*selection_data
);
80 gboolean
drag_data_received( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest
,
81 GtkSelectionData
*selection_data
);
82 gboolean
row_drop_possible( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest_path
,
83 GtkSelectionData
*selection_data
);
85 // notifactions from wxDataViewModel
86 bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
87 bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
88 bool ItemChanged( const wxDataViewItem
&item
);
89 bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
94 void SetSortOrder( GtkSortType sort_order
) { m_sort_order
= sort_order
; }
95 GtkSortType
GetSortOrder() { return m_sort_order
; }
97 void SetSortColumn( int column
) { m_sort_column
= column
; }
98 int GetSortColumn() { return m_sort_column
; }
100 void SetDataViewSortColumn( wxDataViewColumn
*column
) { m_dataview_sort_column
= column
; }
101 wxDataViewColumn
*GetDataViewSortColumn() { return m_dataview_sort_column
; }
103 bool IsSorted() { return (m_sort_column
>= 0); }
106 wxDataViewModel
* GetDataViewModel() { return m_wx_model
; }
107 wxDataViewCtrl
* GetOwner() { return m_owner
; }
108 GtkWxTreeModel
* GetGtkModel() { return m_gtk_model
; }
112 wxGtkTreeModelNode
*FindNode( const wxDataViewItem
&item
);
113 wxGtkTreeModelNode
*FindNode( GtkTreeIter
*iter
);
114 wxGtkTreeModelNode
*FindParentNode( const wxDataViewItem
&item
);
115 wxGtkTreeModelNode
*FindParentNode( GtkTreeIter
*iter
);
116 void BuildBranch( wxGtkTreeModelNode
*branch
);
119 wxGtkTreeModelNode
*m_root
;
120 wxDataViewModel
*m_wx_model
;
121 GtkWxTreeModel
*m_gtk_model
;
122 wxDataViewCtrl
*m_owner
;
123 GtkSortType m_sort_order
;
124 wxDataViewColumn
*m_dataview_sort_column
;
127 GtkTargetEntry m_dragSourceTargetEntry
;
128 wxCharBuffer m_dragSourceTargetEntryTarget
;
129 wxDataObject
*m_dragDataObject
;
131 GtkTargetEntry m_dropTargetTargetEntry
;
132 wxCharBuffer m_dropTargetTargetEntryTarget
;
133 wxDataObject
*m_dropDataObject
;
137 //-----------------------------------------------------------------------------
138 // wxGtkTreeModelNode
139 //-----------------------------------------------------------------------------
142 int LINKAGEMODE
wxGtkTreeModelChildCmp( void** id1
, void** id2
)
144 int ret
= gs_internal
->GetDataViewModel()->Compare( *id1
, *id2
,
145 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
150 WX_DEFINE_ARRAY_PTR( wxGtkTreeModelNode
*, wxGtkTreeModelNodes
);
151 WX_DEFINE_ARRAY_PTR( void*, wxGtkTreeModelChildren
);
153 class wxGtkTreeModelNode
156 wxGtkTreeModelNode( wxGtkTreeModelNode
* parent
, const wxDataViewItem
&item
,
157 wxDataViewCtrlInternal
*internal
)
161 m_internal
= internal
;
164 ~wxGtkTreeModelNode()
166 size_t count
= m_nodes
.GetCount();
168 for (i
= 0; i
< count
; i
++)
170 wxGtkTreeModelNode
*child
= m_nodes
.Item( i
);
175 unsigned int AddNode( wxGtkTreeModelNode
* child
)
177 m_nodes
.Add( child
);
179 void *id
= child
->GetItem().GetID();
181 m_children
.Add( id
);
183 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
185 gs_internal
= m_internal
;
186 m_children
.Sort( &wxGtkTreeModelChildCmp
);
187 return m_children
.Index( id
);
190 return m_children
.GetCount()-1;
193 unsigned int AddLeave( void* id
)
195 m_children
.Add( id
);
197 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
199 gs_internal
= m_internal
;
200 m_children
.Sort( &wxGtkTreeModelChildCmp
);
201 return m_children
.Index( id
);
204 return m_children
.GetCount()-1;
207 void DeleteChild( void* id
)
209 m_children
.Remove( id
);
211 unsigned int count
= m_nodes
.GetCount();
213 for (pos
= 0; pos
< count
; pos
++)
215 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
216 if (node
->GetItem().GetID() == id
)
218 m_nodes
.RemoveAt( pos
);
225 wxGtkTreeModelNode
* GetParent()
227 wxGtkTreeModelNodes
&GetNodes()
229 wxGtkTreeModelChildren
&GetChildren()
230 { return m_children
; }
232 unsigned int GetChildCount() const { return m_children
.GetCount(); }
233 unsigned int GetNodesCount() const { return m_nodes
.GetCount(); }
235 wxDataViewItem
&GetItem() { return m_item
; }
236 wxDataViewCtrlInternal
*GetInternal() { return m_internal
; }
241 wxGtkTreeModelNode
*m_parent
;
242 wxGtkTreeModelNodes m_nodes
;
243 wxGtkTreeModelChildren m_children
;
244 wxDataViewItem m_item
;
245 wxDataViewCtrlInternal
*m_internal
;
249 //-----------------------------------------------------------------------------
251 //-----------------------------------------------------------------------------
253 extern bool g_blockEventsOnDrag
;
255 //-----------------------------------------------------------------------------
256 // define new GTK+ class wxGtkTreeModel
257 //-----------------------------------------------------------------------------
261 #define GTK_TYPE_WX_TREE_MODEL (gtk_wx_tree_model_get_type ())
262 #define GTK_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
263 #define GTK_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
264 #define GTK_IS_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
265 #define GTK_IS_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
266 #define GTK_WX_TREE_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
268 GType
gtk_wx_tree_model_get_type (void);
270 typedef struct _GtkWxTreeModelClass GtkWxTreeModelClass
;
272 struct _GtkWxTreeModel
278 wxDataViewCtrlInternal
*internal
;
281 struct _GtkWxTreeModelClass
283 GObjectClass list_parent_class
;
286 static GtkWxTreeModel
*wxgtk_tree_model_new (void);
287 static void wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
);
288 static void wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
);
290 static void wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
);
291 static void wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
);
292 static void wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
);
293 static void wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
);
295 static void wxgtk_tree_model_finalize (GObject
*object
);
296 static GtkTreeModelFlags
wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
);
297 static gint
wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
);
298 static GType
wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
300 static gboolean
wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
303 static GtkTreePath
*wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
305 static void wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
309 static gboolean
wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
311 static gboolean
wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
313 GtkTreeIter
*parent
);
314 static gboolean
wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
316 static gint
wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
318 static gboolean
wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
322 static gboolean
wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
327 static gboolean
wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
328 gint
*sort_column_id
,
330 static void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
333 static void wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
335 GtkTreeIterCompareFunc func
,
337 GtkDestroyNotify destroy
);
338 static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
339 GtkTreeIterCompareFunc func
,
341 GtkDestroyNotify destroy
);
342 static gboolean
wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
);
345 static gboolean
wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
347 static gboolean
wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
349 static gboolean
wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
351 GtkSelectionData
*selection_data
);
352 static gboolean
wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
354 GtkSelectionData
*selection_data
);
355 static gboolean
wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
356 GtkTreePath
*dest_path
,
357 GtkSelectionData
*selection_data
);
360 static GObjectClass
*list_parent_class
= NULL
;
363 gtk_wx_tree_model_get_type (void)
365 static GType tree_model_type
= 0;
367 if (!tree_model_type
)
369 const GTypeInfo tree_model_info
=
371 sizeof (GtkWxTreeModelClass
),
372 NULL
, /* base_init */
373 NULL
, /* base_finalize */
374 (GClassInitFunc
) wxgtk_tree_model_class_init
,
375 NULL
, /* class_finalize */
376 NULL
, /* class_data */
377 sizeof (GtkWxTreeModel
),
379 (GInstanceInitFunc
) wxgtk_tree_model_init
,
382 static const GInterfaceInfo tree_model_iface_info
=
384 (GInterfaceInitFunc
) wxgtk_tree_model_tree_model_init
,
389 static const GInterfaceInfo sortable_iface_info
=
391 (GInterfaceInitFunc
) wxgtk_tree_model_sortable_init
,
396 static const GInterfaceInfo drag_source_iface_info
=
398 (GInterfaceInitFunc
) wxgtk_tree_model_drag_source_init
,
403 static const GInterfaceInfo drag_dest_iface_info
=
405 (GInterfaceInitFunc
) wxgtk_tree_model_drag_dest_init
,
410 tree_model_type
= g_type_register_static (G_TYPE_OBJECT
, "GtkWxTreeModel",
411 &tree_model_info
, (GTypeFlags
)0 );
413 g_type_add_interface_static (tree_model_type
,
415 &tree_model_iface_info
);
416 g_type_add_interface_static (tree_model_type
,
417 GTK_TYPE_TREE_SORTABLE
,
418 &sortable_iface_info
);
419 g_type_add_interface_static (tree_model_type
,
420 GTK_TYPE_TREE_DRAG_DEST
,
421 &drag_dest_iface_info
);
422 g_type_add_interface_static (tree_model_type
,
423 GTK_TYPE_TREE_DRAG_SOURCE
,
424 &drag_source_iface_info
);
427 return tree_model_type
;
430 static GtkWxTreeModel
*
431 wxgtk_tree_model_new(void)
433 GtkWxTreeModel
*retval
= (GtkWxTreeModel
*) g_object_new (GTK_TYPE_WX_TREE_MODEL
, NULL
);
438 wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
)
440 list_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
441 GObjectClass
*object_class
= (GObjectClass
*) klass
;
442 object_class
->finalize
= wxgtk_tree_model_finalize
;
446 wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
)
448 iface
->get_flags
= wxgtk_tree_model_get_flags
;
449 iface
->get_n_columns
= wxgtk_tree_model_get_n_columns
;
450 iface
->get_column_type
= wxgtk_tree_model_get_column_type
;
451 iface
->get_iter
= wxgtk_tree_model_get_iter
;
452 iface
->get_path
= wxgtk_tree_model_get_path
;
453 iface
->get_value
= wxgtk_tree_model_get_value
;
454 iface
->iter_next
= wxgtk_tree_model_iter_next
;
455 iface
->iter_children
= wxgtk_tree_model_iter_children
;
456 iface
->iter_has_child
= wxgtk_tree_model_iter_has_child
;
457 iface
->iter_n_children
= wxgtk_tree_model_iter_n_children
;
458 iface
->iter_nth_child
= wxgtk_tree_model_iter_nth_child
;
459 iface
->iter_parent
= wxgtk_tree_model_iter_parent
;
463 wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
)
465 iface
->get_sort_column_id
= wxgtk_tree_model_get_sort_column_id
;
466 iface
->set_sort_column_id
= wxgtk_tree_model_set_sort_column_id
;
467 iface
->set_sort_func
= wxgtk_tree_model_set_sort_func
;
468 iface
->set_default_sort_func
= wxgtk_tree_model_set_default_sort_func
;
469 iface
->has_default_sort_func
= wxgtk_tree_model_has_default_sort_func
;
473 wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
)
475 iface
->row_draggable
= wxgtk_tree_model_row_draggable
;
476 iface
->drag_data_delete
= wxgtk_tree_model_drag_data_delete
;
477 iface
->drag_data_get
= wxgtk_tree_model_drag_data_get
;
481 wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
)
483 iface
->drag_data_received
= wxgtk_tree_model_drag_data_received
;
484 iface
->row_drop_possible
= wxgtk_tree_model_row_drop_possible
;
488 wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
)
490 tree_model
->internal
= NULL
;
491 tree_model
->stamp
= g_random_int();
495 wxgtk_tree_model_finalize (GObject
*object
)
498 (* list_parent_class
->finalize
) (object
);
503 //-----------------------------------------------------------------------------
504 // implement callbacks from wxGtkTreeModel class by letting
505 // them call the methods of wxWidgets' wxDataViewModel
506 //-----------------------------------------------------------------------------
508 static GtkTreeModelFlags
509 wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
)
511 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
512 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), (GtkTreeModelFlags
)0 );
514 return wxtree_model
->internal
->get_flags();
518 wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
)
520 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
521 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
523 return wxtree_model
->internal
->GetDataViewModel()->GetColumnCount();
527 wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
530 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
531 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), G_TYPE_INVALID
);
533 GType gtype
= G_TYPE_INVALID
;
535 wxString wxtype
= wxtree_model
->internal
->GetDataViewModel()->GetColumnType( (unsigned int) index
);
537 if (wxtype
== wxT("string"))
538 gtype
= G_TYPE_STRING
;
541 gtype
= G_TYPE_STRING
;
542 // wxFAIL_MSG( _T("non-string columns not supported yet") );
549 wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
553 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
554 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
555 g_return_val_if_fail (gtk_tree_path_get_depth (path
) > 0, FALSE
);
557 return wxtree_model
->internal
->get_iter( iter
, path
);
561 wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
564 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
565 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), NULL
);
566 g_return_val_if_fail (iter
->stamp
== GTK_WX_TREE_MODEL (wxtree_model
)->stamp
, NULL
);
568 return wxtree_model
->internal
->get_path( iter
);
572 wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
577 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
578 g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
) );
580 wxDataViewModel
*model
= wxtree_model
->internal
->GetDataViewModel();
581 wxString mtype
= model
->GetColumnType( (unsigned int) column
);
582 if (mtype
== wxT("string"))
585 g_value_init( value
, G_TYPE_STRING
);
586 wxDataViewItem
item( (void*) iter
->user_data
);
587 model
->GetValue( variant
, item
, (unsigned int) column
);
589 g_value_set_string( value
, variant
.GetString().utf8_str() );
593 wxFAIL_MSG( _T("non-string columns not supported yet") );
598 wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
601 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
603 //if (wxtree_model->stamp != iter->stamp)
604 // wxPrintf( "crash\n" );
605 // TODO: remove this code
607 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
608 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
610 return wxtree_model
->internal
->iter_next( iter
);
614 wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
618 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
619 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
620 g_return_val_if_fail (wxtree_model
->stamp
== parent
->stamp
, FALSE
);
622 return wxtree_model
->internal
->iter_children( iter
, parent
);
626 wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
629 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
630 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
631 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
633 return wxtree_model
->internal
->iter_has_child( iter
);
637 wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
640 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
641 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
644 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, 0);
646 return wxtree_model
->internal
->iter_n_children( iter
);
650 wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
655 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
656 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
658 return wxtree_model
->internal
->iter_nth_child( iter
, parent
, n
);
662 wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
666 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
667 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
668 g_return_val_if_fail (wxtree_model
->stamp
== child
->stamp
, FALSE
);
670 return wxtree_model
->internal
->iter_parent( iter
, child
);
673 /* drag'n'drop iface */
675 wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
678 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
679 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
681 return wxtree_model
->internal
->row_draggable( drag_source
, path
);
685 wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
688 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
689 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
691 return wxtree_model
->internal
->drag_data_delete( drag_source
, path
);
695 wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
697 GtkSelectionData
*selection_data
)
699 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
700 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
703 wxPrintf( "drag_get_data\n");
705 wxGtkString
atom_selection(gdk_atom_name(selection_data
->selection
));
706 wxPrintf( "selection %s\n", wxString::FromAscii(atom_selection
) );
708 wxGtkString
atom_target(gdk_atom_name(selection_data
->target
));
709 wxPrintf( "target %s\n", wxString::FromAscii(atom_target
) );
711 wxGtkString
atom_type(gdk_atom_name(selection_data
->type
));
712 wxPrintf( "type %s\n", wxString::FromAscii(atom_type
) );
714 wxPrintf( "format %d\n", selection_data
->format
);
717 return wxtree_model
->internal
->drag_data_get( drag_source
, path
, selection_data
);
721 wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
723 GtkSelectionData
*selection_data
)
725 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
726 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
728 return wxtree_model
->internal
->drag_data_received( drag_dest
, dest
, selection_data
);
732 wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
733 GtkTreePath
*dest_path
,
734 GtkSelectionData
*selection_data
)
736 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
737 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
739 return wxtree_model
->internal
->row_drop_possible( drag_dest
, dest_path
, selection_data
);
744 wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
745 gint
*sort_column_id
,
748 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) sortable
;
750 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
752 if (!wxtree_model
->internal
->IsSorted())
755 *sort_column_id
= -1;
762 *sort_column_id
= wxtree_model
->internal
->GetSortColumn();
765 *order
= wxtree_model
->internal
->GetSortOrder();
770 wxDataViewColumn
*gs_lastLeftClickHeader
= NULL
;
773 wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
777 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) sortable
;
778 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
780 tree_model
->internal
->SetDataViewSortColumn( gs_lastLeftClickHeader
);
782 if ((sort_column_id
!= (gint
) tree_model
->internal
->GetSortColumn()) ||
783 (order
!= tree_model
->internal
->GetSortOrder()))
785 tree_model
->internal
->SetSortColumn( sort_column_id
);
786 tree_model
->internal
->SetSortOrder( order
);
788 gtk_tree_sortable_sort_column_changed (sortable
);
790 tree_model
->internal
->GetDataViewModel()->Resort();
793 if (gs_lastLeftClickHeader
)
795 wxDataViewCtrl
*dv
= tree_model
->internal
->GetOwner();
796 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED
, dv
->GetId() );
797 event
.SetDataViewColumn( gs_lastLeftClickHeader
);
798 event
.SetModel( dv
->GetModel() );
799 dv
->HandleWindowEvent( event
);
802 gs_lastLeftClickHeader
= NULL
;
806 wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
807 gint
WXUNUSED(sort_column_id
),
808 GtkTreeIterCompareFunc func
,
809 gpointer
WXUNUSED(data
),
810 GtkDestroyNotify
WXUNUSED(destroy
))
812 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
813 g_return_if_fail (func
!= NULL
);
817 wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
818 GtkTreeIterCompareFunc func
,
819 gpointer
WXUNUSED(data
),
820 GtkDestroyNotify
WXUNUSED(destroy
))
822 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
823 g_return_if_fail (func
!= NULL
);
825 //wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
826 // TODO: remove this code
830 wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
)
832 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
837 //-----------------------------------------------------------------------------
838 // define new GTK+ class wxGtkRendererRenderer
839 //-----------------------------------------------------------------------------
843 #define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
844 #define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
845 #define GTK_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
846 #define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
847 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
848 #define GTK_WX_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
850 GType
gtk_wx_cell_renderer_get_type (void);
852 typedef struct _GtkWxCellRenderer GtkWxCellRenderer
;
853 typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass
;
855 struct _GtkWxCellRenderer
857 GtkCellRenderer parent
;
860 wxDataViewCustomRenderer
*cell
;
864 struct _GtkWxCellRendererClass
866 GtkCellRendererClass cell_parent_class
;
870 static GtkCellRenderer
*gtk_wx_cell_renderer_new (void);
871 static void gtk_wx_cell_renderer_init (
872 GtkWxCellRenderer
*cell
);
873 static void gtk_wx_cell_renderer_class_init(
874 GtkWxCellRendererClass
*klass
);
875 static void gtk_wx_cell_renderer_finalize (
877 static void gtk_wx_cell_renderer_get_size (
878 GtkCellRenderer
*cell
,
880 GdkRectangle
*rectangle
,
885 static void gtk_wx_cell_renderer_render (
886 GtkCellRenderer
*cell
,
889 GdkRectangle
*background_area
,
890 GdkRectangle
*cell_area
,
891 GdkRectangle
*expose_area
,
892 GtkCellRendererState flags
);
893 static gboolean
gtk_wx_cell_renderer_activate(
894 GtkCellRenderer
*cell
,
898 GdkRectangle
*background_area
,
899 GdkRectangle
*cell_area
,
900 GtkCellRendererState flags
);
901 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
902 GtkCellRenderer
*cell
,
906 GdkRectangle
*background_area
,
907 GdkRectangle
*cell_area
,
908 GtkCellRendererState flags
);
911 static GObjectClass
*cell_parent_class
= NULL
;
916 gtk_wx_cell_renderer_get_type (void)
918 static GType cell_wx_type
= 0;
922 const GTypeInfo cell_wx_info
=
924 sizeof (GtkWxCellRendererClass
),
925 NULL
, /* base_init */
926 NULL
, /* base_finalize */
927 (GClassInitFunc
) gtk_wx_cell_renderer_class_init
,
928 NULL
, /* class_finalize */
929 NULL
, /* class_data */
930 sizeof (GtkWxCellRenderer
),
932 (GInstanceInitFunc
) gtk_wx_cell_renderer_init
,
935 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER
,
936 "GtkWxCellRenderer", &cell_wx_info
, (GTypeFlags
)0 );
943 gtk_wx_cell_renderer_init (GtkWxCellRenderer
*cell
)
946 cell
->last_click
= 0;
950 gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass
*klass
)
952 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
953 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
955 cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
957 object_class
->finalize
= gtk_wx_cell_renderer_finalize
;
959 cell_class
->get_size
= gtk_wx_cell_renderer_get_size
;
960 cell_class
->render
= gtk_wx_cell_renderer_render
;
961 cell_class
->activate
= gtk_wx_cell_renderer_activate
;
962 cell_class
->start_editing
= gtk_wx_cell_renderer_start_editing
;
966 gtk_wx_cell_renderer_finalize (GObject
*object
)
969 (* G_OBJECT_CLASS (cell_parent_class
)->finalize
) (object
);
973 gtk_wx_cell_renderer_new (void)
975 return (GtkCellRenderer
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER
, NULL
);
980 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
981 GtkCellRenderer
*renderer
,
982 GdkEvent
*WXUNUSED(event
),
985 GdkRectangle
*WXUNUSED(background_area
),
986 GdkRectangle
*cell_area
,
987 GtkCellRendererState
WXUNUSED(flags
) )
989 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
990 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
992 // Renderer doesn't support in-place editing
993 if (!cell
->HasEditorCtrl())
996 // An in-place editing control is still around
997 if (cell
->GetEditorCtrl())
1001 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1007 rect
.x
+= cell_area
->x
;
1008 rect
.y
+= cell_area
->y
;
1009 // rect.width -= renderer->xpad * 2;
1010 // rect.height -= renderer->ypad * 2;
1012 // wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
1013 wxRect
renderrect( cell_area
->x
, cell_area
->y
, cell_area
->width
, cell_area
->height
);
1015 GtkTreePath
*treepath
= gtk_tree_path_new_from_string( path
);
1017 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, treepath
);
1018 wxDataViewItem
item( (void*) iter
.user_data
);
1019 gtk_tree_path_free( treepath
);
1021 cell
->StartEditing( item
, renderrect
);
1027 gtk_wx_cell_renderer_get_size (GtkCellRenderer
*renderer
,
1028 GtkWidget
*WXUNUSED(widget
),
1029 GdkRectangle
*cell_area
,
1035 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1036 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1038 wxSize size
= cell
->GetSize();
1040 gint calc_width
= (gint
) renderer
->xpad
* 2 + size
.x
;
1041 gint calc_height
= (gint
) renderer
->ypad
* 2 + size
.y
;
1048 if (cell_area
&& size
.x
> 0 && size
.y
> 0)
1052 *x_offset
= (gint
)((renderer
->xalign
*
1053 (cell_area
->width
- calc_width
- 2 * renderer
->xpad
)));
1054 *x_offset
= MAX (*x_offset
, 0) + renderer
->xpad
;
1058 *y_offset
= (gint
)((renderer
->yalign
*
1059 (cell_area
->height
- calc_height
- 2 * renderer
->ypad
)));
1060 *y_offset
= MAX (*y_offset
, 0) + renderer
->ypad
;
1065 *width
= calc_width
;
1068 *height
= calc_height
;
1072 gtk_wx_cell_renderer_render (GtkCellRenderer
*renderer
,
1075 GdkRectangle
*background_area
,
1076 GdkRectangle
*cell_area
,
1077 GdkRectangle
*expose_area
,
1078 GtkCellRendererState flags
)
1081 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1082 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1084 cell
->window
= window
;
1085 cell
->widget
= widget
;
1086 cell
->background_area
= (void*) background_area
;
1087 cell
->cell_area
= (void*) cell_area
;
1088 cell
->expose_area
= (void*) expose_area
;
1089 cell
->flags
= (int) flags
;
1092 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1098 rect
.x
+= cell_area
->x
;
1099 rect
.y
+= cell_area
->y
;
1100 rect
.width
-= renderer
->xpad
* 2;
1101 rect
.height
-= renderer
->ypad
* 2;
1104 if (gdk_rectangle_intersect (expose_area
, &rect
, &dummy
))
1106 wxRect
renderrect( rect
.x
, rect
.y
, rect
.width
, rect
.height
);
1107 wxWindowDC
* dc
= (wxWindowDC
*) cell
->GetDC();
1108 wxWindowDCImpl
*impl
= (wxWindowDCImpl
*) dc
->GetImpl();
1110 // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1111 // window such as a DnD drop window.
1112 if (window
!= impl
->m_gdkwindow
)
1115 impl
->m_gdkwindow
= window
;
1120 if (flags
& GTK_CELL_RENDERER_SELECTED
)
1121 state
|= wxDATAVIEW_CELL_SELECTED
;
1122 if (flags
& GTK_CELL_RENDERER_PRELIT
)
1123 state
|= wxDATAVIEW_CELL_PRELIT
;
1124 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1125 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1126 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1127 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1128 if (flags
& GTK_CELL_RENDERER_FOCUSED
)
1129 state
|= wxDATAVIEW_CELL_FOCUSED
;
1130 cell
->Render( renderrect
, dc
, state
);
1135 gtk_wx_cell_renderer_activate(
1136 GtkCellRenderer
*renderer
,
1140 GdkRectangle
*WXUNUSED(background_area
),
1141 GdkRectangle
*cell_area
,
1142 GtkCellRendererState
WXUNUSED(flags
) )
1144 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1145 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1148 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1154 rect
.x
+= cell_area
->x
;
1155 rect
.y
+= cell_area
->y
;
1156 rect
.width
-= renderer
->xpad
* 2;
1157 rect
.height
-= renderer
->ypad
* 2;
1159 wxRect
renderrect( rect
.x
, rect
.y
, rect
.width
, rect
.height
);
1161 wxDataViewModel
*model
= cell
->GetOwner()->GetOwner()->GetModel();
1163 GtkTreePath
*treepath
= gtk_tree_path_new_from_string( path
);
1166 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, treepath
);
1167 wxDataViewItem
item( iter
.user_data
);
1168 gtk_tree_path_free( treepath
);
1170 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
1176 // activated by <ENTER>
1177 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1182 else if (event
->type
== GDK_BUTTON_PRESS
)
1184 GdkEventButton
*button_event
= (GdkEventButton
*) event
;
1185 wxPoint
pt( ((int) button_event
->x
) - renderrect
.x
,
1186 ((int) button_event
->y
) - renderrect
.y
);
1189 if (button_event
->button
== 1)
1191 if (cell
->LeftClick( pt
, renderrect
, model
, item
, model_col
))
1193 // TODO: query system double-click time
1194 if (button_event
->time
- wxrenderer
->last_click
< 400)
1195 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1198 wxrenderer
->last_click
= button_event
->time
;
1206 // ---------------------------------------------------------
1207 // wxGtkDataViewModelNotifier
1208 // ---------------------------------------------------------
1210 class wxGtkDataViewModelNotifier
: public wxDataViewModelNotifier
1213 wxGtkDataViewModelNotifier( GtkWxTreeModel
*wxgtk_model
,
1214 wxDataViewModel
*wx_model
,
1215 wxDataViewCtrl
*ctrl
);
1216 ~wxGtkDataViewModelNotifier();
1218 virtual bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1219 virtual bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1220 virtual bool ItemChanged( const wxDataViewItem
&item
);
1221 virtual bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
1222 virtual bool Cleared();
1223 virtual void Resort();
1225 void SetGtkModel( GtkWxTreeModel
*model
) { m_wxgtk_model
= model
; }
1228 GtkWxTreeModel
*m_wxgtk_model
;
1229 wxDataViewModel
*m_wx_model
;
1230 wxDataViewCtrl
*m_owner
;
1233 // ---------------------------------------------------------
1234 // wxGtkDataViewListModelNotifier
1235 // ---------------------------------------------------------
1237 wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
1238 GtkWxTreeModel
* wxgtk_model
, wxDataViewModel
*wx_model
,
1239 wxDataViewCtrl
*ctrl
)
1241 m_wxgtk_model
= wxgtk_model
;
1242 m_wx_model
= wx_model
;
1246 wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
1249 m_wxgtk_model
= NULL
;
1252 bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1254 m_owner
->GtkGetInternal()->ItemAdded( parent
, item
);
1257 iter
.stamp
= m_wxgtk_model
->stamp
;
1258 iter
.user_data
= (gpointer
) item
.GetID();
1260 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1261 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1262 gtk_tree_model_row_inserted(
1263 GTK_TREE_MODEL(m_wxgtk_model
), path
, &iter
);
1264 gtk_tree_path_free (path
);
1269 bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1272 iter
.stamp
= m_wxgtk_model
->stamp
;
1273 iter
.user_data
= (gpointer
) item
.GetID();
1275 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1276 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1277 gtk_tree_model_row_deleted(
1278 GTK_TREE_MODEL(m_wxgtk_model
), path
);
1279 gtk_tree_path_free (path
);
1281 m_owner
->GtkGetInternal()->ItemDeleted( parent
, item
);
1286 void wxGtkDataViewModelNotifier::Resort()
1288 m_owner
->GtkGetInternal()->Resort();
1291 bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem
&item
)
1294 iter
.stamp
= m_wxgtk_model
->stamp
;
1295 iter
.user_data
= (gpointer
) item
.GetID();
1297 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1298 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1299 gtk_tree_model_row_changed(
1300 GTK_TREE_MODEL(m_wxgtk_model
), path
, &iter
);
1301 gtk_tree_path_free (path
);
1303 m_owner
->GtkGetInternal()->ItemChanged( item
);
1308 bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem
&item
, unsigned int model_col
)
1310 // This adds GTK+'s missing MVC logic for ValueChanged
1312 for (index
= 0; index
< m_owner
->GetColumnCount(); index
++)
1314 wxDataViewColumn
*column
= m_owner
->GetColumn( index
);
1315 if (column
->GetModelColumn() == model_col
)
1317 GtkTreeView
*widget
= GTK_TREE_VIEW(m_owner
->m_treeview
);
1318 GtkTreeViewColumn
*gcolumn
= GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle());
1322 iter
.stamp
= m_wxgtk_model
->stamp
;
1323 iter
.user_data
= (gpointer
) item
.GetID();
1324 GtkTreePath
*path
= wxgtk_tree_model_get_path(
1325 GTK_TREE_MODEL(m_wxgtk_model
), &iter
);
1326 GdkRectangle cell_area
;
1327 gtk_tree_view_get_cell_area( widget
, path
, gcolumn
, &cell_area
);
1328 gtk_tree_path_free( path
);
1330 GtkAdjustment
* hadjust
= gtk_tree_view_get_hadjustment( widget
);
1331 double d
= gtk_adjustment_get_value( hadjust
);
1332 int xdiff
= (int) d
;
1334 int ydiff
= gcolumn
->button
->allocation
.height
;
1336 gtk_widget_queue_draw_area( GTK_WIDGET(widget
),
1337 cell_area
.x
- xdiff
, ydiff
+ cell_area
.y
, cell_area
.width
, cell_area
.height
);
1339 m_owner
->GtkGetInternal()->ValueChanged( item
, model_col
);
1348 bool wxGtkDataViewModelNotifier::Cleared()
1350 gtk_tree_view_set_model( GTK_TREE_VIEW(m_owner
->m_treeview
), NULL
);
1352 // this will create a new GTK model
1353 m_owner
->GtkGetInternal()->Cleared();
1355 SetGtkModel( m_owner
->GtkGetInternal()->GetGtkModel() );
1357 gtk_tree_view_set_model( GTK_TREE_VIEW(m_owner
->m_treeview
), GTK_TREE_MODEL(m_wxgtk_model
) );
1362 // ---------------------------------------------------------
1363 // wxDataViewRenderer
1364 // ---------------------------------------------------------
1366 static gpointer s_user_data
= NULL
;
1369 wxgtk_cell_editable_editing_done( GtkCellEditable
*WXUNUSED(editable
),
1370 wxDataViewRenderer
*wxrenderer
)
1372 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1373 wxDataViewCtrl
*dv
= column
->GetOwner();
1374 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE
, dv
->GetId() );
1375 event
.SetDataViewColumn( column
);
1376 event
.SetModel( dv
->GetModel() );
1377 wxDataViewItem
item( s_user_data
);
1378 event
.SetItem( item
);
1379 dv
->HandleWindowEvent( event
);
1383 wxgtk_renderer_editing_started( GtkCellRenderer
*WXUNUSED(cell
), GtkCellEditable
*editable
,
1384 gchar
*path
, wxDataViewRenderer
*wxrenderer
)
1386 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1387 wxDataViewCtrl
*dv
= column
->GetOwner();
1388 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED
, dv
->GetId() );
1389 event
.SetDataViewColumn( column
);
1390 event
.SetModel( dv
->GetModel() );
1391 GtkTreePath
*tree_path
= gtk_tree_path_new_from_string( path
);
1393 dv
->GtkGetInternal()->get_iter( &iter
, tree_path
);
1394 gtk_tree_path_free( tree_path
);
1395 wxDataViewItem
item( iter
.user_data
);
1396 event
.SetItem( item
);
1397 dv
->HandleWindowEvent( event
);
1399 if (GTK_IS_CELL_EDITABLE(editable
))
1401 s_user_data
= iter
.user_data
;
1403 g_signal_connect (GTK_CELL_EDITABLE (editable
), "editing_done",
1404 G_CALLBACK (wxgtk_cell_editable_editing_done
),
1405 (gpointer
) wxrenderer
);
1411 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer
, wxDataViewRendererBase
)
1413 wxDataViewRenderer::wxDataViewRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1415 wxDataViewRendererBase( varianttype
, mode
, align
)
1419 // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1420 // after the m_renderer pointer has been initialized
1423 void wxDataViewRenderer::GtkInitHandlers()
1425 if (!gtk_check_version(2,6,0))
1427 g_signal_connect (GTK_CELL_RENDERER(m_renderer
), "editing_started",
1428 G_CALLBACK (wxgtk_renderer_editing_started
),
1433 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode
)
1435 GtkCellRendererMode gtkMode
;
1438 case wxDATAVIEW_CELL_INERT
:
1439 gtkMode
= GTK_CELL_RENDERER_MODE_INERT
;
1442 case wxDATAVIEW_CELL_ACTIVATABLE
:
1443 gtkMode
= GTK_CELL_RENDERER_MODE_ACTIVATABLE
;
1446 case wxDATAVIEW_CELL_EDITABLE
:
1447 gtkMode
= GTK_CELL_RENDERER_MODE_EDITABLE
;
1451 wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1455 // This value is most often ignored in GtkTreeView
1456 GValue gvalue
= { 0, };
1457 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
1458 g_value_set_enum( &gvalue
, gtkMode
);
1459 g_object_set_property( G_OBJECT(m_renderer
), "mode", &gvalue
);
1460 g_value_unset( &gvalue
);
1463 wxDataViewCellMode
wxDataViewRenderer::GetMode() const
1465 wxDataViewCellMode ret
;
1468 g_object_get( G_OBJECT(m_renderer
), "mode", &gvalue
, NULL
);
1470 switch (g_value_get_enum(&gvalue
))
1473 wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1474 // fall through (we have to return something)
1476 case GTK_CELL_RENDERER_MODE_INERT
:
1477 ret
= wxDATAVIEW_CELL_INERT
;
1480 case GTK_CELL_RENDERER_MODE_ACTIVATABLE
:
1481 ret
= wxDATAVIEW_CELL_ACTIVATABLE
;
1484 case GTK_CELL_RENDERER_MODE_EDITABLE
:
1485 ret
= wxDATAVIEW_CELL_EDITABLE
;
1489 g_value_unset( &gvalue
);
1494 void wxDataViewRenderer::GtkUpdateAlignment()
1496 int align
= m_alignment
;
1498 // query alignment from column ?
1502 if (GetOwner() == NULL
)
1505 align
= GetOwner()->GetAlignment();
1506 align
|= wxALIGN_CENTRE_VERTICAL
;
1509 // horizontal alignment:
1511 gfloat xalign
= 0.0;
1512 if (align
& wxALIGN_RIGHT
)
1514 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
1517 GValue gvalue
= { 0, };
1518 g_value_init( &gvalue
, G_TYPE_FLOAT
);
1519 g_value_set_float( &gvalue
, xalign
);
1520 g_object_set_property( G_OBJECT(m_renderer
), "xalign", &gvalue
);
1521 g_value_unset( &gvalue
);
1523 // vertical alignment:
1525 gfloat yalign
= 0.0;
1526 if (align
& wxALIGN_BOTTOM
)
1528 else if (align
& wxALIGN_CENTER_VERTICAL
)
1531 GValue gvalue2
= { 0, };
1532 g_value_init( &gvalue2
, G_TYPE_FLOAT
);
1533 g_value_set_float( &gvalue2
, yalign
);
1534 g_object_set_property( G_OBJECT(m_renderer
), "yalign", &gvalue2
);
1535 g_value_unset( &gvalue2
);
1538 void wxDataViewRenderer::SetAlignment( int align
)
1540 m_alignment
= align
;
1541 GtkUpdateAlignment();
1544 int wxDataViewRenderer::GetAlignment() const
1549 // ---------------------------------------------------------
1550 // wxDataViewTextRenderer
1551 // ---------------------------------------------------------
1554 static void wxGtkTextRendererEditedCallback( GtkCellRendererText
*renderer
,
1555 gchar
*arg1
, gchar
*arg2
, gpointer user_data
);
1558 static void wxGtkTextRendererEditedCallback( GtkCellRendererText
*WXUNUSED(renderer
),
1559 gchar
*arg1
, gchar
*arg2
, gpointer user_data
)
1561 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) user_data
;
1563 wxString tmp
= wxGTK_CONV_BACK_FONT(arg2
, cell
->GetOwner()->GetOwner()->GetFont());
1564 wxVariant value
= tmp
;
1565 if (!cell
->Validate( value
))
1568 wxDataViewModel
*model
= cell
->GetOwner()->GetOwner()->GetModel();
1570 GtkTreePath
*path
= gtk_tree_path_new_from_string( arg1
);
1572 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, path
);
1573 wxDataViewItem
item( (void*) iter
.user_data
);;
1574 gtk_tree_path_free( path
);
1576 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
1578 model
->SetValue( value
, item
, model_col
);
1579 model
->ValueChanged( item
, model_col
);
1582 IMPLEMENT_CLASS(wxDataViewTextRenderer
, wxDataViewRenderer
)
1584 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1586 wxDataViewRenderer( varianttype
, mode
, align
)
1588 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_text_new();
1590 if (mode
& wxDATAVIEW_CELL_EDITABLE
)
1592 GValue gvalue
= { 0, };
1593 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1594 g_value_set_boolean( &gvalue
, true );
1595 g_object_set_property( G_OBJECT(m_renderer
), "editable", &gvalue
);
1596 g_value_unset( &gvalue
);
1598 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
1604 SetAlignment(align
);
1607 bool wxDataViewTextRenderer::SetValue( const wxVariant
&value
)
1609 wxString tmp
= value
;
1611 GValue gvalue
= { 0, };
1612 g_value_init( &gvalue
, G_TYPE_STRING
);
1613 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( tmp
, GetOwner()->GetOwner()->GetFont() ) );
1614 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
1615 g_value_unset( &gvalue
);
1620 bool wxDataViewTextRenderer::GetValue( wxVariant
&value
) const
1622 GValue gvalue
= { 0, };
1623 g_value_init( &gvalue
, G_TYPE_STRING
);
1624 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
1625 wxString tmp
= wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue
), const_cast<wxDataViewTextRenderer
*>(this)->GetOwner()->GetOwner()->GetFont() );
1626 g_value_unset( &gvalue
);
1633 void wxDataViewTextRenderer::SetAlignment( int align
)
1635 wxDataViewRenderer::SetAlignment(align
);
1637 if (gtk_check_version(2,10,0))
1640 // horizontal alignment:
1641 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
1642 if (align
& wxALIGN_RIGHT
)
1643 pangoAlign
= PANGO_ALIGN_RIGHT
;
1644 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
1645 pangoAlign
= PANGO_ALIGN_CENTER
;
1647 GValue gvalue
= { 0, };
1648 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
1649 g_value_set_enum( &gvalue
, pangoAlign
);
1650 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
1651 g_value_unset( &gvalue
);
1654 // ---------------------------------------------------------
1655 // wxDataViewTextRendererAttr
1656 // ---------------------------------------------------------
1658 IMPLEMENT_CLASS(wxDataViewTextRendererAttr
,wxDataViewTextRenderer
)
1660 wxDataViewTextRendererAttr::wxDataViewTextRendererAttr( const wxString
&varianttype
,
1661 wxDataViewCellMode mode
, int align
) :
1662 wxDataViewTextRenderer( varianttype
, mode
, align
)
1666 // ---------------------------------------------------------
1667 // wxDataViewBitmapRenderer
1668 // ---------------------------------------------------------
1670 IMPLEMENT_CLASS(wxDataViewBitmapRenderer
, wxDataViewRenderer
)
1672 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1674 wxDataViewRenderer( varianttype
, mode
, align
)
1676 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_pixbuf_new();
1679 SetAlignment(align
);
1682 bool wxDataViewBitmapRenderer::SetValue( const wxVariant
&value
)
1684 if (value
.GetType() == wxT("wxBitmap"))
1689 // This may create a Pixbuf representation in the
1690 // wxBitmap object (and it will stay there)
1691 GdkPixbuf
*pixbuf
= bitmap
.GetPixbuf();
1693 GValue gvalue
= { 0, };
1694 g_value_init( &gvalue
, G_TYPE_OBJECT
);
1695 g_value_set_object( &gvalue
, pixbuf
);
1696 g_object_set_property( G_OBJECT(m_renderer
), "pixbuf", &gvalue
);
1697 g_value_unset( &gvalue
);
1702 if (value
.GetType() == wxT("wxIcon"))
1707 // This may create a Pixbuf representation in the
1708 // wxBitmap object (and it will stay there)
1709 GdkPixbuf
*pixbuf
= bitmap
.GetPixbuf();
1711 GValue gvalue
= { 0, };
1712 g_value_init( &gvalue
, G_TYPE_OBJECT
);
1713 g_value_set_object( &gvalue
, pixbuf
);
1714 g_object_set_property( G_OBJECT(m_renderer
), "pixbuf", &gvalue
);
1715 g_value_unset( &gvalue
);
1723 bool wxDataViewBitmapRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
1728 // ---------------------------------------------------------
1729 // wxDataViewToggleRenderer
1730 // ---------------------------------------------------------
1733 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
1734 gchar
*path
, gpointer user_data
);
1737 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
1738 gchar
*path
, gpointer user_data
)
1740 wxDataViewToggleRenderer
*cell
= (wxDataViewToggleRenderer
*) user_data
;
1743 GValue gvalue
= { 0, };
1744 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1745 g_object_get_property( G_OBJECT(renderer
), "active", &gvalue
);
1746 bool tmp
= g_value_get_boolean( &gvalue
);
1747 g_value_unset( &gvalue
);
1751 wxVariant value
= tmp
;
1752 if (!cell
->Validate( value
))
1755 wxDataViewModel
*model
= cell
->GetOwner()->GetOwner()->GetModel();
1757 GtkTreePath
*gtk_path
= gtk_tree_path_new_from_string( path
);
1759 cell
->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter
, gtk_path
);
1760 wxDataViewItem
item( (void*) iter
.user_data
);;
1761 gtk_tree_path_free( gtk_path
);
1763 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
1765 model
->SetValue( value
, item
, model_col
);
1766 model
->ValueChanged( item
, model_col
);
1769 IMPLEMENT_CLASS(wxDataViewToggleRenderer
, wxDataViewRenderer
)
1771 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString
&varianttype
,
1772 wxDataViewCellMode mode
, int align
) :
1773 wxDataViewRenderer( varianttype
, mode
, align
)
1775 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_toggle_new();
1777 if (mode
& wxDATAVIEW_CELL_ACTIVATABLE
)
1779 g_signal_connect_after( m_renderer
, "toggled",
1780 G_CALLBACK(wxGtkToggleRendererToggledCallback
), this );
1784 GValue gvalue
= { 0, };
1785 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1786 g_value_set_boolean( &gvalue
, false );
1787 g_object_set_property( G_OBJECT(m_renderer
), "activatable", &gvalue
);
1788 g_value_unset( &gvalue
);
1792 SetAlignment(align
);
1795 bool wxDataViewToggleRenderer::SetValue( const wxVariant
&value
)
1799 GValue gvalue
= { 0, };
1800 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1801 g_value_set_boolean( &gvalue
, tmp
);
1802 g_object_set_property( G_OBJECT(m_renderer
), "active", &gvalue
);
1803 g_value_unset( &gvalue
);
1808 bool wxDataViewToggleRenderer::GetValue( wxVariant
&value
) const
1810 GValue gvalue
= { 0, };
1811 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1812 g_object_get_property( G_OBJECT(m_renderer
), "active", &gvalue
);
1813 bool tmp
= g_value_get_boolean( &gvalue
);
1814 g_value_unset( &gvalue
);
1821 // ---------------------------------------------------------
1822 // wxDataViewCustomRenderer
1823 // ---------------------------------------------------------
1825 class wxDataViewCtrlDCImpl
: public wxWindowDCImpl
1828 wxDataViewCtrlDCImpl( wxDC
*owner
, wxDataViewCtrl
*window
) :
1829 wxWindowDCImpl( owner
)
1831 GtkWidget
*widget
= window
->m_treeview
;
1837 m_context
= window
->GTKGetPangoDefaultContext();
1838 m_layout
= pango_layout_new( m_context
);
1839 m_fontdesc
= pango_font_description_copy( widget
->style
->font_desc
);
1841 m_cmap
= gtk_widget_get_colormap( widget
? widget
: window
->m_widget
);
1843 // Set m_gdkwindow later
1848 class wxDataViewCtrlDC
: public wxWindowDC
1851 wxDataViewCtrlDC( wxDataViewCtrl
*window
) :
1852 wxWindowDC( new wxDataViewCtrlDCImpl( this, window
) )
1857 // ---------------------------------------------------------
1858 // wxDataViewCustomRenderer
1859 // ---------------------------------------------------------
1861 IMPLEMENT_CLASS(wxDataViewCustomRenderer
, wxDataViewRenderer
)
1863 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString
&varianttype
,
1864 wxDataViewCellMode mode
, int align
,
1866 wxDataViewRenderer( varianttype
, mode
, align
)
1869 m_text_renderer
= NULL
;
1877 void wxDataViewCustomRenderer::RenderText( const wxString
&text
, int xoffset
,
1878 wxRect
WXUNUSED(cell
), wxDC
*WXUNUSED(dc
), int WXUNUSED(state
) )
1881 wxDataViewCtrl
*view
= GetOwner()->GetOwner();
1882 wxColour col
= (state
& wxDATAVIEW_CELL_SELECTED
) ?
1883 wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
) :
1884 view
->GetForegroundColour();
1885 dc
->SetTextForeground(col
);
1886 dc
->DrawText( text
, cell
.x
+ xoffset
, cell
.y
+ ((cell
.height
- dc
->GetCharHeight()) / 2));
1888 if (!m_text_renderer
)
1889 m_text_renderer
= gtk_cell_renderer_text_new();
1891 GValue gvalue
= { 0, };
1892 g_value_init( &gvalue
, G_TYPE_STRING
);
1893 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( text
, GetOwner()->GetOwner()->GetFont() ) );
1894 g_object_set_property( G_OBJECT(m_text_renderer
), "text", &gvalue
);
1895 g_value_unset( &gvalue
);
1897 ((GdkRectangle
*) cell_area
)->x
+= xoffset
;
1898 ((GdkRectangle
*) cell_area
)->width
-= xoffset
;
1900 gtk_cell_renderer_render( m_text_renderer
,
1903 (GdkRectangle
*) background_area
,
1904 (GdkRectangle
*) cell_area
,
1905 (GdkRectangle
*) expose_area
,
1906 (GtkCellRendererState
) flags
);
1908 ((GdkRectangle
*) cell_area
)->x
-= xoffset
;
1909 ((GdkRectangle
*) cell_area
)->width
+= xoffset
;
1913 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode
, int align
)
1915 GtkWxCellRenderer
*renderer
= (GtkWxCellRenderer
*) gtk_wx_cell_renderer_new();
1916 renderer
->cell
= this;
1918 m_renderer
= (GtkCellRenderer
*) renderer
;
1921 SetAlignment(align
);
1928 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
1933 if (m_text_renderer
)
1934 gtk_object_sink( GTK_OBJECT(m_text_renderer
) );
1937 wxDC
*wxDataViewCustomRenderer::GetDC()
1941 if (GetOwner() == NULL
)
1943 if (GetOwner()->GetOwner() == NULL
)
1945 m_dc
= new wxDataViewCtrlDC( GetOwner()->GetOwner() );
1951 // ---------------------------------------------------------
1952 // wxDataViewProgressRenderer
1953 // ---------------------------------------------------------
1955 IMPLEMENT_CLASS(wxDataViewProgressRenderer
, wxDataViewCustomRenderer
)
1957 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString
&label
,
1958 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
1959 wxDataViewCustomRenderer( varianttype
, mode
, align
, true )
1965 if (!gtk_check_version(2,6,0))
1967 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_progress_new();
1969 GValue gvalue
= { 0, };
1970 g_value_init( &gvalue
, G_TYPE_STRING
);
1972 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( m_label
, GetOwner()->GetOwner()->GetFont() ) );
1973 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
1974 g_value_unset( &gvalue
);
1977 SetAlignment(align
);
1982 // Use custom cell code
1983 wxDataViewCustomRenderer::Init(mode
, align
);
1987 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
1991 bool wxDataViewProgressRenderer::SetValue( const wxVariant
&value
)
1994 if (!gtk_check_version(2,6,0))
1996 gint tmp
= (long) value
;
1997 GValue gvalue
= { 0, };
1998 g_value_init( &gvalue
, G_TYPE_INT
);
1999 g_value_set_int( &gvalue
, tmp
);
2000 g_object_set_property( G_OBJECT(m_renderer
), "value", &gvalue
);
2001 g_value_unset( &gvalue
);
2006 m_value
= (long) value
;
2008 if (m_value
< 0) m_value
= 0;
2009 if (m_value
> 100) m_value
= 100;
2015 bool wxDataViewProgressRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2020 bool wxDataViewProgressRenderer::Render( wxRect cell
, wxDC
*dc
, int WXUNUSED(state
) )
2022 double pct
= (double)m_value
/ 100.0;
2024 bar
.width
= (int)(cell
.width
* pct
);
2025 dc
->SetPen( *wxTRANSPARENT_PEN
);
2026 dc
->SetBrush( *wxBLUE_BRUSH
);
2027 dc
->DrawRectangle( bar
);
2029 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
2030 dc
->SetPen( *wxBLACK_PEN
);
2031 dc
->DrawRectangle( cell
);
2036 wxSize
wxDataViewProgressRenderer::GetSize() const
2038 return wxSize(40,12);
2041 // -------------------------------------
2042 // wxDataViewChoiceRenderer
2043 // -------------------------------------
2045 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString
&choices
,
2046 wxDataViewCellMode mode
, int alignment
) :
2047 wxDataViewCustomRenderer( "string", mode
, alignment
, true )
2049 m_choices
= choices
;
2052 if (!gtk_check_version(2,6,0))
2054 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_combo_new();
2056 GtkListStore
*store
= gtk_list_store_new( 1, G_TYPE_STRING
);
2057 for (size_t n
= 0; n
< m_choices
.GetCount(); n
++)
2059 gtk_list_store_insert_with_values(
2061 static_cast<const char *>(m_choices
[n
].utf8_str()), -1 );
2064 g_object_set (m_renderer
,
2070 bool editable
= (mode
& wxDATAVIEW_CELL_EDITABLE
);
2071 g_object_set (m_renderer
, "editable", editable
, NULL
);
2073 SetAlignment(alignment
);
2075 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
2082 // Use custom cell code
2083 wxDataViewCustomRenderer::Init(mode
, alignment
);
2087 bool wxDataViewChoiceRenderer::Render( wxRect rect
, wxDC
*dc
, int state
)
2089 RenderText( m_data
, 0, rect
, dc
, state
);
2093 wxSize
wxDataViewChoiceRenderer::GetSize() const
2095 return wxSize(70,20);
2098 bool wxDataViewChoiceRenderer::SetValue( const wxVariant
&value
)
2102 if (!gtk_check_version(2,6,0))
2104 GValue gvalue
= { 0, };
2105 g_value_init( &gvalue
, G_TYPE_STRING
);
2106 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( value
.GetString(), GetOwner()->GetOwner()->GetFont() ) );
2107 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2108 g_value_unset( &gvalue
);
2112 m_data
= value
.GetString();
2117 bool wxDataViewChoiceRenderer::GetValue( wxVariant
&value
) const
2120 if (!gtk_check_version(2,6,0))
2122 GValue gvalue
= { 0, };
2123 g_value_init( &gvalue
, G_TYPE_STRING
);
2124 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2125 wxString temp
= wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue
),
2126 const_cast<wxDataViewChoiceRenderer
*>(this)->GetOwner()->GetOwner()->GetFont() );
2127 g_value_unset( &gvalue
);
2130 //wxPrintf( "temp %s\n", temp );
2131 // TODO: remove this code
2140 void wxDataViewChoiceRenderer::SetAlignment( int align
)
2142 wxDataViewCustomRenderer::SetAlignment(align
);
2144 if (gtk_check_version(2,10,0))
2147 // horizontal alignment:
2148 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
2149 if (align
& wxALIGN_RIGHT
)
2150 pangoAlign
= PANGO_ALIGN_RIGHT
;
2151 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
2152 pangoAlign
= PANGO_ALIGN_CENTER
;
2154 GValue gvalue
= { 0, };
2155 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
2156 g_value_set_enum( &gvalue
, pangoAlign
);
2157 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
2158 g_value_unset( &gvalue
);
2161 // ---------------------------------------------------------
2162 // wxDataViewDateRenderer
2163 // ---------------------------------------------------------
2165 class wxDataViewDateRendererPopupTransient
: public wxPopupTransientWindow
2168 wxDataViewDateRendererPopupTransient( wxWindow
* parent
, wxDateTime
*value
,
2169 wxDataViewModel
*model
, const wxDataViewItem
&item
, unsigned int col
) :
2170 wxPopupTransientWindow( parent
, wxBORDER_SIMPLE
)
2175 m_cal
= new wxCalendarCtrl( this, -1, *value
);
2176 wxBoxSizer
*sizer
= new wxBoxSizer( wxHORIZONTAL
);
2177 sizer
->Add( m_cal
, 1, wxGROW
);
2182 virtual void OnDismiss()
2186 void OnCalendar( wxCalendarEvent
&event
);
2188 wxCalendarCtrl
*m_cal
;
2189 wxDataViewModel
*m_model
;
2190 wxDataViewItem m_item
;
2194 DECLARE_EVENT_TABLE()
2197 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient
,wxPopupTransientWindow
)
2198 EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient::OnCalendar
)
2201 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent
&event
)
2203 wxDateTime date
= event
.GetDate();
2204 wxVariant value
= date
;
2205 m_model
->SetValue( value
, m_item
, m_col
);
2206 m_model
->ValueChanged( m_item
, m_col
);
2210 IMPLEMENT_CLASS(wxDataViewDateRenderer
, wxDataViewCustomRenderer
)
2212 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString
&varianttype
,
2213 wxDataViewCellMode mode
, int align
) :
2214 wxDataViewCustomRenderer( varianttype
, mode
, align
)
2217 SetAlignment(align
);
2220 bool wxDataViewDateRenderer::SetValue( const wxVariant
&value
)
2222 m_date
= value
.GetDateTime();
2227 bool wxDataViewDateRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2232 bool wxDataViewDateRenderer::Render( wxRect cell
, wxDC
*dc
, int state
)
2234 dc
->SetFont( GetOwner()->GetOwner()->GetFont() );
2235 wxString tmp
= m_date
.FormatDate();
2236 RenderText( tmp
, 0, cell
, dc
, state
);
2240 wxSize
wxDataViewDateRenderer::GetSize() const
2242 wxString tmp
= m_date
.FormatDate();
2244 GetView()->GetTextExtent( tmp
, &x
, &y
, &d
);
2245 return wxSize(x
,y
+d
);
2248 bool wxDataViewDateRenderer::Activate( wxRect
WXUNUSED(cell
), wxDataViewModel
*model
,
2249 const wxDataViewItem
&item
, unsigned int col
)
2252 model
->GetValue( variant
, item
, col
);
2253 wxDateTime value
= variant
.GetDateTime();
2255 wxDataViewDateRendererPopupTransient
*popup
= new wxDataViewDateRendererPopupTransient(
2256 GetOwner()->GetOwner()->GetParent(), &value
, model
, item
, col
);
2257 wxPoint pos
= wxGetMousePosition();
2260 popup
->Popup( popup
->m_cal
);
2266 // ---------------------------------------------------------
2267 // wxDataViewIconTextRenderer
2268 // ---------------------------------------------------------
2270 IMPLEMENT_CLASS(wxDataViewIconTextRenderer
, wxDataViewCustomRenderer
)
2272 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(
2273 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
2274 wxDataViewCustomRenderer( varianttype
, mode
, align
)
2277 SetAlignment(align
);
2280 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
2284 bool wxDataViewIconTextRenderer::SetValue( const wxVariant
&value
)
2290 bool wxDataViewIconTextRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2295 bool wxDataViewIconTextRenderer::Render( wxRect cell
, wxDC
*dc
, int state
)
2297 const wxIcon
&icon
= m_value
.GetIcon();
2301 int yoffset
= wxMax( 0, (cell
.height
- icon
.GetHeight()) / 2 );
2302 dc
->DrawIcon( icon
, cell
.x
, cell
.y
+ yoffset
);
2303 offset
= icon
.GetWidth() + 4;
2306 RenderText( m_value
.GetText(), offset
, cell
, dc
, state
);
2311 wxSize
wxDataViewIconTextRenderer::GetSize() const
2314 if (m_value
.GetIcon().IsOk())
2315 size
.x
= 4 + m_value
.GetIcon().GetWidth();
2317 GetView()->GetTextExtent( m_value
.GetText(), &x
, &y
, &d
);
2323 wxControl
* wxDataViewIconTextRenderer::CreateEditorCtrl(
2324 wxWindow
*WXUNUSED(parent
), wxRect
WXUNUSED(labelRect
), const wxVariant
&WXUNUSED(value
) )
2329 bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl(
2330 wxControl
* WXUNUSED(editor
), wxVariant
&WXUNUSED(value
) )
2335 // ---------------------------------------------------------
2337 // ---------------------------------------------------------
2341 gtk_dataview_header_button_press_callback( GtkWidget
*WXUNUSED(widget
),
2342 GdkEventButton
*gdk_event
,
2343 wxDataViewColumn
*column
)
2345 if (gdk_event
->type
!= GDK_BUTTON_PRESS
)
2348 if (gdk_event
->button
== 1)
2350 gs_lastLeftClickHeader
= column
;
2352 wxDataViewCtrl
*dv
= column
->GetOwner();
2353 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK
, dv
->GetId() );
2354 event
.SetDataViewColumn( column
);
2355 event
.SetModel( dv
->GetModel() );
2356 if (dv
->HandleWindowEvent( event
))
2360 if (gdk_event
->button
== 3)
2362 wxDataViewCtrl
*dv
= column
->GetOwner();
2363 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK
, dv
->GetId() );
2364 event
.SetDataViewColumn( column
);
2365 event
.SetModel( dv
->GetModel() );
2366 if (dv
->HandleWindowEvent( event
))
2374 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn
*column
,
2375 GtkCellRenderer
*cell
,
2376 GtkTreeModel
*model
,
2382 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn
*WXUNUSED(column
),
2383 GtkCellRenderer
*renderer
,
2384 GtkTreeModel
*model
,
2388 g_return_if_fail (GTK_IS_WX_TREE_MODEL (model
));
2389 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) model
;
2391 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) data
;
2393 wxDataViewItem
item( (void*) iter
->user_data
);
2395 wxDataViewModel
*wx_model
= tree_model
->internal
->GetDataViewModel();
2397 if (!wx_model
->IsVirtualListModel())
2400 if (wx_model
->IsContainer( item
))
2402 if (wx_model
->HasContainerColumns( item
) || (cell
->GetOwner()->GetModelColumn() == 0))
2404 GValue gvalue
= { 0, };
2405 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2406 g_value_set_boolean( &gvalue
, TRUE
);
2407 g_object_set_property( G_OBJECT(renderer
), "visible", &gvalue
);
2408 g_value_unset( &gvalue
);
2412 GValue gvalue
= { 0, };
2413 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2414 g_value_set_boolean( &gvalue
, FALSE
);
2415 g_object_set_property( G_OBJECT(renderer
), "visible", &gvalue
);
2416 g_value_unset( &gvalue
);
2423 GValue gvalue
= { 0, };
2424 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2425 g_value_set_boolean( &gvalue
, TRUE
);
2426 g_object_set_property( G_OBJECT(renderer
), "visible", &gvalue
);
2427 g_value_unset( &gvalue
);
2433 wx_model
->GetValue( value
, item
, cell
->GetOwner()->GetModelColumn() );
2435 if (value
.GetType() != cell
->GetVariantType())
2436 wxLogError( wxT("Wrong type, required: %s but: %s"),
2437 value
.GetType().c_str(),
2438 cell
->GetVariantType().c_str() );
2440 cell
->SetValue( value
);
2442 if (cell
->GtkHasAttributes())
2444 wxDataViewItemAttr attr
;
2445 bool colour_set
= false;
2446 bool style_set
= false;
2447 bool weight_set
= false;
2449 if (wx_model
->GetAttr( item
, cell
->GetOwner()->GetModelColumn(), attr
))
2451 // this must be a GtkCellRendererText
2452 wxColour colour
= attr
.GetColour();
2455 const GdkColor
* const gcol
= colour
.GetColor();
2457 GValue gvalue
= { 0, };
2458 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
2459 g_value_set_boxed( &gvalue
, gcol
);
2460 g_object_set_property( G_OBJECT(renderer
), "foreground_gdk", &gvalue
);
2461 g_value_unset( &gvalue
);
2466 if (attr
.GetItalic())
2468 GValue gvalue
= { 0, };
2469 g_value_init( &gvalue
, PANGO_TYPE_STYLE
);
2470 g_value_set_enum( &gvalue
, PANGO_STYLE_ITALIC
);
2471 g_object_set_property( G_OBJECT(renderer
), "style", &gvalue
);
2472 g_value_unset( &gvalue
);
2479 GValue gvalue
= { 0, };
2480 g_value_init( &gvalue
, PANGO_TYPE_WEIGHT
);
2481 g_value_set_enum( &gvalue
, PANGO_WEIGHT_BOLD
);
2482 g_object_set_property( G_OBJECT(renderer
), "weight", &gvalue
);
2483 g_value_unset( &gvalue
);
2491 GValue gvalue
= { 0, };
2492 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2493 g_value_set_boolean( &gvalue
, FALSE
);
2494 g_object_set_property( G_OBJECT(renderer
), "style-set", &gvalue
);
2495 g_value_unset( &gvalue
);
2500 GValue gvalue
= { 0, };
2501 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2502 g_value_set_boolean( &gvalue
, FALSE
);
2503 g_object_set_property( G_OBJECT(renderer
), "weight-set", &gvalue
);
2504 g_value_unset( &gvalue
);
2509 GValue gvalue
= { 0, };
2510 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2511 g_value_set_boolean( &gvalue
, FALSE
);
2512 g_object_set_property( G_OBJECT(renderer
), "foreground-set", &gvalue
);
2513 g_value_unset( &gvalue
);
2518 if (attr
.HasBackgroundColour())
2520 wxColour colour
= attr
.GetBackgroundColour();
2521 const GdkColor
* const gcol
= colour
.GetColor();
2523 GValue gvalue
= { 0, };
2524 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
2525 g_value_set_boxed( &gvalue
, gcol
);
2526 g_object_set_property( G_OBJECT(renderer
), "cell-background_gdk", &gvalue
);
2527 g_value_unset( &gvalue
);
2531 GValue gvalue
= { 0, };
2532 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2533 g_value_set_boolean( &gvalue
, FALSE
);
2534 g_object_set_property( G_OBJECT(renderer
), "cell-background-set", &gvalue
);
2535 g_value_unset( &gvalue
);
2541 #include <wx/listimpl.cpp>
2542 WX_DEFINE_LIST(wxDataViewColumnList
)
2544 wxDataViewColumn::wxDataViewColumn( const wxString
&title
, wxDataViewRenderer
*cell
,
2545 unsigned int model_column
, int width
,
2546 wxAlignment align
, int flags
)
2547 : wxDataViewColumnBase( cell
, model_column
)
2549 Init( align
, flags
, width
);
2554 wxDataViewColumn::wxDataViewColumn( const wxBitmap
&bitmap
, wxDataViewRenderer
*cell
,
2555 unsigned int model_column
, int width
,
2556 wxAlignment align
, int flags
)
2557 : wxDataViewColumnBase( bitmap
, cell
, model_column
)
2559 Init( align
, flags
, width
);
2561 SetBitmap( bitmap
);
2564 void wxDataViewColumn::Init(wxAlignment align
, int flags
, int width
)
2566 m_isConnected
= false;
2568 GtkCellRenderer
*renderer
= (GtkCellRenderer
*) GetRenderer()->GetGtkHandle();
2569 GtkTreeViewColumn
*column
= gtk_tree_view_column_new();
2570 m_column
= (GtkWidget
*) column
;
2573 SetAlignment( align
);
2577 // Create container for icon and label
2578 GtkWidget
*box
= gtk_hbox_new( FALSE
, 1 );
2579 gtk_widget_show( box
);
2580 // gtk_container_set_border_width((GtkContainer*)box, 2);
2581 m_image
= gtk_image_new();
2582 gtk_box_pack_start(GTK_BOX(box
), m_image
, FALSE
, FALSE
, 1);
2583 m_label
= gtk_label_new("");
2584 gtk_box_pack_end( GTK_BOX(box
), GTK_WIDGET(m_label
), FALSE
, FALSE
, 1 );
2585 gtk_tree_view_column_set_widget( column
, box
);
2587 gtk_tree_view_column_pack_end( column
, renderer
, TRUE
);
2589 gtk_tree_view_column_set_cell_data_func( column
, renderer
,
2590 wxGtkTreeCellDataFunc
, (gpointer
) GetRenderer(), NULL
);
2593 void wxDataViewColumn::OnInternalIdle()
2598 if (GTK_WIDGET_REALIZED(GetOwner()->m_treeview
))
2600 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2603 g_signal_connect(column
->button
, "button_press_event",
2604 G_CALLBACK (gtk_dataview_header_button_press_callback
), this);
2606 m_isConnected
= true;
2611 void wxDataViewColumn::SetOwner( wxDataViewCtrl
*owner
)
2613 wxDataViewColumnBase::SetOwner( owner
);
2615 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2617 gtk_tree_view_column_set_title( column
, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
2620 void wxDataViewColumn::SetTitle( const wxString
&title
)
2622 wxDataViewCtrl
*ctrl
= GetOwner();
2623 gtk_label_set_text( GTK_LABEL(m_label
), ctrl
? wxGTK_CONV_FONT(title
, ctrl
->GetFont())
2624 : wxGTK_CONV_SYS(title
) );
2626 gtk_widget_hide( m_label
);
2628 gtk_widget_show( m_label
);
2631 wxString
wxDataViewColumn::GetTitle() const
2633 return wxGTK_CONV_BACK_FONT(
2634 gtk_label_get_text( GTK_LABEL(m_label
) ),
2635 GetOwner()->GetFont()
2639 void wxDataViewColumn::SetBitmap( const wxBitmap
&bitmap
)
2641 wxDataViewColumnBase::SetBitmap( bitmap
);
2645 GtkImage
*gtk_image
= GTK_IMAGE(m_image
);
2647 GdkBitmap
*mask
= NULL
;
2648 if (bitmap
.GetMask())
2649 mask
= bitmap
.GetMask()->GetBitmap();
2651 if (bitmap
.HasPixbuf())
2653 gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image
),
2654 bitmap
.GetPixbuf());
2658 gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image
),
2659 bitmap
.GetPixmap(), mask
);
2661 gtk_widget_show( m_image
);
2665 gtk_widget_hide( m_image
);
2669 void wxDataViewColumn::SetHidden( bool hidden
)
2671 gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column
), !hidden
);
2674 void wxDataViewColumn::SetResizeable( bool resizeable
)
2676 gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column
), resizeable
);
2679 void wxDataViewColumn::SetAlignment( wxAlignment align
)
2681 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2683 gfloat xalign
= 0.0;
2684 if (align
== wxALIGN_RIGHT
)
2686 if (align
== wxALIGN_CENTER_HORIZONTAL
||
2687 align
== wxALIGN_CENTER
)
2690 gtk_tree_view_column_set_alignment( column
, xalign
);
2692 if (m_renderer
&& m_renderer
->GetAlignment() == -1)
2693 m_renderer
->GtkUpdateAlignment();
2696 wxAlignment
wxDataViewColumn::GetAlignment() const
2698 gfloat xalign
= gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column
) );
2701 return wxALIGN_RIGHT
;
2703 return wxALIGN_CENTER_HORIZONTAL
;
2705 return wxALIGN_LEFT
;
2708 void wxDataViewColumn::SetSortable( bool sortable
)
2710 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2714 gtk_tree_view_column_set_sort_column_id( column
, GetModelColumn() );
2718 gtk_tree_view_column_set_sort_column_id( column
, -1 );
2719 gtk_tree_view_column_set_sort_indicator( column
, FALSE
);
2720 gtk_tree_view_column_set_clickable( column
, FALSE
);
2724 bool wxDataViewColumn::IsSortable() const
2726 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2727 return gtk_tree_view_column_get_clickable( column
);
2730 void wxDataViewColumn::SetAsSortKey( bool WXUNUSED(sort
) )
2732 // it might not make sense to have this function in wxHeaderColumn at
2733 // all in fact, changing of the sort order should only be done using the
2734 // associated control API
2735 wxFAIL_MSG( "not implemented" );
2738 bool wxDataViewColumn::IsSortKey() const
2740 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2741 return gtk_tree_view_column_get_sort_indicator( column
);
2744 bool wxDataViewColumn::IsResizeable() const
2746 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2747 return gtk_tree_view_column_get_resizable( column
);
2750 bool wxDataViewColumn::IsHidden() const
2752 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2753 return !gtk_tree_view_column_get_visible( column
);
2756 void wxDataViewColumn::SetSortOrder( bool ascending
)
2758 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2761 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_ASCENDING
);
2763 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_DESCENDING
);
2765 gtk_tree_view_column_set_sort_indicator( column
, TRUE
);
2768 bool wxDataViewColumn::IsSortOrderAscending() const
2770 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2772 return (gtk_tree_view_column_get_sort_order( column
) != GTK_SORT_DESCENDING
);
2775 void wxDataViewColumn::SetMinWidth( int width
)
2777 gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
2780 int wxDataViewColumn::GetMinWidth() const
2782 return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column
) );
2785 int wxDataViewColumn::GetWidth() const
2787 return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column
) );
2790 void wxDataViewColumn::SetWidth( int width
)
2795 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
2797 // TODO find a better calculation
2798 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), wxDVC_DEFAULT_WIDTH
);
2800 // this is unpractical for large numbers of items and disables
2801 // user resizing, which is totally unexpected
2802 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_AUTOSIZE
);
2807 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
2809 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
2813 void wxDataViewColumn::SetReorderable( bool reorderable
)
2815 gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column
), reorderable
);
2818 bool wxDataViewColumn::IsReorderable() const
2820 return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column
) );
2823 //-----------------------------------------------------------------------------
2824 // wxGtkTreeModelNode
2825 //-----------------------------------------------------------------------------
2827 void wxGtkTreeModelNode::Resort()
2829 size_t child_count
= GetChildCount();
2830 if (child_count
== 0)
2833 size_t node_count
= GetNodesCount();
2835 if (child_count
== 1)
2837 if (node_count
== 1)
2839 wxGtkTreeModelNode
*node
= m_nodes
.Item( 0 );
2845 wxGtkTreeModelChildren temp
;
2846 WX_APPEND_ARRAY( temp
, m_children
);
2848 gs_internal
= m_internal
;
2849 m_children
.Sort( &wxGtkTreeModelChildCmp
);
2851 gint
*new_order
= new gint
[child_count
];
2854 for (pos
= 0; pos
< child_count
; pos
++)
2856 void *id
= m_children
.Item( pos
);
2857 int old_pos
= temp
.Index( id
);
2858 new_order
[pos
] = old_pos
;
2861 GtkTreeModel
*gtk_tree_model
= GTK_TREE_MODEL( m_internal
->GetGtkModel() );
2864 iter
.user_data
= GetItem().GetID();
2865 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
2867 GtkTreePath
*path
= m_internal
->get_path( &iter
);
2869 gtk_tree_model_rows_reordered( gtk_tree_model
, path
, &iter
, new_order
);
2871 gtk_tree_path_free (path
);
2873 delete [] new_order
;
2875 for (pos
= 0; pos
< node_count
; pos
++)
2877 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
2882 //-----------------------------------------------------------------------------
2883 // wxDataViewCtrlInternal
2884 //-----------------------------------------------------------------------------
2886 wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl
*owner
,
2887 wxDataViewModel
*wx_model
, GtkWxTreeModel
*gtk_model
)
2890 m_wx_model
= wx_model
;
2891 m_gtk_model
= gtk_model
;
2893 m_sort_order
= GTK_SORT_ASCENDING
;
2895 m_dataview_sort_column
= NULL
;
2897 m_dragDataObject
= NULL
;
2898 m_dropDataObject
= NULL
;
2900 if (!m_wx_model
->IsVirtualListModel())
2904 wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
2906 g_object_unref( m_gtk_model
);
2908 delete m_dragDataObject
;
2909 delete m_dropDataObject
;
2912 void wxDataViewCtrlInternal::InitTree()
2914 wxDataViewItem item
;
2915 m_root
= new wxGtkTreeModelNode( NULL
, item
, this );
2917 BuildBranch( m_root
);
2920 void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode
*node
)
2922 if (node
->GetChildCount() == 0)
2924 wxDataViewItemArray children
;
2925 unsigned int count
= m_wx_model
->GetChildren( node
->GetItem(), children
);
2927 for (pos
= 0; pos
< count
; pos
++)
2929 wxDataViewItem child
= children
[pos
];
2931 if (m_wx_model
->IsContainer( child
))
2932 node
->AddNode( new wxGtkTreeModelNode( node
, child
, this ) );
2934 node
->AddLeave( child
.GetID() );
2936 // Don't send any events here
2943 bool wxDataViewCtrlInternal::EnableDragSource( const wxDataFormat
&format
)
2945 wxGtkString
atom_str( gdk_atom_name( format
) );
2946 m_dragSourceTargetEntryTarget
= wxCharBuffer( atom_str
);
2948 m_dragSourceTargetEntry
.target
= m_dragSourceTargetEntryTarget
.data();
2949 m_dragSourceTargetEntry
.flags
= 0;
2950 m_dragSourceTargetEntry
.info
= static_cast<guint
>(-1);
2952 gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
2953 GDK_BUTTON1_MASK
, &m_dragSourceTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
2958 bool wxDataViewCtrlInternal::EnableDropTarget( const wxDataFormat
&format
)
2960 wxGtkString
atom_str( gdk_atom_name( format
) );
2961 m_dropTargetTargetEntryTarget
= wxCharBuffer( atom_str
);
2963 m_dropTargetTargetEntry
.target
= m_dropTargetTargetEntryTarget
.data();
2964 m_dropTargetTargetEntry
.flags
= 0;
2965 m_dropTargetTargetEntry
.info
= static_cast<guint
>(-1);
2967 gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
2968 &m_dropTargetTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
2973 gboolean
wxDataViewCtrlInternal::row_draggable( GtkTreeDragSource
*WXUNUSED(drag_source
),
2976 delete m_dragDataObject
;
2979 if (!get_iter( &iter
, path
)) return FALSE
;
2980 wxDataViewItem
item( (void*) iter
.user_data
);
2982 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG
, m_owner
->GetId() );
2983 event
.SetEventObject( m_owner
);
2984 event
.SetItem( item
);
2985 event
.SetModel( m_wx_model
);
2986 if (!m_owner
->HandleWindowEvent( event
))
2989 if (!event
.IsAllowed())
2992 wxDataObject
*obj
= event
.GetDataObject();
2996 m_dragDataObject
= obj
;
3002 wxDataViewCtrlInternal::drag_data_delete(GtkTreeDragSource
*WXUNUSED(drag_source
),
3003 GtkTreePath
*WXUNUSED(path
))
3008 gboolean
wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource
*WXUNUSED(drag_source
),
3009 GtkTreePath
*path
, GtkSelectionData
*selection_data
)
3012 if (!get_iter( &iter
, path
)) return FALSE
;
3013 wxDataViewItem
item( (void*) iter
.user_data
);
3015 if (!m_dragDataObject
->IsSupported( selection_data
->target
))
3018 size_t size
= m_dragDataObject
->GetDataSize( selection_data
->target
);
3022 void *buf
= malloc( size
);
3024 gboolean res
= FALSE
;
3025 if (m_dragDataObject
->GetDataHere( selection_data
->target
, buf
))
3029 gtk_selection_data_set( selection_data
, selection_data
->target
,
3030 8, (const guchar
*) buf
, size
);
3039 wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3041 GtkSelectionData
*selection_data
)
3044 if (!get_iter( &iter
, path
)) return FALSE
;
3045 wxDataViewItem
item( (void*) iter
.user_data
);
3047 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP
, m_owner
->GetId() );
3048 event
.SetEventObject( m_owner
);
3049 event
.SetItem( item
);
3050 event
.SetModel( m_wx_model
);
3051 event
.SetDataFormat( selection_data
->target
);
3052 event
.SetDataSize( selection_data
->length
);
3053 event
.SetDataBuffer( selection_data
->data
);
3054 if (!m_owner
->HandleWindowEvent( event
))
3057 if (!event
.IsAllowed())
3064 wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3066 GtkSelectionData
*selection_data
)
3069 if (!get_iter( &iter
, path
)) return FALSE
;
3070 wxDataViewItem
item( (void*) iter
.user_data
);
3072 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE
, m_owner
->GetId() );
3073 event
.SetEventObject( m_owner
);
3074 event
.SetItem( item
);
3075 event
.SetModel( m_wx_model
);
3076 event
.SetDataFormat( selection_data
->target
);
3077 if (!m_owner
->HandleWindowEvent( event
))
3080 if (!event
.IsAllowed())
3086 // notifications from wxDataViewModel
3088 bool wxDataViewCtrlInternal::Cleared()
3096 // Create new GTK model
3097 g_object_unref( m_gtk_model
);
3098 m_gtk_model
= wxgtk_tree_model_new();
3099 m_gtk_model
->internal
= this;
3104 void wxDataViewCtrlInternal::Resort()
3106 if (!m_wx_model
->IsVirtualListModel())
3110 bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3112 if (!m_wx_model
->IsVirtualListModel())
3114 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3115 wxASSERT_MSG(parent_node
,
3116 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3118 if (m_wx_model
->IsContainer( item
))
3119 parent_node
->AddNode( new wxGtkTreeModelNode( parent_node
, item
, this ) );
3121 parent_node
->AddLeave( item
.GetID() );
3127 bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3129 if (!m_wx_model
->IsVirtualListModel())
3131 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3132 wxASSERT_MSG(parent_node
,
3133 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3135 parent_node
->DeleteChild( item
.GetID() );
3141 bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem
&item
)
3143 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3144 event
.SetEventObject( m_owner
);
3145 event
.SetModel( m_owner
->GetModel() );
3146 event
.SetItem( item
);
3147 m_owner
->HandleWindowEvent( event
);
3152 bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem
&item
, unsigned int col
)
3154 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3155 event
.SetEventObject( m_owner
);
3156 event
.SetModel( m_owner
->GetModel() );
3157 event
.SetColumn( col
);
3158 event
.SetDataViewColumn( GetOwner()->GetColumn(col
) );
3159 event
.SetItem( item
);
3160 m_owner
->HandleWindowEvent( event
);
3167 GtkTreeModelFlags
wxDataViewCtrlInternal::get_flags()
3169 if (m_wx_model
->IsVirtualListModel())
3170 return GTK_TREE_MODEL_LIST_ONLY
;
3172 return GTK_TREE_MODEL_ITERS_PERSIST
;
3175 gboolean
wxDataViewCtrlInternal::get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
)
3177 if (m_wx_model
->IsVirtualListModel())
3179 wxDataViewIndexListModel
*wx_model
= (wxDataViewIndexListModel
*) m_wx_model
;
3181 unsigned int i
= (unsigned int)gtk_tree_path_get_indices (path
)[0];
3183 if (i
>= wx_model
->GetLastIndex() + 1)
3186 iter
->stamp
= m_gtk_model
->stamp
;
3187 // user_data is just the index
3188 iter
->user_data
= (gpointer
) i
;
3194 int depth
= gtk_tree_path_get_depth( path
);
3196 wxGtkTreeModelNode
*node
= m_root
;
3199 for (i
= 0; i
< depth
; i
++)
3201 BuildBranch( node
);
3203 gint pos
= gtk_tree_path_get_indices (path
)[i
];
3204 if (pos
< 0) return FALSE
;
3205 if ((size_t)pos
>= node
->GetChildCount()) return FALSE
;
3207 void* id
= node
->GetChildren().Item( (size_t) pos
);
3211 iter
->stamp
= m_gtk_model
->stamp
;
3212 iter
->user_data
= id
;
3216 size_t count
= node
->GetNodes().GetCount();
3218 for (pos2
= 0; pos2
< count
; pos2
++)
3220 wxGtkTreeModelNode
*child_node
= node
->GetNodes().Item( pos2
);
3221 if (child_node
->GetItem().GetID() == id
)
3233 GtkTreePath
*wxDataViewCtrlInternal::get_path( GtkTreeIter
*iter
)
3235 GtkTreePath
*retval
= gtk_tree_path_new ();
3237 if (m_wx_model
->IsVirtualListModel())
3239 // user_data is just the index
3240 int i
= (wxUIntPtr
) iter
->user_data
;
3241 gtk_tree_path_append_index (retval
, i
);
3245 void *id
= iter
->user_data
;
3247 wxGtkTreeModelNode
*node
= FindParentNode( iter
);
3250 int pos
= node
->GetChildren().Index( id
);
3252 gtk_tree_path_prepend_index( retval
, pos
);
3254 id
= node
->GetItem().GetID();
3255 node
= node
->GetParent();
3262 gboolean
wxDataViewCtrlInternal::iter_next( GtkTreeIter
*iter
)
3264 if (m_wx_model
->IsVirtualListModel())
3266 wxDataViewIndexListModel
*wx_model
= (wxDataViewIndexListModel
*) m_wx_model
;
3268 int n
= (wxUIntPtr
) iter
->user_data
;
3273 if (n
>= (int) wx_model
->GetLastIndex())
3276 iter
->user_data
= (gpointer
) ++n
;
3280 wxGtkTreeModelNode
*parent
= FindParentNode( iter
);
3281 if( parent
== NULL
)
3284 int pos
= parent
->GetChildren().Index( iter
->user_data
);
3286 if (pos
== (int) parent
->GetChildCount()-1)
3289 iter
->stamp
= m_gtk_model
->stamp
;
3290 iter
->user_data
= parent
->GetChildren().Item( pos
+1 );
3296 gboolean
wxDataViewCtrlInternal::iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
)
3298 if (m_wx_model
->IsVirtualListModel())
3300 // this is a list, nodes have no children
3304 iter
->stamp
= m_gtk_model
->stamp
;
3305 iter
->user_data
= (gpointer
) -1;
3311 wxDataViewItem
item( (void*) parent
->user_data
);
3313 if (!m_wx_model
->IsContainer( item
))
3316 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3317 wxASSERT_MSG(parent_node
,
3318 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3320 BuildBranch( parent_node
);
3322 if (parent_node
->GetChildCount() == 0)
3325 iter
->stamp
= m_gtk_model
->stamp
;
3326 iter
->user_data
= (gpointer
) parent_node
->GetChildren().Item( 0 );
3332 gboolean
wxDataViewCtrlInternal::iter_has_child( GtkTreeIter
*iter
)
3334 if (m_wx_model
->IsVirtualListModel())
3336 // this is a list, nodes have no children
3341 wxDataViewItem
item( (void*) iter
->user_data
);
3343 bool is_container
= m_wx_model
->IsContainer( item
);
3348 wxGtkTreeModelNode
*node
= FindNode( iter
);
3350 "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
3352 BuildBranch( node
);
3354 return (node
->GetChildCount() > 0);
3358 gint
wxDataViewCtrlInternal::iter_n_children( GtkTreeIter
*iter
)
3360 if (m_wx_model
->IsVirtualListModel())
3362 wxDataViewIndexListModel
*wx_model
= (wxDataViewIndexListModel
*) m_wx_model
;
3365 return (gint
) wx_model
->GetLastIndex() + 1;
3372 return m_root
->GetChildCount();
3374 wxDataViewItem
item( (void*) iter
->user_data
);
3376 if (!m_wx_model
->IsContainer( item
))
3379 wxGtkTreeModelNode
*parent_node
= FindNode( iter
);
3380 wxASSERT_MSG(parent_node
,
3381 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3383 BuildBranch( parent_node
);
3385 // wxPrintf( "iter_n_children %d\n", parent_node->GetChildCount() );
3387 return parent_node
->GetChildCount();
3391 gboolean
wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
)
3393 if (m_wx_model
->IsVirtualListModel())
3395 wxDataViewIndexListModel
*wx_model
= (wxDataViewIndexListModel
*) m_wx_model
;
3403 if (n
>= (gint
) wx_model
->GetLastIndex() + 1)
3406 iter
->stamp
= m_gtk_model
->stamp
;
3407 iter
->user_data
= (gpointer
) n
;
3414 if (parent
) id
= (void*) parent
->user_data
;
3415 wxDataViewItem
item( id
);
3417 if (!m_wx_model
->IsContainer( item
))
3420 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3421 wxASSERT_MSG(parent_node
,
3422 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3424 BuildBranch( parent_node
);
3426 // wxPrintf( "iter_nth_child %d\n", n );
3428 iter
->stamp
= m_gtk_model
->stamp
;
3429 iter
->user_data
= parent_node
->GetChildren().Item( n
);
3435 gboolean
wxDataViewCtrlInternal::iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
)
3437 if (m_wx_model
->IsVirtualListModel())
3443 wxGtkTreeModelNode
*node
= FindParentNode( child
);
3447 iter
->stamp
= m_gtk_model
->stamp
;
3448 iter
->user_data
= (gpointer
) node
->GetItem().GetID();
3454 static wxGtkTreeModelNode
*
3455 wxDataViewCtrlInternal_FindNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
3461 list
.DeleteContents( true );
3462 wxDataViewItem
it( item
);
3466 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
3467 list
.Insert( pItem
);
3468 it
= model
->GetParent( it
);
3471 wxGtkTreeModelNode
* node
= treeNode
;
3472 for( ItemList::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
3474 if( node
&& node
->GetNodes().GetCount() != 0 )
3476 int len
= node
->GetNodes().GetCount();
3477 wxGtkTreeModelNodes nodes
= node
->GetNodes();
3479 for( ; j
< len
; j
++)
3481 if( nodes
[j
]->GetItem() == *(n
->GetData()))
3500 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindNode( GtkTreeIter
*iter
)
3505 wxDataViewItem
item( (void*) iter
->user_data
);
3509 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
3514 wxLogDebug( "Not found %p", iter->user_data );
3518 // TODO: remove this code
3524 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindNode( const wxDataViewItem
&item
)
3529 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
3534 wxLogDebug( "Not found %p", item.GetID() );
3538 // TODO: remove this code
3544 static wxGtkTreeModelNode
*
3545 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
3551 list
.DeleteContents( true );
3555 wxDataViewItem
it( model
->GetParent( item
) );
3558 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
3559 list
.Insert( pItem
);
3560 it
= model
->GetParent( it
);
3563 wxGtkTreeModelNode
* node
= treeNode
;
3564 for( ItemList::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
3566 if( node
&& node
->GetNodes().GetCount() != 0 )
3568 int len
= node
->GetNodes().GetCount();
3569 wxGtkTreeModelNodes nodes
= node
->GetNodes();
3571 for( ; j
< len
; j
++)
3573 if( nodes
[j
]->GetItem() == *(n
->GetData()))
3588 //Examine whether the node is item's parent node
3589 int len
= node
->GetChildCount();
3590 for( int i
= 0; i
< len
; i
++ )
3592 if( node
->GetChildren().Item( i
) == item
.GetID() )
3598 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindParentNode( GtkTreeIter
*iter
)
3603 wxDataViewItem
item( (void*) iter
->user_data
);
3607 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
3610 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindParentNode( const wxDataViewItem
&item
)
3615 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
3618 //-----------------------------------------------------------------------------
3619 // wxDataViewCtrl signal callbacks
3620 //-----------------------------------------------------------------------------
3623 wxdataview_selection_changed_callback( GtkTreeSelection
* WXUNUSED(selection
), wxDataViewCtrl
*dv
)
3625 if (!GTK_WIDGET_REALIZED(dv
->m_widget
))
3628 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED
, dv
->GetId() );
3629 event
.SetItem( dv
->GetSelection() );
3630 event
.SetModel( dv
->GetModel() );
3631 dv
->HandleWindowEvent( event
);
3635 wxdataview_row_activated_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreePath
*path
,
3636 GtkTreeViewColumn
*WXUNUSED(column
), wxDataViewCtrl
*dv
)
3638 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED
, dv
->GetId() );
3641 dv
->GtkGetInternal()->get_iter( &iter
, path
);
3642 wxDataViewItem
item( (void*) iter
.user_data
);;
3643 event
.SetItem( item
);
3644 event
.SetModel( dv
->GetModel() );
3645 dv
->HandleWindowEvent( event
);
3649 wxdataview_test_expand_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3650 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3652 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING
, dv
->GetId() );
3654 wxDataViewItem
item( (void*) iter
->user_data
);;
3655 event
.SetItem( item
);
3656 event
.SetModel( dv
->GetModel() );
3657 dv
->HandleWindowEvent( event
);
3659 return !event
.IsAllowed();
3663 wxdataview_row_expanded_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3664 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3666 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED
, dv
->GetId() );
3668 wxDataViewItem
item( (void*) iter
->user_data
);;
3669 event
.SetItem( item
);
3670 event
.SetModel( dv
->GetModel() );
3671 dv
->HandleWindowEvent( event
);
3675 wxdataview_test_collapse_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3676 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3678 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING
, dv
->GetId() );
3680 wxDataViewItem
item( (void*) iter
->user_data
);;
3681 event
.SetItem( item
);
3682 event
.SetModel( dv
->GetModel() );
3683 dv
->HandleWindowEvent( event
);
3685 return !event
.IsAllowed();
3689 wxdataview_row_collapsed_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
3690 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
3692 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED
, dv
->GetId() );
3694 wxDataViewItem
item( (void*) iter
->user_data
);;
3695 event
.SetItem( item
);
3696 event
.SetModel( dv
->GetModel() );
3697 dv
->HandleWindowEvent( event
);
3700 //-----------------------------------------------------------------------------
3702 //-----------------------------------------------------------------------------
3704 void wxDataViewCtrl::AddChildGTK(wxWindowGTK
* child
)
3706 GtkWidget
* treeview
= GtkGetTreeView();
3708 // Insert widget in GtkTreeView
3709 if (GTK_WIDGET_REALIZED(treeview
))
3710 gtk_widget_set_parent_window( child
->m_widget
,
3711 gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview
) ) );
3712 gtk_widget_set_parent( child
->m_widget
, treeview
);
3716 void gtk_dataviewctrl_size_callback( GtkWidget
*WXUNUSED(widget
),
3717 GtkAllocation
*WXUNUSED(gtk_alloc
),
3718 wxDataViewCtrl
*win
)
3720 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
3723 wxWindow
*child
= node
->GetData();
3726 gtk_widget_size_request( child
->m_widget
, &req
);
3728 GtkAllocation alloc
;
3729 alloc
.x
= child
->m_x
;
3730 alloc
.y
= child
->m_y
;
3731 alloc
.width
= child
->m_width
;
3732 alloc
.height
= child
->m_height
;
3733 gtk_widget_size_allocate( child
->m_widget
, &alloc
);
3735 node
= node
->GetNext();
3740 //-----------------------------------------------------------------------------
3741 // "motion_notify_event"
3742 //-----------------------------------------------------------------------------
3745 gtk_dataview_motion_notify_callback( GtkWidget
*WXUNUSED(widget
),
3746 GdkEventMotion
*gdk_event
,
3747 wxDataViewCtrl
*dv
)
3749 if (gdk_event
->is_hint
)
3753 GdkModifierType state
;
3754 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
3759 GtkTreePath
*path
= NULL
;
3760 GtkTreeViewColumn
*column
= NULL
;
3763 if (gtk_tree_view_get_path_at_pos(
3764 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
3765 (int) gdk_event
->x
, (int) gdk_event
->y
,
3774 dv
->GtkGetInternal()->get_iter( &iter
, path
);
3776 // wxPrintf( "mouse %d %d\n", (int) gdk_event->x, (int) gdk_event->y );
3778 gtk_tree_path_free( path
);
3786 //-----------------------------------------------------------------------------
3787 // "button_press_event"
3788 //-----------------------------------------------------------------------------
3791 gtk_dataview_button_press_callback( GtkWidget
*WXUNUSED(widget
),
3792 GdkEventButton
*gdk_event
,
3793 wxDataViewCtrl
*dv
)
3795 if ((gdk_event
->button
== 3) && (gdk_event
->type
== GDK_BUTTON_PRESS
))
3797 GtkTreePath
*path
= NULL
;
3798 GtkTreeViewColumn
*column
= NULL
;
3801 if (gtk_tree_view_get_path_at_pos(
3802 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
3803 (int) gdk_event
->x
, (int) gdk_event
->y
,
3812 dv
->GtkGetInternal()->get_iter( &iter
, path
);
3814 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU
, dv
->GetId() );
3815 wxDataViewItem
item( (void*) iter
.user_data
);;
3816 event
.SetItem( item
);
3817 event
.SetModel( dv
->GetModel() );
3818 bool ret
= dv
->HandleWindowEvent( event
);
3819 gtk_tree_path_free( path
);
3828 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl
, wxDataViewCtrlBase
)
3830 wxDataViewCtrl::~wxDataViewCtrl()
3833 GetModel()->RemoveNotifier( m_notifier
);
3837 // remove the model from the GtkTreeView before it gets destroyed by the
3838 // wxDataViewCtrlBase's dtor
3839 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview
), NULL
);
3844 void wxDataViewCtrl::Init()
3849 m_cols
.DeleteContents( true );
3852 bool wxDataViewCtrl::Create(wxWindow
*parent
, wxWindowID id
,
3853 const wxPoint
& pos
, const wxSize
& size
,
3854 long style
, const wxValidator
& validator
)
3858 if (!PreCreation( parent
, pos
, size
) ||
3859 !CreateBase( parent
, id
, pos
, size
, style
, validator
))
3861 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
3865 m_widget
= gtk_scrolled_window_new (NULL
, NULL
);
3866 g_object_ref(m_widget
);
3868 GTKScrolledWindowSetBorder(m_widget
, style
);
3870 m_treeview
= gtk_tree_view_new();
3871 gtk_container_add (GTK_CONTAINER (m_widget
), m_treeview
);
3873 g_signal_connect (m_treeview
, "size_allocate",
3874 G_CALLBACK (gtk_dataviewctrl_size_callback
), this);
3877 if (!gtk_check_version(2,6,0))
3879 bool fixed
= (style
& wxDV_VARIABLE_LINE_HEIGHT
) == 0;
3880 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
3884 if (style
& wxDV_MULTIPLE
)
3886 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
3887 gtk_tree_selection_set_mode( selection
, GTK_SELECTION_MULTIPLE
);
3890 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_NO_HEADER
) == 0 );
3893 if (!gtk_check_version(2,10,0))
3895 GtkTreeViewGridLines grid
= GTK_TREE_VIEW_GRID_LINES_NONE
;
3897 if ((style
& wxDV_HORIZ_RULES
) != 0 &&
3898 (style
& wxDV_VERT_RULES
) != 0)
3899 grid
= GTK_TREE_VIEW_GRID_LINES_BOTH
;
3900 else if (style
& wxDV_VERT_RULES
)
3901 grid
= GTK_TREE_VIEW_GRID_LINES_VERTICAL
;
3902 else if (style
& wxDV_HORIZ_RULES
)
3903 grid
= GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
;
3905 if (grid
!= GTK_TREE_VIEW_GRID_LINES_NONE
)
3906 gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview
), grid
);
3910 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_ROW_LINES
) != 0 );
3912 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget
),
3913 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
3914 gtk_widget_show (m_treeview
);
3916 m_parent
->DoAddChild( this );
3920 GtkEnableSelectionEvents();
3922 g_signal_connect_after (m_treeview
, "row-activated",
3923 G_CALLBACK (wxdataview_row_activated_callback
), this);
3925 g_signal_connect (m_treeview
, "test-collapse-row",
3926 G_CALLBACK (wxdataview_test_collapse_row_callback
), this);
3928 g_signal_connect_after (m_treeview
, "row-collapsed",
3929 G_CALLBACK (wxdataview_row_collapsed_callback
), this);
3931 g_signal_connect (m_treeview
, "test-expand-row",
3932 G_CALLBACK (wxdataview_test_expand_row_callback
), this);
3934 g_signal_connect_after (m_treeview
, "row-expanded",
3935 G_CALLBACK (wxdataview_row_expanded_callback
), this);
3937 g_signal_connect (m_treeview
, "motion_notify_event",
3938 G_CALLBACK (gtk_dataview_motion_notify_callback
), this);
3940 g_signal_connect (m_treeview
, "button_press_event",
3941 G_CALLBACK (gtk_dataview_button_press_callback
), this);
3946 void wxDataViewCtrl::OnInternalIdle()
3948 wxWindow::OnInternalIdle();
3950 unsigned int cols
= GetColumnCount();
3952 for (i
= 0; i
< cols
; i
++)
3954 wxDataViewColumn
*col
= GetColumn( i
);
3955 col
->OnInternalIdle();
3959 bool wxDataViewCtrl::AssociateModel( wxDataViewModel
*model
)
3970 if (!wxDataViewCtrlBase::AssociateModel( model
))
3974 if (!gtk_check_version(2,6,0))
3976 bool fixed
= (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT
) == 0) || (model
->IsVirtualListModel()));
3977 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
3981 GtkWxTreeModel
*gtk_model
= wxgtk_tree_model_new();
3982 m_internal
= new wxDataViewCtrlInternal( this, model
, gtk_model
);
3983 gtk_model
->internal
= m_internal
;
3985 m_notifier
= new wxGtkDataViewModelNotifier( gtk_model
, model
, this );
3987 model
->AddNotifier( m_notifier
);
3989 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview
), GTK_TREE_MODEL(gtk_model
) );
3991 // unref in wxDataViewCtrlInternal
3992 // g_object_unref( gtk_model );
3997 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat
&format
)
3999 return m_internal
->EnableDragSource( format
);
4002 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat
&format
)
4004 return m_internal
->EnableDropTarget( format
);
4007 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn
*col
)
4009 if (!wxDataViewCtrlBase::AppendColumn(col
))
4012 m_cols
.Append( col
);
4015 if (!gtk_check_version(2,6,0))
4017 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4018 GTK_TREE_VIEW_COLUMN_FIXED
)
4019 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4023 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview
),
4024 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4029 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn
*col
)
4031 if (!wxDataViewCtrlBase::PrependColumn(col
))
4034 m_cols
.Insert( col
);
4037 if (!gtk_check_version(2,6,0))
4039 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4040 GTK_TREE_VIEW_COLUMN_FIXED
)
4041 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4045 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4046 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), 0 );
4051 bool wxDataViewCtrl::InsertColumn( unsigned int pos
, wxDataViewColumn
*col
)
4053 if (!wxDataViewCtrlBase::InsertColumn(pos
,col
))
4056 m_cols
.Insert( pos
, col
);
4059 if (!gtk_check_version(2,6,0))
4061 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4062 GTK_TREE_VIEW_COLUMN_FIXED
)
4063 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4067 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4068 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), pos
);
4073 unsigned int wxDataViewCtrl::GetColumnCount() const
4075 return m_cols
.GetCount();
4078 wxDataViewColumn
* wxDataViewCtrl::GetColumn( unsigned int pos
) const
4080 GtkTreeViewColumn
*gtk_col
= gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview
), pos
);
4084 wxDataViewColumnList::const_iterator iter
;
4085 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4087 wxDataViewColumn
*col
= *iter
;
4088 if (GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) == gtk_col
)
4097 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn
*column
)
4099 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4100 GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle()) );
4102 m_cols
.DeleteObject( column
);
4107 bool wxDataViewCtrl::ClearColumns()
4109 wxDataViewColumnList::iterator iter
;
4110 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4112 wxDataViewColumn
*col
= *iter
;
4113 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4114 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4122 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn
*column
) const
4124 GtkTreeViewColumn
*gtk_column
= GTK_TREE_VIEW_COLUMN(column
->GetConstGtkHandle());
4126 GList
*list
= gtk_tree_view_get_columns( GTK_TREE_VIEW(m_treeview
) );
4128 gint pos
= g_list_index( list
, (gconstpointer
) gtk_column
);
4130 g_list_free( list
);
4135 wxDataViewColumn
*wxDataViewCtrl::GetSortingColumn() const
4137 return m_internal
->GetDataViewSortColumn();
4140 void wxDataViewCtrl::Expand( const wxDataViewItem
& item
)
4143 iter
.user_data
= item
.GetID();
4144 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4145 gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview
), path
, false );
4146 gtk_tree_path_free( path
);
4149 void wxDataViewCtrl::Collapse( const wxDataViewItem
& item
)
4152 iter
.user_data
= item
.GetID();
4153 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4154 gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview
), path
);
4155 gtk_tree_path_free( path
);
4158 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem
& item
) const
4161 iter
.user_data
= item
.GetID();
4162 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4163 bool res
= gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview
), path
);
4164 gtk_tree_path_free( path
);
4169 wxDataViewItem
wxDataViewCtrl::GetSelection() const
4171 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4173 if (m_windowStyle
& wxDV_MULTIPLE
)
4175 // Report the first one
4176 GtkTreeModel
*model
;
4177 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4181 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4183 m_internal
->get_iter( &iter
, path
);
4186 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4187 g_list_free( list
);
4189 return wxDataViewItem( (void*) iter
.user_data
);
4195 if (gtk_tree_selection_get_selected( selection
, NULL
, &iter
))
4197 wxDataViewItem
item( (void*) iter
.user_data
);
4202 return wxDataViewItem(0);
4205 int wxDataViewCtrl::GetSelections( wxDataViewItemArray
& sel
) const
4209 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4210 if (HasFlag(wxDV_MULTIPLE
))
4212 GtkTreeModel
*model
;
4213 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4218 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4221 m_internal
->get_iter( &iter
, path
);
4223 sel
.Add( wxDataViewItem( (void*) iter
.user_data
) );
4225 list
= g_list_next( list
);
4230 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4231 g_list_free( list
);
4237 GtkTreeModel
*model
;
4239 gboolean has_selection
= gtk_tree_selection_get_selected( selection
, &model
, &iter
);
4242 sel
.Add( wxDataViewItem( (void*) iter
.user_data
) );
4250 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray
& sel
)
4252 GtkDisableSelectionEvents();
4254 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4256 gtk_tree_selection_unselect_all( selection
);
4258 wxDataViewItem last_parent
;
4261 for (i
= 0; i
< sel
.GetCount(); i
++)
4263 wxDataViewItem item
= sel
[i
];
4264 wxDataViewItem parent
= GetModel()->GetParent( item
);
4267 if (parent
!= last_parent
)
4268 ExpandAncestors(item
);
4270 last_parent
= parent
;
4273 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4274 iter
.user_data
= (gpointer
) item
.GetID();
4275 gtk_tree_selection_select_iter( selection
, &iter
);
4278 GtkEnableSelectionEvents();
4281 void wxDataViewCtrl::Select( const wxDataViewItem
& item
)
4283 ExpandAncestors(item
);
4285 GtkDisableSelectionEvents();
4287 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4290 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4291 iter
.user_data
= (gpointer
) item
.GetID();
4292 gtk_tree_selection_select_iter( selection
, &iter
);
4294 GtkEnableSelectionEvents();
4297 void wxDataViewCtrl::Unselect( const wxDataViewItem
& item
)
4299 GtkDisableSelectionEvents();
4301 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4304 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4305 iter
.user_data
= (gpointer
) item
.GetID();
4306 gtk_tree_selection_unselect_iter( selection
, &iter
);
4308 GtkEnableSelectionEvents();
4311 bool wxDataViewCtrl::IsSelected( const wxDataViewItem
& item
) const
4313 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4316 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4317 iter
.user_data
= (gpointer
) item
.GetID();
4319 return gtk_tree_selection_iter_is_selected( selection
, &iter
);
4322 void wxDataViewCtrl::SelectAll()
4324 GtkDisableSelectionEvents();
4326 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4328 gtk_tree_selection_select_all( selection
);
4330 GtkEnableSelectionEvents();
4333 void wxDataViewCtrl::UnselectAll()
4335 GtkDisableSelectionEvents();
4337 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4339 gtk_tree_selection_unselect_all( selection
);
4341 GtkEnableSelectionEvents();
4344 void wxDataViewCtrl::EnsureVisible(const wxDataViewItem
& item
,
4345 const wxDataViewColumn
*WXUNUSED(column
))
4347 ExpandAncestors(item
);
4350 iter
.user_data
= (gpointer
) item
.GetID();
4351 GtkTreePath
*path
= m_internal
->get_path( &iter
);
4352 gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview
), path
, NULL
, false, 0.0, 0.0 );
4353 gtk_tree_path_free( path
);
4356 void wxDataViewCtrl::HitTest(const wxPoint
& WXUNUSED(point
),
4357 wxDataViewItem
& item
,
4358 wxDataViewColumn
*& column
) const
4360 item
= wxDataViewItem(0);
4365 wxDataViewCtrl::GetItemRect(const wxDataViewItem
& WXUNUSED(item
),
4366 const wxDataViewColumn
*WXUNUSED(column
)) const
4371 void wxDataViewCtrl::DoSetExpanderColumn()
4373 gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview
),
4374 GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
4377 void wxDataViewCtrl::DoSetIndent()
4381 void wxDataViewCtrl::GtkDisableSelectionEvents()
4383 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4384 g_signal_handlers_disconnect_by_func( selection
,
4385 (gpointer
) (wxdataview_selection_changed_callback
), this);
4388 void wxDataViewCtrl::GtkEnableSelectionEvents()
4390 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4391 g_signal_connect_after (selection
, "changed",
4392 G_CALLBACK (wxdataview_selection_changed_callback
), this);
4397 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
4399 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new
);
4404 // !wxUSE_GENERICDATAVIEWCTRL
4407 // wxUSE_DATAVIEWCTRL