1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/dataview.cpp
3 // Purpose: wxDataViewCtrl GTK+2 implementation
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 #if wxUSE_DATAVIEWCTRL
15 #include "wx/dataview.h"
17 #ifndef wxUSE_GENERICDATAVIEWCTRL
21 #include "wx/dcclient.h"
23 #include "wx/settings.h"
27 #include "wx/stockitem.h"
28 #include "wx/calctrl.h"
29 #include "wx/popupwin.h"
30 #include "wx/listimpl.cpp"
32 #include "wx/gtk/private.h"
33 #include "wx/gtk/dc.h"
34 #include "wx/gtk/dcclient.h"
36 #include "wx/gtk/private/gdkconv.h"
37 using namespace wxGTKImpl
;
39 class wxGtkDataViewModelNotifier
;
41 //-----------------------------------------------------------------------------
42 //-----------------------------------------------------------------------------
44 static wxDataViewCtrlInternal
*gs_internal
= NULL
;
46 class wxGtkTreeModelNode
;
49 typedef struct _GtkWxTreeModel GtkWxTreeModel
;
52 // ----------------------------------------------------------------------------
53 // wxGtkTreePath: self-destroying GtkTreePath
54 // ----------------------------------------------------------------------------
56 // Usually this object is initialized with the associated GtkTreePath
57 // immediately when it's constructed but it can also be changed later either by
58 // using Assign() or by getting the pointer to the internally stored pointer
59 // value using ByRef(). The latter should be avoided but is very convenient
60 // when using GTK functions with GtkTreePath output parameters.
64 // Ctor takes ownership of the given path and will free it if non-NULL.
65 wxGtkTreePath(GtkTreePath
*path
= NULL
) : m_path(path
) { }
67 // Creates a tree path for the given string path.
68 wxGtkTreePath(const gchar
*strpath
)
69 : m_path(gtk_tree_path_new_from_string(strpath
))
73 // Set the stored pointer if not done by ctor.
74 void Assign(GtkTreePath
*path
)
76 wxASSERT_MSG( !m_path
, "shouldn't be already initialized" );
81 // Return the pointer to the internally stored pointer. This should only be
82 // used to initialize the object by passing it to some GTK function.
85 wxASSERT_MSG( !m_path
, "shouldn't be already initialized" );
91 operator GtkTreePath
*() const { return m_path
; }
93 ~wxGtkTreePath() { if ( m_path
) gtk_tree_path_free(m_path
); }
98 wxDECLARE_NO_COPY_CLASS(wxGtkTreePath
);
101 // ----------------------------------------------------------------------------
102 // wxGtkTreeSelectionLock: prevent selection from changing during the
103 // lifetime of this object
104 // ----------------------------------------------------------------------------
106 // Implementation note: it could be expected that setting the selection
107 // function in this class ctor and resetting it back to the old value in its
108 // dtor would work. However currently gtk_tree_selection_get_select_function()
109 // can't be passed NULL (see https://bugzilla.gnome.org/show_bug.cgi?id=626276)
110 // so we can't do this. Instead, we always use the selection function (which
111 // imposes extra overhead, albeit minimal one, on all selection operations) and
112 // just set/reset the flag telling it whether it should allow or forbid the
115 // Also notice that currently only a single object of this class may exist at
116 // any given moment. It's just simpler like this and we don't need anything
120 gboolean
wxdataview_selection_func(GtkTreeSelection
* WXUNUSED(selection
),
121 GtkTreeModel
* WXUNUSED(model
),
122 GtkTreePath
* WXUNUSED(path
),
123 gboolean
WXUNUSED(path_currently_selected
),
129 class wxGtkTreeSelectionLock
132 wxGtkTreeSelectionLock(GtkTreeSelection
*selection
)
133 : m_selection(selection
)
135 wxASSERT_MSG( !ms_instance
, "this class is not reentrant currently" );
139 CheckCurrentSelectionFunc(NULL
);
141 // Pass some non-NULL pointer as "data" for the callback, it doesn't
142 // matter what it is as long as it's non-NULL.
143 gtk_tree_selection_set_select_function(selection
,
144 wxdataview_selection_func
,
149 ~wxGtkTreeSelectionLock()
151 CheckCurrentSelectionFunc(wxdataview_selection_func
);
153 gtk_tree_selection_set_select_function(m_selection
,
154 wxdataview_selection_func
,
162 void CheckCurrentSelectionFunc(GtkTreeSelectionFunc func
)
164 // We can only use gtk_tree_selection_get_select_function() with 2.14+
165 // so check for its availability both during compile- and run-time.
166 #if GTK_CHECK_VERSION(2, 14, 0)
167 if ( gtk_check_version(2, 14, 0) != NULL
)
170 // If this assert is triggered, it means the code elsewhere has called
171 // gtk_tree_selection_set_select_function() but currently doing this
172 // breaks this class so the code here needs to be changed.
175 gtk_tree_selection_get_select_function(m_selection
) == func
,
176 "selection function has changed unexpectedly, review this code!"
183 static wxGtkTreeSelectionLock
*ms_instance
;
185 GtkTreeSelection
* const m_selection
;
187 wxDECLARE_NO_COPY_CLASS(wxGtkTreeSelectionLock
);
190 wxGtkTreeSelectionLock
*wxGtkTreeSelectionLock
::ms_instance
= NULL
;
192 //-----------------------------------------------------------------------------
193 // wxDataViewCtrlInternal
194 //-----------------------------------------------------------------------------
196 WX_DECLARE_LIST(wxDataViewItem
, ItemList
);
197 WX_DEFINE_LIST(ItemList
)
199 class wxDataViewCtrlInternal
202 wxDataViewCtrlInternal( wxDataViewCtrl
*owner
, wxDataViewModel
*wx_model
);
203 ~wxDataViewCtrlInternal();
206 GtkTreeModelFlags
get_flags();
207 gboolean
get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
);
208 GtkTreePath
*get_path( GtkTreeIter
*iter
);
209 gboolean
iter_next( GtkTreeIter
*iter
);
210 gboolean
iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
);
211 gboolean
iter_has_child( GtkTreeIter
*iter
);
212 gint
iter_n_children( GtkTreeIter
*iter
);
213 gboolean
iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
);
214 gboolean
iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
);
218 bool EnableDragSource( const wxDataFormat
&format
);
219 bool EnableDropTarget( const wxDataFormat
&format
);
221 gboolean
row_draggable( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
);
222 gboolean
drag_data_delete( GtkTreeDragSource
*drag_source
, GtkTreePath
* path
);
223 gboolean
drag_data_get( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
,
224 GtkSelectionData
*selection_data
);
225 gboolean
drag_data_received( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest
,
226 GtkSelectionData
*selection_data
);
227 gboolean
row_drop_possible( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest_path
,
228 GtkSelectionData
*selection_data
);
230 // notifactions from wxDataViewModel
231 bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
232 bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
233 bool ItemChanged( const wxDataViewItem
&item
);
234 bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
236 bool BeforeReset(size_t old_Size
,size_t new_size
);
241 void SetSortOrder( GtkSortType sort_order
) { m_sort_order
= sort_order
; }
242 GtkSortType
GetSortOrder() const { return m_sort_order
; }
244 void SetSortColumn( int column
) { m_sort_column
= column
; }
245 int GetSortColumn() const { return m_sort_column
; }
247 void SetDataViewSortColumn( wxDataViewColumn
*column
) { m_dataview_sort_column
= column
; }
248 wxDataViewColumn
*GetDataViewSortColumn() { return m_dataview_sort_column
; }
250 bool IsSorted() { return (m_sort_column
>= 0); }
253 wxDataViewModel
* GetDataViewModel() { return m_wx_model
; }
254 const wxDataViewModel
* GetDataViewModel() const { return m_wx_model
; }
255 wxDataViewCtrl
* GetOwner() { return m_owner
; }
256 GtkWxTreeModel
* GetGtkModel() { return m_gtk_model
; }
258 // item can be deleted already in the model
259 int GetIndexOf( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
263 wxGtkTreeModelNode
*FindNode( const wxDataViewItem
&item
);
264 wxGtkTreeModelNode
*FindNode( GtkTreeIter
*iter
);
265 wxGtkTreeModelNode
*FindParentNode( const wxDataViewItem
&item
);
266 wxGtkTreeModelNode
*FindParentNode( GtkTreeIter
*iter
);
267 void BuildBranch( wxGtkTreeModelNode
*branch
);
270 wxGtkTreeModelNode
*m_root
;
271 wxDataViewModel
*m_wx_model
;
272 GtkWxTreeModel
*m_gtk_model
;
273 wxDataViewCtrl
*m_owner
;
274 GtkSortType m_sort_order
;
275 wxDataViewColumn
*m_dataview_sort_column
;
278 GtkTargetEntry m_dragSourceTargetEntry
;
279 wxCharBuffer m_dragSourceTargetEntryTarget
;
280 wxDataObject
*m_dragDataObject
;
282 GtkTargetEntry m_dropTargetTargetEntry
;
283 wxCharBuffer m_dropTargetTargetEntryTarget
;
284 wxDataObject
*m_dropDataObject
;
286 wxGtkDataViewModelNotifier
*m_notifier
;
290 //-----------------------------------------------------------------------------
291 // wxGtkTreeModelNode
292 //-----------------------------------------------------------------------------
295 int LINKAGEMODE
wxGtkTreeModelChildCmp( void** id1
, void** id2
)
297 int ret
= gs_internal
->GetDataViewModel()->Compare( *id1
, *id2
,
298 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
303 WX_DEFINE_ARRAY_PTR( wxGtkTreeModelNode
*, wxGtkTreeModelNodes
);
304 WX_DEFINE_ARRAY_PTR( void*, wxGtkTreeModelChildren
);
306 class wxGtkTreeModelNode
309 wxGtkTreeModelNode( wxGtkTreeModelNode
* parent
, const wxDataViewItem
&item
,
310 wxDataViewCtrlInternal
*internal
)
314 m_internal
= internal
;
317 ~wxGtkTreeModelNode()
319 size_t count
= m_nodes
.GetCount();
321 for (i
= 0; i
< count
; i
++)
323 wxGtkTreeModelNode
*child
= m_nodes
.Item( i
);
328 unsigned int AddNode( wxGtkTreeModelNode
* child
)
330 m_nodes
.Add( child
);
332 void *id
= child
->GetItem().GetID();
334 m_children
.Add( id
);
336 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
338 gs_internal
= m_internal
;
339 m_children
.Sort( &wxGtkTreeModelChildCmp
);
340 return m_children
.Index( id
);
343 return m_children
.GetCount()-1;
346 unsigned int AddLeave( void* id
)
348 m_children
.Add( id
);
350 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
352 gs_internal
= m_internal
;
353 m_children
.Sort( &wxGtkTreeModelChildCmp
);
354 return m_children
.Index( id
);
357 return m_children
.GetCount()-1;
360 void DeleteChild( void* id
)
362 m_children
.Remove( id
);
364 unsigned int count
= m_nodes
.GetCount();
366 for (pos
= 0; pos
< count
; pos
++)
368 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
369 if (node
->GetItem().GetID() == id
)
371 m_nodes
.RemoveAt( pos
);
378 wxGtkTreeModelNode
* GetParent()
380 wxGtkTreeModelNodes
&GetNodes()
382 wxGtkTreeModelChildren
&GetChildren()
383 { return m_children
; }
385 unsigned int GetChildCount() const { return m_children
.GetCount(); }
386 unsigned int GetNodesCount() const { return m_nodes
.GetCount(); }
388 wxDataViewItem
&GetItem() { return m_item
; }
389 wxDataViewCtrlInternal
*GetInternal() { return m_internal
; }
394 wxGtkTreeModelNode
*m_parent
;
395 wxGtkTreeModelNodes m_nodes
;
396 wxGtkTreeModelChildren m_children
;
397 wxDataViewItem m_item
;
398 wxDataViewCtrlInternal
*m_internal
;
402 //-----------------------------------------------------------------------------
404 //-----------------------------------------------------------------------------
406 extern bool g_blockEventsOnDrag
;
408 //-----------------------------------------------------------------------------
409 // define new GTK+ class wxGtkTreeModel
410 //-----------------------------------------------------------------------------
414 #define GTK_TYPE_WX_TREE_MODEL (gtk_wx_tree_model_get_type ())
415 #define GTK_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
416 #define GTK_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
417 #define GTK_IS_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
418 #define GTK_IS_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
419 #define GTK_WX_TREE_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
421 GType
gtk_wx_tree_model_get_type (void);
423 typedef struct _GtkWxTreeModelClass GtkWxTreeModelClass
;
425 struct _GtkWxTreeModel
431 wxDataViewCtrlInternal
*internal
;
434 struct _GtkWxTreeModelClass
436 GObjectClass list_parent_class
;
439 static GtkWxTreeModel
*wxgtk_tree_model_new (void);
440 static void wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
);
441 static void wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
);
443 static void wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
);
444 static void wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
);
445 static void wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
);
446 static void wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
);
448 static void wxgtk_tree_model_finalize (GObject
*object
);
449 static GtkTreeModelFlags
wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
);
450 static gint
wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
);
451 static GType
wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
453 static gboolean
wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
456 static GtkTreePath
*wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
458 static void wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
462 static gboolean
wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
464 static gboolean
wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
466 GtkTreeIter
*parent
);
467 static gboolean
wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
469 static gint
wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
471 static gboolean
wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
475 static gboolean
wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
480 static gboolean
wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
481 gint
*sort_column_id
,
483 static void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
486 static void wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
488 GtkTreeIterCompareFunc func
,
490 GtkDestroyNotify destroy
);
491 static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
492 GtkTreeIterCompareFunc func
,
494 GtkDestroyNotify destroy
);
495 static gboolean
wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
);
498 static gboolean
wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
500 static gboolean
wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
502 static gboolean
wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
504 GtkSelectionData
*selection_data
);
505 static gboolean
wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
507 GtkSelectionData
*selection_data
);
508 static gboolean
wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
509 GtkTreePath
*dest_path
,
510 GtkSelectionData
*selection_data
);
513 static GObjectClass
*list_parent_class
= NULL
;
516 gtk_wx_tree_model_get_type (void)
518 static GType tree_model_type
= 0;
520 if (!tree_model_type
)
522 const GTypeInfo tree_model_info
=
524 sizeof (GtkWxTreeModelClass
),
525 NULL
, /* base_init */
526 NULL
, /* base_finalize */
527 (GClassInitFunc
) wxgtk_tree_model_class_init
,
528 NULL
, /* class_finalize */
529 NULL
, /* class_data */
530 sizeof (GtkWxTreeModel
),
532 (GInstanceInitFunc
) wxgtk_tree_model_init
,
535 static const GInterfaceInfo tree_model_iface_info
=
537 (GInterfaceInitFunc
) wxgtk_tree_model_tree_model_init
,
542 static const GInterfaceInfo sortable_iface_info
=
544 (GInterfaceInitFunc
) wxgtk_tree_model_sortable_init
,
549 static const GInterfaceInfo drag_source_iface_info
=
551 (GInterfaceInitFunc
) wxgtk_tree_model_drag_source_init
,
556 static const GInterfaceInfo drag_dest_iface_info
=
558 (GInterfaceInitFunc
) wxgtk_tree_model_drag_dest_init
,
563 tree_model_type
= g_type_register_static (G_TYPE_OBJECT
, "GtkWxTreeModel",
564 &tree_model_info
, (GTypeFlags
)0 );
566 g_type_add_interface_static (tree_model_type
,
568 &tree_model_iface_info
);
569 g_type_add_interface_static (tree_model_type
,
570 GTK_TYPE_TREE_SORTABLE
,
571 &sortable_iface_info
);
572 g_type_add_interface_static (tree_model_type
,
573 GTK_TYPE_TREE_DRAG_DEST
,
574 &drag_dest_iface_info
);
575 g_type_add_interface_static (tree_model_type
,
576 GTK_TYPE_TREE_DRAG_SOURCE
,
577 &drag_source_iface_info
);
580 return tree_model_type
;
583 static GtkWxTreeModel
*
584 wxgtk_tree_model_new(void)
586 GtkWxTreeModel
*retval
= (GtkWxTreeModel
*) g_object_new (GTK_TYPE_WX_TREE_MODEL
, NULL
);
591 wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
)
593 list_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
594 GObjectClass
*object_class
= (GObjectClass
*) klass
;
595 object_class
->finalize
= wxgtk_tree_model_finalize
;
599 wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
)
601 iface
->get_flags
= wxgtk_tree_model_get_flags
;
602 iface
->get_n_columns
= wxgtk_tree_model_get_n_columns
;
603 iface
->get_column_type
= wxgtk_tree_model_get_column_type
;
604 iface
->get_iter
= wxgtk_tree_model_get_iter
;
605 iface
->get_path
= wxgtk_tree_model_get_path
;
606 iface
->get_value
= wxgtk_tree_model_get_value
;
607 iface
->iter_next
= wxgtk_tree_model_iter_next
;
608 iface
->iter_children
= wxgtk_tree_model_iter_children
;
609 iface
->iter_has_child
= wxgtk_tree_model_iter_has_child
;
610 iface
->iter_n_children
= wxgtk_tree_model_iter_n_children
;
611 iface
->iter_nth_child
= wxgtk_tree_model_iter_nth_child
;
612 iface
->iter_parent
= wxgtk_tree_model_iter_parent
;
616 wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
)
618 iface
->get_sort_column_id
= wxgtk_tree_model_get_sort_column_id
;
619 iface
->set_sort_column_id
= wxgtk_tree_model_set_sort_column_id
;
620 iface
->set_sort_func
= wxgtk_tree_model_set_sort_func
;
621 iface
->set_default_sort_func
= wxgtk_tree_model_set_default_sort_func
;
622 iface
->has_default_sort_func
= wxgtk_tree_model_has_default_sort_func
;
626 wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
)
628 iface
->row_draggable
= wxgtk_tree_model_row_draggable
;
629 iface
->drag_data_delete
= wxgtk_tree_model_drag_data_delete
;
630 iface
->drag_data_get
= wxgtk_tree_model_drag_data_get
;
634 wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
)
636 iface
->drag_data_received
= wxgtk_tree_model_drag_data_received
;
637 iface
->row_drop_possible
= wxgtk_tree_model_row_drop_possible
;
641 wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
)
643 tree_model
->internal
= NULL
;
644 tree_model
->stamp
= g_random_int();
648 wxgtk_tree_model_finalize (GObject
*object
)
651 (* list_parent_class
->finalize
) (object
);
656 //-----------------------------------------------------------------------------
657 // implement callbacks from wxGtkTreeModel class by letting
658 // them call the methods of wxWidgets' wxDataViewModel
659 //-----------------------------------------------------------------------------
661 static GtkTreeModelFlags
662 wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
)
664 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
665 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), (GtkTreeModelFlags
)0 );
667 return wxtree_model
->internal
->get_flags();
671 wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
)
673 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
674 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
676 return wxtree_model
->internal
->GetDataViewModel()->GetColumnCount();
680 wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
683 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
684 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), G_TYPE_INVALID
);
686 GType gtype
= G_TYPE_INVALID
;
688 wxString wxtype
= wxtree_model
->internal
->GetDataViewModel()->GetColumnType( (unsigned int) index
);
690 if (wxtype
== wxT("string"))
691 gtype
= G_TYPE_STRING
;
694 gtype
= G_TYPE_POINTER
;
695 // wxFAIL_MSG( wxT("non-string columns not supported for searching yet") );
702 wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
706 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
707 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
708 g_return_val_if_fail (gtk_tree_path_get_depth (path
) > 0, FALSE
);
710 return wxtree_model
->internal
->get_iter( iter
, path
);
714 wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
717 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
718 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), NULL
);
719 g_return_val_if_fail (iter
->stamp
== GTK_WX_TREE_MODEL (wxtree_model
)->stamp
, NULL
);
721 return wxtree_model
->internal
->get_path( iter
);
725 wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
730 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
731 g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
) );
733 wxDataViewModel
*model
= wxtree_model
->internal
->GetDataViewModel();
734 wxString mtype
= model
->GetColumnType( (unsigned int) column
);
735 if (mtype
== wxT("string"))
738 g_value_init( value
, G_TYPE_STRING
);
739 wxDataViewItem
item( (void*) iter
->user_data
);
740 model
->GetValue( variant
, item
, (unsigned int) column
);
742 g_value_set_string( value
, variant
.GetString().utf8_str() );
746 wxFAIL_MSG( wxT("non-string columns not supported yet") );
751 wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
754 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
756 // This happens when clearing the view by calling .._set_model( NULL );
757 if (iter
->stamp
== 0) return FALSE
;
759 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
760 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
762 return wxtree_model
->internal
->iter_next( iter
);
766 wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
770 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
771 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
774 g_return_val_if_fail (wxtree_model
->stamp
== parent
->stamp
, FALSE
);
777 return wxtree_model
->internal
->iter_children( iter
, parent
);
781 wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
784 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
785 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
786 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
788 return wxtree_model
->internal
->iter_has_child( iter
);
792 wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
795 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
796 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
797 g_return_val_if_fail ( !iter
|| wxtree_model
->stamp
== iter
->stamp
, 0);
799 return wxtree_model
->internal
->iter_n_children( iter
);
803 wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
808 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
809 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
811 return wxtree_model
->internal
->iter_nth_child( iter
, parent
, n
);
815 wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
819 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
820 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
821 g_return_val_if_fail (wxtree_model
->stamp
== child
->stamp
, FALSE
);
823 return wxtree_model
->internal
->iter_parent( iter
, child
);
826 /* drag'n'drop iface */
828 wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
831 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
832 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
834 return wxtree_model
->internal
->row_draggable( drag_source
, path
);
838 wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
841 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
842 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
844 return wxtree_model
->internal
->drag_data_delete( drag_source
, path
);
848 wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
850 GtkSelectionData
*selection_data
)
852 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
853 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
856 wxPrintf( "drag_get_data\n");
858 wxGtkString
atom_selection(gdk_atom_name(selection_data
->selection
));
859 wxPrintf( "selection %s\n", wxString
::FromAscii(atom_selection
) );
861 wxGtkString
atom_target(gdk_atom_name(selection_data
->target
));
862 wxPrintf( "target %s\n", wxString
::FromAscii(atom_target
) );
864 wxGtkString
atom_type(gdk_atom_name(selection_data
->type
));
865 wxPrintf( "type %s\n", wxString
::FromAscii(atom_type
) );
867 wxPrintf( "format %d\n", selection_data
->format
);
870 return wxtree_model
->internal
->drag_data_get( drag_source
, path
, selection_data
);
874 wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
876 GtkSelectionData
*selection_data
)
878 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
879 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
881 return wxtree_model
->internal
->drag_data_received( drag_dest
, dest
, selection_data
);
885 wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
886 GtkTreePath
*dest_path
,
887 GtkSelectionData
*selection_data
)
889 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
890 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
892 return wxtree_model
->internal
->row_drop_possible( drag_dest
, dest_path
, selection_data
);
897 wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
898 gint
*sort_column_id
,
901 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) sortable
;
903 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
905 if (!wxtree_model
->internal
->IsSorted())
908 *sort_column_id
= -1;
915 *sort_column_id
= wxtree_model
->internal
->GetSortColumn();
918 *order
= wxtree_model
->internal
->GetSortOrder();
923 wxDataViewColumn
*gs_lastLeftClickHeader
= NULL
;
926 wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
930 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) sortable
;
931 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
933 tree_model
->internal
->SetDataViewSortColumn( gs_lastLeftClickHeader
);
935 if ((sort_column_id
!= (gint
) tree_model
->internal
->GetSortColumn()) ||
936 (order
!= tree_model
->internal
->GetSortOrder()))
938 tree_model
->internal
->SetSortColumn( sort_column_id
);
939 tree_model
->internal
->SetSortOrder( order
);
941 gtk_tree_sortable_sort_column_changed (sortable
);
943 tree_model
->internal
->GetDataViewModel()->Resort();
946 if (gs_lastLeftClickHeader
)
948 wxDataViewCtrl
*dv
= tree_model
->internal
->GetOwner();
949 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED
, dv
->GetId() );
950 event
.SetDataViewColumn( gs_lastLeftClickHeader
);
951 event
.SetModel( dv
->GetModel() );
952 dv
->HandleWindowEvent( event
);
955 gs_lastLeftClickHeader
= NULL
;
959 wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
960 gint
WXUNUSED(sort_column_id
),
961 GtkTreeIterCompareFunc func
,
962 gpointer
WXUNUSED(data
),
963 GtkDestroyNotify
WXUNUSED(destroy
))
965 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
966 g_return_if_fail (func
!= NULL
);
970 wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
971 GtkTreeIterCompareFunc func
,
972 gpointer
WXUNUSED(data
),
973 GtkDestroyNotify
WXUNUSED(destroy
))
975 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
976 g_return_if_fail (func
!= NULL
);
978 //wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
979 // TODO: remove this code
983 wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
)
985 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
990 //-----------------------------------------------------------------------------
991 // define new GTK+ class GtkWxRendererText
992 //-----------------------------------------------------------------------------
996 #define GTK_TYPE_WX_CELL_RENDERER_TEXT (gtk_wx_cell_renderer_text_get_type ())
997 #define GTK_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererText))
998 #define GTK_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
999 #define GTK_IS_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT))
1000 #define GTK_IS_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT))
1001 #define GTK_WX_CELL_RENDERER_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
1003 GType
gtk_wx_cell_renderer_text_get_type (void);
1005 typedef struct _GtkWxCellRendererText GtkWxCellRendererText
;
1006 typedef struct _GtkWxCellRendererTextClass GtkWxCellRendererTextClass
;
1008 struct _GtkWxCellRendererText
1010 GtkCellRendererText parent
;
1012 wxDataViewRenderer
*wx_renderer
;
1015 struct _GtkWxCellRendererTextClass
1017 GtkCellRendererTextClass cell_parent_class
;
1021 static GtkWxCellRendererText
*gtk_wx_cell_renderer_text_new (void);
1022 static void gtk_wx_cell_renderer_text_init (
1023 GtkWxCellRendererText
*cell
);
1024 static void gtk_wx_cell_renderer_text_class_init(
1025 GtkWxCellRendererTextClass
*klass
);
1026 static void gtk_wx_cell_renderer_text_finalize (
1028 static GtkCellEditable
*gtk_wx_cell_renderer_text_start_editing(
1029 GtkCellRenderer
*cell
,
1033 GdkRectangle
*background_area
,
1034 GdkRectangle
*cell_area
,
1035 GtkCellRendererState flags
);
1038 static GObjectClass
*text_cell_parent_class
= NULL
;
1043 gtk_wx_cell_renderer_text_get_type (void)
1045 static GType cell_wx_type
= 0;
1049 const GTypeInfo cell_wx_info
=
1051 sizeof (GtkWxCellRendererTextClass
),
1052 NULL
, /* base_init */
1053 NULL
, /* base_finalize */
1054 (GClassInitFunc
) gtk_wx_cell_renderer_text_class_init
,
1055 NULL
, /* class_finalize */
1056 NULL
, /* class_data */
1057 sizeof (GtkWxCellRendererText
),
1058 0, /* n_preallocs */
1059 (GInstanceInitFunc
) gtk_wx_cell_renderer_text_init
,
1062 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER_TEXT
,
1063 "GtkWxCellRendererText", &cell_wx_info
, (GTypeFlags
)0 );
1066 return cell_wx_type
;
1070 gtk_wx_cell_renderer_text_init (GtkWxCellRendererText
*cell
)
1072 cell
->wx_renderer
= NULL
;
1076 gtk_wx_cell_renderer_text_class_init (GtkWxCellRendererTextClass
*klass
)
1078 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
1079 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
1081 text_cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
1083 object_class
->finalize
= gtk_wx_cell_renderer_text_finalize
;
1085 cell_class
->start_editing
= gtk_wx_cell_renderer_text_start_editing
;
1089 gtk_wx_cell_renderer_text_finalize (GObject
*object
)
1092 (* G_OBJECT_CLASS (text_cell_parent_class
)->finalize
) (object
);
1095 GtkWxCellRendererText
*
1096 gtk_wx_cell_renderer_text_new (void)
1098 return (GtkWxCellRendererText
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER_TEXT
, NULL
);
1101 static GtkCellEditable
*gtk_wx_cell_renderer_text_start_editing(
1102 GtkCellRenderer
*gtk_renderer
,
1103 GdkEvent
*gdk_event
,
1106 GdkRectangle
*background_area
,
1107 GdkRectangle
*cell_area
,
1108 GtkCellRendererState flags
)
1110 GtkWxCellRendererText
*wxgtk_renderer
= (GtkWxCellRendererText
*) gtk_renderer
;
1111 wxDataViewRenderer
*wx_renderer
= wxgtk_renderer
->wx_renderer
;
1112 wxDataViewColumn
*column
= wx_renderer
->GetOwner();
1115 item(column
->GetOwner()->GTKPathToItem(wxGtkTreePath(path
)));
1117 wxDataViewCtrl
*dv
= column
->GetOwner();
1118 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING
, dv
->GetId() );
1119 event
.SetDataViewColumn( column
);
1120 event
.SetModel( dv
->GetModel() );
1121 event
.SetColumn( column
->GetModelColumn() );
1122 event
.SetItem( item
);
1123 dv
->HandleWindowEvent( event
);
1125 if (event
.IsAllowed())
1126 return GTK_CELL_RENDERER_CLASS(text_cell_parent_class
)->
1127 start_editing( gtk_renderer
, gdk_event
, widget
, path
, background_area
, cell_area
, flags
);
1132 //-----------------------------------------------------------------------------
1133 // define new GTK+ class GtkWxCellRenderer
1134 //-----------------------------------------------------------------------------
1138 #define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
1139 #define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
1140 #define GTK_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
1141 #define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
1142 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
1143 #define GTK_WX_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
1145 GType
gtk_wx_cell_renderer_get_type (void);
1147 typedef struct _GtkWxCellRenderer GtkWxCellRenderer
;
1148 typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass
;
1150 struct _GtkWxCellRenderer
1152 GtkCellRenderer parent
;
1155 wxDataViewCustomRenderer
*cell
;
1159 struct _GtkWxCellRendererClass
1161 GtkCellRendererClass cell_parent_class
;
1165 static GtkCellRenderer
*gtk_wx_cell_renderer_new (void);
1166 static void gtk_wx_cell_renderer_init (
1167 GtkWxCellRenderer
*cell
);
1168 static void gtk_wx_cell_renderer_class_init(
1169 GtkWxCellRendererClass
*klass
);
1170 static void gtk_wx_cell_renderer_finalize (
1172 static void gtk_wx_cell_renderer_get_size (
1173 GtkCellRenderer
*cell
,
1175 GdkRectangle
*rectangle
,
1180 static void gtk_wx_cell_renderer_render (
1181 GtkCellRenderer
*cell
,
1184 GdkRectangle
*background_area
,
1185 GdkRectangle
*cell_area
,
1186 GdkRectangle
*expose_area
,
1187 GtkCellRendererState flags
);
1188 static gboolean
gtk_wx_cell_renderer_activate(
1189 GtkCellRenderer
*cell
,
1193 GdkRectangle
*background_area
,
1194 GdkRectangle
*cell_area
,
1195 GtkCellRendererState flags
);
1196 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
1197 GtkCellRenderer
*cell
,
1201 GdkRectangle
*background_area
,
1202 GdkRectangle
*cell_area
,
1203 GtkCellRendererState flags
);
1206 static GObjectClass
*cell_parent_class
= NULL
;
1211 gtk_wx_cell_renderer_get_type (void)
1213 static GType cell_wx_type
= 0;
1217 const GTypeInfo cell_wx_info
=
1219 sizeof (GtkWxCellRendererClass
),
1220 NULL
, /* base_init */
1221 NULL
, /* base_finalize */
1222 (GClassInitFunc
) gtk_wx_cell_renderer_class_init
,
1223 NULL
, /* class_finalize */
1224 NULL
, /* class_data */
1225 sizeof (GtkWxCellRenderer
),
1226 0, /* n_preallocs */
1227 (GInstanceInitFunc
) gtk_wx_cell_renderer_init
,
1230 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER
,
1231 "GtkWxCellRenderer", &cell_wx_info
, (GTypeFlags
)0 );
1234 return cell_wx_type
;
1238 gtk_wx_cell_renderer_init (GtkWxCellRenderer
*cell
)
1241 cell
->last_click
= 0;
1245 gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass
*klass
)
1247 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
1248 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
1250 cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
1252 object_class
->finalize
= gtk_wx_cell_renderer_finalize
;
1254 cell_class
->get_size
= gtk_wx_cell_renderer_get_size
;
1255 cell_class
->render
= gtk_wx_cell_renderer_render
;
1256 cell_class
->activate
= gtk_wx_cell_renderer_activate
;
1257 cell_class
->start_editing
= gtk_wx_cell_renderer_start_editing
;
1261 gtk_wx_cell_renderer_finalize (GObject
*object
)
1264 (* G_OBJECT_CLASS (cell_parent_class
)->finalize
) (object
);
1268 gtk_wx_cell_renderer_new (void)
1270 return (GtkCellRenderer
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER
, NULL
);
1273 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
1274 GtkCellRenderer
*renderer
,
1275 GdkEvent
*WXUNUSED(event
),
1278 GdkRectangle
*WXUNUSED(background_area
),
1279 GdkRectangle
*cell_area
,
1280 GtkCellRendererState
WXUNUSED(flags
) )
1282 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1283 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1285 // Renderer doesn't support in-place editing
1286 if (!cell
->HasEditorCtrl())
1289 // An in-place editing control is still around
1290 if (cell
->GetEditorCtrl())
1294 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1300 rect
.x
+= cell_area
->x
;
1301 rect
.y
+= cell_area
->y
;
1302 // rect.width -= renderer->xpad * 2;
1303 // rect.height -= renderer->ypad * 2;
1305 // wxRect renderrect(wxRectFromGDKRect(&rect));
1306 wxRect
renderrect(wxRectFromGDKRect(cell_area
));
1309 item(cell
->GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(path
)));
1311 cell
->StartEditing( item
, renderrect
);
1317 gtk_wx_cell_renderer_get_size (GtkCellRenderer
*renderer
,
1318 GtkWidget
*WXUNUSED(widget
),
1319 GdkRectangle
*cell_area
,
1325 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1326 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1328 wxSize size
= cell
->GetSize();
1330 gint calc_width
= (gint
) renderer
->xpad
* 2 + size
.x
;
1331 gint calc_height
= (gint
) renderer
->ypad
* 2 + size
.y
;
1338 if (cell_area
&& size
.x
> 0 && size
.y
> 0)
1342 *x_offset
= (gint
)((renderer
->xalign
*
1343 (cell_area
->width
- calc_width
- 2 * renderer
->xpad
)));
1344 *x_offset
= MAX (*x_offset
, 0) + renderer
->xpad
;
1348 *y_offset
= (gint
)((renderer
->yalign
*
1349 (cell_area
->height
- calc_height
- 2 * renderer
->ypad
)));
1350 *y_offset
= MAX (*y_offset
, 0) + renderer
->ypad
;
1355 *width
= calc_width
;
1358 *height
= calc_height
;
1362 gtk_wx_cell_renderer_render (GtkCellRenderer
*renderer
,
1365 GdkRectangle
*background_area
,
1366 GdkRectangle
*cell_area
,
1367 GdkRectangle
*expose_area
,
1368 GtkCellRendererState flags
)
1371 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1372 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1374 cell
->GTKStashRenderParams(window
, widget
,
1375 background_area
, expose_area
, flags
);
1377 wxRect
rect(wxRectFromGDKRect(cell_area
));
1378 rect
= rect
.Deflate(renderer
->xpad
, renderer
->ypad
);
1380 wxWindowDC
* dc
= (wxWindowDC
*) cell
->GetDC();
1381 wxWindowDCImpl
*impl
= (wxWindowDCImpl
*) dc
->GetImpl();
1383 // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1384 // window such as a DnD drop window.
1385 if (window
!= impl
->m_gdkwindow
)
1388 impl
->m_gdkwindow
= window
;
1393 if (flags
& GTK_CELL_RENDERER_SELECTED
)
1394 state
|= wxDATAVIEW_CELL_SELECTED
;
1395 if (flags
& GTK_CELL_RENDERER_PRELIT
)
1396 state
|= wxDATAVIEW_CELL_PRELIT
;
1397 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1398 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1399 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1400 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1401 if (flags
& GTK_CELL_RENDERER_FOCUSED
)
1402 state
|= wxDATAVIEW_CELL_FOCUSED
;
1403 cell
->WXCallRender( rect
, dc
, state
);
1407 gtk_wx_cell_renderer_activate(
1408 GtkCellRenderer
*renderer
,
1412 GdkRectangle
*WXUNUSED(background_area
),
1413 GdkRectangle
*cell_area
,
1414 GtkCellRendererState
WXUNUSED(flags
) )
1416 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1417 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1420 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1426 rect
.x
+= cell_area
->x
;
1427 rect
.y
+= cell_area
->y
;
1428 rect
.width
-= renderer
->xpad
* 2;
1429 rect
.height
-= renderer
->ypad
* 2;
1431 wxRect
renderrect(wxRectFromGDKRect(&rect
));
1433 wxDataViewCtrl
* const ctrl
= cell
->GetOwner()->GetOwner();
1434 wxDataViewModel
*model
= ctrl
->GetModel();
1436 wxDataViewItem
item(ctrl
->GTKPathToItem(wxGtkTreePath(path
)));
1438 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
1444 // activated by <ENTER>
1445 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1450 else if (event
->type
== GDK_BUTTON_PRESS
)
1452 GdkEventButton
*button_event
= (GdkEventButton
*) event
;
1453 wxPoint
pt( ((int) button_event
->x
) - renderrect
.x
,
1454 ((int) button_event
->y
) - renderrect
.y
);
1457 if (button_event
->button
== 1)
1459 if (cell
->LeftClick( pt
, renderrect
, model
, item
, model_col
))
1461 // TODO: query system double-click time
1462 if (button_event
->time
- wxrenderer
->last_click
< 400)
1463 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1466 wxrenderer
->last_click
= button_event
->time
;
1474 // ---------------------------------------------------------
1475 // wxGtkDataViewModelNotifier
1476 // ---------------------------------------------------------
1478 class wxGtkDataViewModelNotifier
: public wxDataViewModelNotifier
1481 wxGtkDataViewModelNotifier( wxDataViewModel
*wx_model
, wxDataViewCtrlInternal
*internal
);
1482 ~wxGtkDataViewModelNotifier();
1484 virtual bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1485 virtual bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1486 virtual bool ItemChanged( const wxDataViewItem
&item
);
1487 virtual bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
1488 virtual bool Cleared();
1489 virtual void Resort();
1490 virtual bool BeforeReset(size_t old_size
,size_t new_size
);
1491 virtual bool AfterReset();
1493 void UpdateLastCount();
1496 wxDataViewModel
*m_wx_model
;
1497 wxDataViewCtrlInternal
*m_internal
;
1500 // ---------------------------------------------------------
1501 // wxGtkDataViewListModelNotifier
1502 // ---------------------------------------------------------
1504 wxGtkDataViewModelNotifier
::wxGtkDataViewModelNotifier(
1505 wxDataViewModel
*wx_model
, wxDataViewCtrlInternal
*internal
)
1507 m_wx_model
= wx_model
;
1508 m_internal
= internal
;
1511 wxGtkDataViewModelNotifier
::~wxGtkDataViewModelNotifier()
1517 bool wxGtkDataViewModelNotifier
::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1519 m_internal
->ItemAdded( parent
, item
);
1520 GtkWxTreeModel
*wxgtk_model
= m_internal
->GetGtkModel();
1523 iter
.stamp
= wxgtk_model
->stamp
;
1524 iter
.user_data
= item
.GetID();
1526 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1527 GTK_TREE_MODEL(wxgtk_model
), &iter
));
1528 gtk_tree_model_row_inserted(
1529 GTK_TREE_MODEL(wxgtk_model
), path
, &iter
);
1534 bool wxGtkDataViewModelNotifier
::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1536 GtkWxTreeModel
*wxgtk_model
= m_internal
->GetGtkModel();
1538 // using _get_path for a deleted item cannot be
1541 iter
.stamp
= wxgtk_model
->stamp
;
1542 iter
.user_data
= (gpointer
) item
.GetID();
1543 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1544 GTK_TREE_MODEL(wxgtk_model
), &iter
));
1546 // so get the path from the parent
1548 iter
.stamp
= wxgtk_model
->stamp
;
1549 iter
.user_data
= (gpointer
) parent
.GetID();
1550 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1551 GTK_TREE_MODEL(wxgtk_model
), &iter
));
1552 // and add the final index ourselves
1553 int index
= m_internal
->GetIndexOf( parent
, item
);
1554 gtk_tree_path_append_index( path
, index
);
1557 gtk_tree_model_row_deleted(
1558 GTK_TREE_MODEL(wxgtk_model
), path
);
1560 m_internal
->ItemDeleted( parent
, item
);
1565 void wxGtkDataViewModelNotifier
::Resort()
1567 m_internal
->Resort();
1570 bool wxGtkDataViewModelNotifier
::ItemChanged( const wxDataViewItem
&item
)
1572 GtkWxTreeModel
*wxgtk_model
= m_internal
->GetGtkModel();
1575 iter
.stamp
= wxgtk_model
->stamp
;
1576 iter
.user_data
= (gpointer
) item
.GetID();
1578 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1579 GTK_TREE_MODEL(wxgtk_model
), &iter
));
1580 gtk_tree_model_row_changed(
1581 GTK_TREE_MODEL(wxgtk_model
), path
, &iter
);
1583 m_internal
->ItemChanged( item
);
1588 bool wxGtkDataViewModelNotifier
::ValueChanged( const wxDataViewItem
&item
, unsigned int model_col
)
1590 GtkWxTreeModel
*wxgtk_model
= m_internal
->GetGtkModel();
1591 wxDataViewCtrl
*ctrl
= m_internal
->GetOwner();
1593 // This adds GTK+'s missing MVC logic for ValueChanged
1595 for (index
= 0; index
< ctrl
->GetColumnCount(); index
++)
1597 wxDataViewColumn
*column
= ctrl
->GetColumn( index
);
1598 if (column
->GetModelColumn() == model_col
)
1600 GtkTreeView
*widget
= GTK_TREE_VIEW(ctrl
->GtkGetTreeView());
1601 GtkTreeViewColumn
*gcolumn
= GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle());
1605 iter
.stamp
= wxgtk_model
->stamp
;
1606 iter
.user_data
= (gpointer
) item
.GetID();
1607 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1608 GTK_TREE_MODEL(wxgtk_model
), &iter
));
1609 GdkRectangle cell_area
;
1610 gtk_tree_view_get_cell_area( widget
, path
, gcolumn
, &cell_area
);
1612 GtkAdjustment
* hadjust
= gtk_tree_view_get_hadjustment( widget
);
1613 double d
= gtk_adjustment_get_value( hadjust
);
1614 int xdiff
= (int) d
;
1616 int ydiff
= gcolumn
->button
->allocation
.height
;
1618 gtk_widget_queue_draw_area( GTK_WIDGET(widget
),
1619 cell_area
.x
- xdiff
, ydiff
+ cell_area
.y
, cell_area
.width
, cell_area
.height
);
1621 m_internal
->ValueChanged( item
, model_col
);
1630 bool wxGtkDataViewModelNotifier
::BeforeReset(size_t WXUNUSED(old_size
), size_t WXUNUSED(new_size
))
1632 GtkWidget
*treeview
= m_internal
->GetOwner()->GtkGetTreeView();
1633 gtk_tree_view_set_model( GTK_TREE_VIEW(treeview
), NULL
);
1638 bool wxGtkDataViewModelNotifier
::AfterReset()
1640 GtkWxTreeModel
*wxgtk_model
= m_internal
->GetGtkModel();
1641 GtkWidget
*treeview
= m_internal
->GetOwner()->GtkGetTreeView();
1643 gtk_tree_view_set_model( GTK_TREE_VIEW(treeview
), GTK_TREE_MODEL(wxgtk_model
) );
1645 m_internal
->Cleared();
1650 bool wxGtkDataViewModelNotifier
::Cleared()
1652 GtkWxTreeModel
*wxgtk_model
= m_internal
->GetGtkModel();
1654 // There is no call to tell the model that everything
1655 // has been deleted so call row_deleted() for every
1658 int count
= m_internal
->iter_n_children( NULL
); // number of children of root
1660 GtkTreePath
*path
= gtk_tree_path_new_first(); // points to root
1663 for (i
= 0; i
< count
; i
++)
1664 gtk_tree_model_row_deleted( GTK_TREE_MODEL(wxgtk_model
), path
);
1666 gtk_tree_path_free( path
);
1668 m_internal
->Cleared();
1673 // ---------------------------------------------------------
1674 // wxDataViewRenderer
1675 // ---------------------------------------------------------
1677 static gpointer s_user_data
= NULL
;
1680 wxgtk_cell_editable_editing_done( GtkCellEditable
*WXUNUSED(editable
),
1681 wxDataViewRenderer
*wxrenderer
)
1683 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1684 wxDataViewCtrl
*dv
= column
->GetOwner();
1685 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE
, dv
->GetId() );
1686 event
.SetDataViewColumn( column
);
1687 event
.SetModel( dv
->GetModel() );
1688 wxDataViewItem
item( s_user_data
);
1689 event
.SetItem( item
);
1690 dv
->HandleWindowEvent( event
);
1694 wxgtk_renderer_editing_started( GtkCellRenderer
*WXUNUSED(cell
), GtkCellEditable
*editable
,
1695 gchar
*path
, wxDataViewRenderer
*wxrenderer
)
1700 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1701 wxDataViewCtrl
*dv
= column
->GetOwner();
1702 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED
, dv
->GetId() );
1703 event
.SetDataViewColumn( column
);
1704 event
.SetModel( dv
->GetModel() );
1705 wxDataViewItem
item(dv
->GTKPathToItem(wxGtkTreePath(path
)));
1706 event
.SetItem( item
);
1707 dv
->HandleWindowEvent( event
);
1709 if (GTK_IS_CELL_EDITABLE(editable
))
1711 s_user_data
= item
.GetID();
1713 g_signal_connect (GTK_CELL_EDITABLE (editable
), "editing_done",
1714 G_CALLBACK (wxgtk_cell_editable_editing_done
),
1715 (gpointer
) wxrenderer
);
1721 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer
, wxDataViewRendererBase
)
1723 wxDataViewRenderer
::wxDataViewRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1725 wxDataViewRendererBase( varianttype
, mode
, align
)
1729 // we haven't changed them yet
1730 m_usingDefaultAttrs
= true;
1732 // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1733 // after the m_renderer pointer has been initialized
1736 void wxDataViewRenderer
::GtkPackIntoColumn(GtkTreeViewColumn
*column
)
1738 gtk_tree_view_column_pack_end( column
, m_renderer
, TRUE
/* expand */);
1741 void wxDataViewRenderer
::GtkInitHandlers()
1743 if (!gtk_check_version(2,6,0))
1745 g_signal_connect (GTK_CELL_RENDERER(m_renderer
), "editing_started",
1746 G_CALLBACK (wxgtk_renderer_editing_started
),
1751 void wxDataViewRenderer
::SetMode( wxDataViewCellMode mode
)
1753 GtkCellRendererMode gtkMode
;
1756 case wxDATAVIEW_CELL_INERT
:
1757 gtkMode
= GTK_CELL_RENDERER_MODE_INERT
;
1760 case wxDATAVIEW_CELL_ACTIVATABLE
:
1761 gtkMode
= GTK_CELL_RENDERER_MODE_ACTIVATABLE
;
1764 case wxDATAVIEW_CELL_EDITABLE
:
1765 gtkMode
= GTK_CELL_RENDERER_MODE_EDITABLE
;
1769 wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1773 // This value is most often ignored in GtkTreeView
1774 GValue gvalue
= { 0, };
1775 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
1776 g_value_set_enum( &gvalue
, gtkMode
);
1777 g_object_set_property( G_OBJECT(m_renderer
), "mode", &gvalue
);
1778 g_value_unset( &gvalue
);
1781 wxDataViewCellMode wxDataViewRenderer
::GetMode() const
1783 wxDataViewCellMode ret
;
1786 g_object_get( G_OBJECT(m_renderer
), "mode", &gvalue
, NULL
);
1788 switch (g_value_get_enum(&gvalue
))
1791 wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1792 // fall through (we have to return something)
1794 case GTK_CELL_RENDERER_MODE_INERT
:
1795 ret
= wxDATAVIEW_CELL_INERT
;
1798 case GTK_CELL_RENDERER_MODE_ACTIVATABLE
:
1799 ret
= wxDATAVIEW_CELL_ACTIVATABLE
;
1802 case GTK_CELL_RENDERER_MODE_EDITABLE
:
1803 ret
= wxDATAVIEW_CELL_EDITABLE
;
1807 g_value_unset( &gvalue
);
1812 void wxDataViewRenderer
::GtkUpdateAlignment()
1814 int align
= m_alignment
;
1816 // query alignment from column ?
1820 if (GetOwner() == NULL
)
1823 align
= GetOwner()->GetAlignment();
1824 align
|= wxALIGN_CENTRE_VERTICAL
;
1827 // horizontal alignment:
1829 gfloat xalign
= 0.0;
1830 if (align
& wxALIGN_RIGHT
)
1832 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
1835 GValue gvalue
= { 0, };
1836 g_value_init( &gvalue
, G_TYPE_FLOAT
);
1837 g_value_set_float( &gvalue
, xalign
);
1838 g_object_set_property( G_OBJECT(m_renderer
), "xalign", &gvalue
);
1839 g_value_unset( &gvalue
);
1841 // vertical alignment:
1843 gfloat yalign
= 0.0;
1844 if (align
& wxALIGN_BOTTOM
)
1846 else if (align
& wxALIGN_CENTER_VERTICAL
)
1849 GValue gvalue2
= { 0, };
1850 g_value_init( &gvalue2
, G_TYPE_FLOAT
);
1851 g_value_set_float( &gvalue2
, yalign
);
1852 g_object_set_property( G_OBJECT(m_renderer
), "yalign", &gvalue2
);
1853 g_value_unset( &gvalue2
);
1856 void wxDataViewRenderer
::SetAlignment( int align
)
1858 m_alignment
= align
;
1859 GtkUpdateAlignment();
1862 int wxDataViewRenderer
::GetAlignment() const
1867 void wxDataViewRenderer
::EnableEllipsize(wxEllipsizeMode mode
)
1870 if ( gtk_check_version(2, 6, 0) != NULL
)
1873 GtkCellRendererText
* const rend
= GtkGetTextRenderer();
1877 // we use the same values in wxEllipsizeMode as PangoEllipsizeMode so we
1878 // can just cast between them
1879 GValue gvalue
= { 0, };
1880 g_value_init( &gvalue
, PANGO_TYPE_ELLIPSIZE_MODE
);
1881 g_value_set_enum( &gvalue
, static_cast<PangoEllipsizeMode
>(mode
) );
1882 g_object_set_property( G_OBJECT(rend
), "ellipsize", &gvalue
);
1883 g_value_unset( &gvalue
);
1886 #endif // GTK 2.6/before
1889 wxEllipsizeMode wxDataViewRenderer
::GetEllipsizeMode() const
1892 if ( gtk_check_version(2, 6, 0) != NULL
)
1893 return wxELLIPSIZE_NONE
;
1895 GtkCellRendererText
* const rend
= GtkGetTextRenderer();
1897 return wxELLIPSIZE_NONE
;
1899 GValue gvalue
= { 0, };
1900 g_value_init( &gvalue
, PANGO_TYPE_ELLIPSIZE_MODE
);
1901 g_object_get_property( G_OBJECT(rend
), "ellipsize", &gvalue
);
1903 mode
= static_cast<wxEllipsizeMode
>(g_value_get_enum( &gvalue
));
1904 g_value_unset( &gvalue
);
1908 return wxELLIPSIZE_NONE
;
1909 #endif // GTK 2.6/before
1913 wxDataViewRenderer
::GtkOnTextEdited(const gchar
*itempath
, const wxString
& str
)
1915 wxVariant
value(str
);
1916 if (!Validate( value
))
1920 item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath
)));
1922 GtkOnCellChanged(value
, item
, GetOwner()->GetModelColumn());
1926 wxDataViewRenderer
::GtkOnCellChanged(const wxVariant
& value
,
1927 const wxDataViewItem
& item
,
1930 wxDataViewModel
*model
= GetOwner()->GetOwner()->GetModel();
1931 model
->ChangeValue( value
, item
, col
);
1934 // ---------------------------------------------------------
1935 // wxDataViewTextRenderer
1936 // ---------------------------------------------------------
1941 static void wxGtkTextRendererEditedCallback( GtkCellRendererText
*WXUNUSED(renderer
),
1942 gchar
*arg1
, gchar
*arg2
, gpointer user_data
)
1944 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) user_data
;
1946 cell
->GtkOnTextEdited(arg1
, wxGTK_CONV_BACK_FONT(
1947 arg2
, cell
->GetOwner()->GetOwner()->GetFont()));
1955 // helper function used by wxDataViewTextRenderer and
1956 // wxDataViewCustomRenderer::RenderText(): it applies the attributes to the
1957 // given text renderer and returns true if anything was done
1958 bool GtkApplyAttr(GtkCellRendererText
*renderer
, const wxDataViewItemAttr
& attr
)
1960 bool usingDefaultAttrs
= true;
1961 if (attr
.HasColour())
1963 const GdkColor
* const gcol
= attr
.GetColour().GetColor();
1965 GValue gvalue
= { 0, };
1966 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
1967 g_value_set_boxed( &gvalue
, gcol
);
1968 g_object_set_property( G_OBJECT(renderer
), "foreground_gdk", &gvalue
);
1969 g_value_unset( &gvalue
);
1971 usingDefaultAttrs
= false;
1975 GValue gvalue
= { 0, };
1976 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1977 g_value_set_boolean( &gvalue
, FALSE
);
1978 g_object_set_property( G_OBJECT(renderer
), "foreground-set", &gvalue
);
1979 g_value_unset( &gvalue
);
1982 if (attr
.GetItalic())
1984 GValue gvalue
= { 0, };
1985 g_value_init( &gvalue
, PANGO_TYPE_STYLE
);
1986 g_value_set_enum( &gvalue
, PANGO_STYLE_ITALIC
);
1987 g_object_set_property( G_OBJECT(renderer
), "style", &gvalue
);
1988 g_value_unset( &gvalue
);
1990 usingDefaultAttrs
= false;
1994 GValue gvalue
= { 0, };
1995 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1996 g_value_set_boolean( &gvalue
, FALSE
);
1997 g_object_set_property( G_OBJECT(renderer
), "style-set", &gvalue
);
1998 g_value_unset( &gvalue
);
2004 GValue gvalue
= { 0, };
2005 g_value_init( &gvalue
, PANGO_TYPE_WEIGHT
);
2006 g_value_set_enum( &gvalue
, PANGO_WEIGHT_BOLD
);
2007 g_object_set_property( G_OBJECT(renderer
), "weight", &gvalue
);
2008 g_value_unset( &gvalue
);
2010 usingDefaultAttrs
= false;
2014 GValue gvalue
= { 0, };
2015 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2016 g_value_set_boolean( &gvalue
, FALSE
);
2017 g_object_set_property( G_OBJECT(renderer
), "weight-set", &gvalue
);
2018 g_value_unset( &gvalue
);
2022 if (attr
.HasBackgroundColour())
2024 wxColour colour
= attr
.GetBackgroundColour();
2025 const GdkColor
* const gcol
= colour
.GetColor();
2027 GValue gvalue
= { 0, };
2028 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
2029 g_value_set_boxed( &gvalue
, gcol
);
2030 g_object_set_property( G_OBJECT(renderer
), "cell-background_gdk", &gvalue
);
2031 g_value_unset( &gvalue
);
2035 GValue gvalue
= { 0, };
2036 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2037 g_value_set_boolean( &gvalue
, FALSE
);
2038 g_object_set_property( G_OBJECT(renderer
), "cell-background-set", &gvalue
);
2039 g_value_unset( &gvalue
);
2043 return !usingDefaultAttrs
;
2046 } // anonymous namespace
2048 IMPLEMENT_CLASS(wxDataViewTextRenderer
, wxDataViewRenderer
)
2050 wxDataViewTextRenderer
::wxDataViewTextRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
2052 wxDataViewRenderer( varianttype
, mode
, align
)
2054 GtkWxCellRendererText
*text_renderer
= gtk_wx_cell_renderer_text_new();
2055 text_renderer
->wx_renderer
= this;
2056 m_renderer
= (GtkCellRenderer
*) text_renderer
;
2058 if (mode
& wxDATAVIEW_CELL_EDITABLE
)
2060 GValue gvalue
= { 0, };
2061 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2062 g_value_set_boolean( &gvalue
, true );
2063 g_object_set_property( G_OBJECT(m_renderer
), "editable", &gvalue
);
2064 g_value_unset( &gvalue
);
2066 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
2072 SetAlignment(align
);
2075 bool wxDataViewTextRenderer
::SetTextValue(const wxString
& str
)
2077 GValue gvalue
= { 0, };
2078 g_value_init( &gvalue
, G_TYPE_STRING
);
2079 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( str
, GetOwner()->GetOwner()->GetFont() ) );
2080 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2081 g_value_unset( &gvalue
);
2086 bool wxDataViewTextRenderer
::GetTextValue(wxString
& str
) const
2088 GValue gvalue
= { 0, };
2089 g_value_init( &gvalue
, G_TYPE_STRING
);
2090 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2091 str
= wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue
), const_cast<wxDataViewTextRenderer
*>(this)->GetOwner()->GetOwner()->GetFont() );
2092 g_value_unset( &gvalue
);
2097 void wxDataViewTextRenderer
::SetAlignment( int align
)
2099 wxDataViewRenderer
::SetAlignment(align
);
2101 if (gtk_check_version(2,10,0))
2104 // horizontal alignment:
2105 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
2106 if (align
& wxALIGN_RIGHT
)
2107 pangoAlign
= PANGO_ALIGN_RIGHT
;
2108 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
2109 pangoAlign
= PANGO_ALIGN_CENTER
;
2111 GValue gvalue
= { 0, };
2112 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
2113 g_value_set_enum( &gvalue
, pangoAlign
);
2114 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
2115 g_value_unset( &gvalue
);
2118 bool wxDataViewTextRenderer
::GtkSetAttr(const wxDataViewItemAttr
& attr
)
2120 return GtkApplyAttr(GtkGetTextRenderer(), attr
);
2123 GtkCellRendererText
*wxDataViewTextRenderer
::GtkGetTextRenderer() const
2125 return GTK_CELL_RENDERER_TEXT(m_renderer
);
2128 // ---------------------------------------------------------
2129 // wxDataViewBitmapRenderer
2130 // ---------------------------------------------------------
2135 // set "pixbuf" property on the given renderer
2136 void SetPixbufProp(GtkCellRenderer
*renderer
, GdkPixbuf
*pixbuf
)
2138 GValue gvalue
= { 0, };
2139 g_value_init( &gvalue
, G_TYPE_OBJECT
);
2140 g_value_set_object( &gvalue
, pixbuf
);
2141 g_object_set_property( G_OBJECT(renderer
), "pixbuf", &gvalue
);
2142 g_value_unset( &gvalue
);
2145 } // anonymous namespace
2147 IMPLEMENT_CLASS(wxDataViewBitmapRenderer
, wxDataViewRenderer
)
2149 wxDataViewBitmapRenderer
::wxDataViewBitmapRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
2151 wxDataViewRenderer( varianttype
, mode
, align
)
2153 m_renderer
= gtk_cell_renderer_pixbuf_new();
2156 SetAlignment(align
);
2159 bool wxDataViewBitmapRenderer
::SetValue( const wxVariant
&value
)
2161 if (value
.GetType() == wxT("wxBitmap"))
2166 // GetPixbuf() may create a Pixbuf representation in the wxBitmap
2167 // object (and it will stay there and remain owned by wxBitmap)
2168 SetPixbufProp(m_renderer
, bitmap
.GetPixbuf());
2170 else if (value
.GetType() == wxT("wxIcon"))
2175 SetPixbufProp(m_renderer
, icon
.GetPixbuf());
2185 bool wxDataViewBitmapRenderer
::GetValue( wxVariant
&WXUNUSED(value
) ) const
2190 // ---------------------------------------------------------
2191 // wxDataViewToggleRenderer
2192 // ---------------------------------------------------------
2195 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
2196 gchar
*path
, gpointer user_data
);
2199 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
2200 gchar
*path
, gpointer user_data
)
2202 wxDataViewToggleRenderer
*cell
= (wxDataViewToggleRenderer
*) user_data
;
2205 GValue gvalue
= { 0, };
2206 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2207 g_object_get_property( G_OBJECT(renderer
), "active", &gvalue
);
2208 bool tmp
= g_value_get_boolean( &gvalue
);
2209 g_value_unset( &gvalue
);
2213 wxVariant value
= tmp
;
2214 if (!cell
->Validate( value
))
2217 wxDataViewCtrl
* const ctrl
= cell
->GetOwner()->GetOwner();
2218 wxDataViewModel
*model
= ctrl
->GetModel();
2220 wxDataViewItem
item(ctrl
->GTKPathToItem(wxGtkTreePath(path
)));
2222 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
2224 model
->ChangeValue( value
, item
, model_col
);
2227 IMPLEMENT_CLASS(wxDataViewToggleRenderer
, wxDataViewRenderer
)
2229 wxDataViewToggleRenderer
::wxDataViewToggleRenderer( const wxString
&varianttype
,
2230 wxDataViewCellMode mode
, int align
) :
2231 wxDataViewRenderer( varianttype
, mode
, align
)
2233 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_toggle_new();
2235 if (mode
& wxDATAVIEW_CELL_ACTIVATABLE
)
2237 g_signal_connect_after( m_renderer
, "toggled",
2238 G_CALLBACK(wxGtkToggleRendererToggledCallback
), this );
2242 GValue gvalue
= { 0, };
2243 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2244 g_value_set_boolean( &gvalue
, false );
2245 g_object_set_property( G_OBJECT(m_renderer
), "activatable", &gvalue
);
2246 g_value_unset( &gvalue
);
2250 SetAlignment(align
);
2253 bool wxDataViewToggleRenderer
::SetValue( const wxVariant
&value
)
2257 GValue gvalue
= { 0, };
2258 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2259 g_value_set_boolean( &gvalue
, tmp
);
2260 g_object_set_property( G_OBJECT(m_renderer
), "active", &gvalue
);
2261 g_value_unset( &gvalue
);
2266 bool wxDataViewToggleRenderer
::GetValue( wxVariant
&value
) const
2268 GValue gvalue
= { 0, };
2269 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2270 g_object_get_property( G_OBJECT(m_renderer
), "active", &gvalue
);
2271 bool tmp
= g_value_get_boolean( &gvalue
);
2272 g_value_unset( &gvalue
);
2279 // ---------------------------------------------------------
2280 // wxDataViewCustomRenderer
2281 // ---------------------------------------------------------
2283 class wxDataViewCtrlDCImpl
: public wxWindowDCImpl
2286 wxDataViewCtrlDCImpl( wxDC
*owner
, wxDataViewCtrl
*window
) :
2287 wxWindowDCImpl( owner
)
2289 GtkWidget
*widget
= window
->m_treeview
;
2295 m_context
= window
->GTKGetPangoDefaultContext();
2296 m_layout
= pango_layout_new( m_context
);
2297 m_fontdesc
= pango_font_description_copy( widget
->style
->font_desc
);
2299 m_cmap
= gtk_widget_get_colormap( widget ? widget
: window
->m_widget
);
2301 // Set m_gdkwindow later
2306 class wxDataViewCtrlDC
: public wxWindowDC
2309 wxDataViewCtrlDC( wxDataViewCtrl
*window
) :
2310 wxWindowDC( new wxDataViewCtrlDCImpl( this, window
) )
2315 // ---------------------------------------------------------
2316 // wxDataViewCustomRenderer
2317 // ---------------------------------------------------------
2319 IMPLEMENT_CLASS(wxDataViewCustomRenderer
, wxDataViewRenderer
)
2321 wxDataViewCustomRenderer
::wxDataViewCustomRenderer( const wxString
&varianttype
,
2322 wxDataViewCellMode mode
,
2325 : wxDataViewCustomRendererBase( varianttype
, mode
, align
)
2328 m_text_renderer
= NULL
;
2336 GtkCellRendererText
*wxDataViewCustomRenderer
::GtkGetTextRenderer() const
2338 if ( !m_text_renderer
)
2340 // we create it on demand so need to do it even from a const function
2341 const_cast<wxDataViewCustomRenderer
*>(this)->
2342 m_text_renderer
= GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
2345 return m_text_renderer
;
2348 void wxDataViewCustomRenderer
::RenderText( const wxString
&text
,
2352 int WXUNUSED(state
) )
2355 GtkCellRendererText
* const textRenderer
= GtkGetTextRenderer();
2357 GValue gvalue
= { 0, };
2358 g_value_init( &gvalue
, G_TYPE_STRING
);
2359 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( text
, GetOwner()->GetOwner()->GetFont() ) );
2360 g_object_set_property( G_OBJECT(textRenderer
), "text", &gvalue
);
2361 g_value_unset( &gvalue
);
2363 GtkApplyAttr(textRenderer
, GetAttr());
2365 GdkRectangle cell_area
;
2366 wxRectToGDKRect(cell
, cell_area
);
2367 cell_area
.x
+= xoffset
;
2368 cell_area
.width
-= xoffset
;
2370 gtk_cell_renderer_render( GTK_CELL_RENDERER(textRenderer
),
2371 m_renderParams
.window
,
2372 m_renderParams
.widget
,
2373 m_renderParams
.background_area
,
2375 m_renderParams
.expose_area
,
2376 (GtkCellRendererState
) m_renderParams
.flags
);
2379 bool wxDataViewCustomRenderer
::Init(wxDataViewCellMode mode
, int align
)
2381 GtkWxCellRenderer
*renderer
= (GtkWxCellRenderer
*) gtk_wx_cell_renderer_new();
2382 renderer
->cell
= this;
2384 m_renderer
= (GtkCellRenderer
*) renderer
;
2387 SetAlignment(align
);
2394 wxDataViewCustomRenderer
::~wxDataViewCustomRenderer()
2399 if (m_text_renderer
)
2400 gtk_object_sink( GTK_OBJECT(m_text_renderer
) );
2403 wxDC
*wxDataViewCustomRenderer
::GetDC()
2407 if (GetOwner() == NULL
)
2409 if (GetOwner()->GetOwner() == NULL
)
2411 m_dc
= new wxDataViewCtrlDC( GetOwner()->GetOwner() );
2417 // ---------------------------------------------------------
2418 // wxDataViewProgressRenderer
2419 // ---------------------------------------------------------
2421 IMPLEMENT_CLASS(wxDataViewProgressRenderer
, wxDataViewCustomRenderer
)
2423 wxDataViewProgressRenderer
::wxDataViewProgressRenderer( const wxString
&label
,
2424 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
2425 wxDataViewCustomRenderer( varianttype
, mode
, align
, true )
2431 if (!gtk_check_version(2,6,0))
2433 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_progress_new();
2435 GValue gvalue
= { 0, };
2436 g_value_init( &gvalue
, G_TYPE_STRING
);
2438 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( m_label
, GetOwner()->GetOwner()->GetFont() ) );
2439 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2440 g_value_unset( &gvalue
);
2443 SetAlignment(align
);
2448 // Use custom cell code
2449 wxDataViewCustomRenderer
::Init(mode
, align
);
2453 wxDataViewProgressRenderer
::~wxDataViewProgressRenderer()
2457 bool wxDataViewProgressRenderer
::SetValue( const wxVariant
&value
)
2460 if (!gtk_check_version(2,6,0))
2462 gint tmp
= (long) value
;
2463 GValue gvalue
= { 0, };
2464 g_value_init( &gvalue
, G_TYPE_INT
);
2465 g_value_set_int( &gvalue
, tmp
);
2466 g_object_set_property( G_OBJECT(m_renderer
), "value", &gvalue
);
2467 g_value_unset( &gvalue
);
2472 m_value
= (long) value
;
2474 if (m_value
< 0) m_value
= 0;
2475 if (m_value
> 100) m_value
= 100;
2481 bool wxDataViewProgressRenderer
::GetValue( wxVariant
&WXUNUSED(value
) ) const
2486 bool wxDataViewProgressRenderer
::Render( wxRect cell
, wxDC
*dc
, int WXUNUSED(state
) )
2488 double pct
= (double)m_value
/ 100.0;
2490 bar
.width
= (int)(cell
.width
* pct
);
2491 dc
->SetPen( *wxTRANSPARENT_PEN
);
2492 dc
->SetBrush( *wxBLUE_BRUSH
);
2493 dc
->DrawRectangle( bar
);
2495 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
2496 dc
->SetPen( *wxBLACK_PEN
);
2497 dc
->DrawRectangle( cell
);
2502 wxSize wxDataViewProgressRenderer
::GetSize() const
2504 return wxSize(40,12);
2507 // -------------------------------------
2508 // wxDataViewChoiceRenderer
2509 // -------------------------------------
2511 wxDataViewChoiceRenderer
::wxDataViewChoiceRenderer( const wxArrayString
&choices
,
2512 wxDataViewCellMode mode
, int alignment
) :
2513 wxDataViewCustomRenderer( "string", mode
, alignment
, true )
2515 m_choices
= choices
;
2518 if (!gtk_check_version(2,6,0))
2520 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_combo_new();
2522 GtkListStore
*store
= gtk_list_store_new( 1, G_TYPE_STRING
);
2523 for (size_t n
= 0; n
< m_choices
.GetCount(); n
++)
2525 gtk_list_store_insert_with_values(
2527 static_cast<const char *>(m_choices
[n
].utf8_str()), -1 );
2530 g_object_set (m_renderer
,
2536 bool editable
= (mode
& wxDATAVIEW_CELL_EDITABLE
);
2537 g_object_set (m_renderer
, "editable", editable
, NULL
);
2539 SetAlignment(alignment
);
2541 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
2548 // Use custom cell code
2549 wxDataViewCustomRenderer
::Init(mode
, alignment
);
2553 bool wxDataViewChoiceRenderer
::Render( wxRect rect
, wxDC
*dc
, int state
)
2555 RenderText( m_data
, 0, rect
, dc
, state
);
2559 wxSize wxDataViewChoiceRenderer
::GetSize() const
2561 return wxSize(70,20);
2564 bool wxDataViewChoiceRenderer
::SetValue( const wxVariant
&value
)
2568 if (!gtk_check_version(2,6,0))
2570 GValue gvalue
= { 0, };
2571 g_value_init( &gvalue
, G_TYPE_STRING
);
2572 g_value_set_string(&gvalue
,
2573 wxGTK_CONV_FONT(value
.GetString(),
2574 GetOwner()->GetOwner()->GetFont()));
2575 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2576 g_value_unset( &gvalue
);
2580 m_data
= value
.GetString();
2585 bool wxDataViewChoiceRenderer
::GetValue( wxVariant
&value
) const
2588 if (!gtk_check_version(2,6,0))
2590 GValue gvalue
= { 0, };
2591 g_value_init( &gvalue
, G_TYPE_STRING
);
2592 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2593 wxString temp
= wxGTK_CONV_BACK_FONT(g_value_get_string(&gvalue
),
2594 GetOwner()->GetOwner()->GetFont());
2595 g_value_unset( &gvalue
);
2598 //wxPrintf( "temp %s\n", temp );
2599 // TODO: remove this code
2608 void wxDataViewChoiceRenderer
::SetAlignment( int align
)
2610 wxDataViewCustomRenderer
::SetAlignment(align
);
2612 if (gtk_check_version(2,10,0))
2615 // horizontal alignment:
2616 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
2617 if (align
& wxALIGN_RIGHT
)
2618 pangoAlign
= PANGO_ALIGN_RIGHT
;
2619 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
2620 pangoAlign
= PANGO_ALIGN_CENTER
;
2622 GValue gvalue
= { 0, };
2623 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
2624 g_value_set_enum( &gvalue
, pangoAlign
);
2625 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
2626 g_value_unset( &gvalue
);
2629 // ----------------------------------------------------------------------------
2630 // wxDataViewChoiceByIndexRenderer
2631 // ----------------------------------------------------------------------------
2633 wxDataViewChoiceByIndexRenderer
::wxDataViewChoiceByIndexRenderer( const wxArrayString
&choices
,
2634 wxDataViewCellMode mode
, int alignment
) :
2635 wxDataViewChoiceRenderer( choices
, mode
, alignment
)
2639 void wxDataViewChoiceByIndexRenderer
::GtkOnTextEdited(const gchar
*itempath
, const wxString
& str
)
2641 wxVariant
value( (long) GetChoices().Index( str
) );
2643 if (!Validate( value
))
2647 item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath
)));
2649 GtkOnCellChanged(value
, item
, GetOwner()->GetModelColumn());
2652 bool wxDataViewChoiceByIndexRenderer
::SetValue( const wxVariant
&value
)
2654 wxVariant string_value
= GetChoice( value
.GetLong() );
2655 return wxDataViewChoiceRenderer
::SetValue( string_value
);
2658 bool wxDataViewChoiceByIndexRenderer
::GetValue( wxVariant
&value
) const
2660 wxVariant string_value
;
2661 if (!wxDataViewChoiceRenderer
::GetValue( string_value
))
2664 value
= (long) GetChoices().Index( string_value
.GetString() );
2668 // ---------------------------------------------------------
2669 // wxDataViewDateRenderer
2670 // ---------------------------------------------------------
2672 class wxDataViewDateRendererPopupTransient
: public wxPopupTransientWindow
2675 wxDataViewDateRendererPopupTransient( wxWindow
* parent
, wxDateTime
*value
,
2676 wxDataViewModel
*model
, const wxDataViewItem
&item
, unsigned int col
) :
2677 wxPopupTransientWindow( parent
, wxBORDER_SIMPLE
)
2682 m_cal
= new wxCalendarCtrl( this, -1, *value
);
2683 wxBoxSizer
*sizer
= new wxBoxSizer( wxHORIZONTAL
);
2684 sizer
->Add( m_cal
, 1, wxGROW
);
2689 virtual void OnDismiss()
2693 void OnCalendar( wxCalendarEvent
&event
);
2695 wxCalendarCtrl
*m_cal
;
2696 wxDataViewModel
*m_model
;
2697 wxDataViewItem m_item
;
2701 DECLARE_EVENT_TABLE()
2704 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient
,wxPopupTransientWindow
)
2705 EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient
::OnCalendar
)
2708 void wxDataViewDateRendererPopupTransient
::OnCalendar( wxCalendarEvent
&event
)
2710 m_model
->ChangeValue( event
.GetDate(), m_item
, m_col
);
2714 IMPLEMENT_CLASS(wxDataViewDateRenderer
, wxDataViewCustomRenderer
)
2716 wxDataViewDateRenderer
::wxDataViewDateRenderer( const wxString
&varianttype
,
2717 wxDataViewCellMode mode
, int align
) :
2718 wxDataViewCustomRenderer( varianttype
, mode
, align
)
2721 SetAlignment(align
);
2724 bool wxDataViewDateRenderer
::SetValue( const wxVariant
&value
)
2726 m_date
= value
.GetDateTime();
2731 bool wxDataViewDateRenderer
::GetValue( wxVariant
&WXUNUSED(value
) ) const
2736 bool wxDataViewDateRenderer
::Render( wxRect cell
, wxDC
*dc
, int state
)
2738 dc
->SetFont( GetOwner()->GetOwner()->GetFont() );
2739 wxString tmp
= m_date
.FormatDate();
2740 RenderText( tmp
, 0, cell
, dc
, state
);
2744 wxSize wxDataViewDateRenderer
::GetSize() const
2746 wxString tmp
= m_date
.FormatDate();
2748 GetView()->GetTextExtent( tmp
, &x
, &y
, &d
);
2749 return wxSize(x
,y
+d
);
2752 bool wxDataViewDateRenderer
::Activate( wxRect
WXUNUSED(cell
), wxDataViewModel
*model
,
2753 const wxDataViewItem
&item
, unsigned int col
)
2756 model
->GetValue( variant
, item
, col
);
2757 wxDateTime value
= variant
.GetDateTime();
2759 wxDataViewDateRendererPopupTransient
*popup
= new wxDataViewDateRendererPopupTransient(
2760 GetOwner()->GetOwner()->GetParent(), &value
, model
, item
, col
);
2761 wxPoint pos
= wxGetMousePosition();
2764 popup
->Popup( popup
->m_cal
);
2770 // ---------------------------------------------------------
2771 // wxDataViewIconTextRenderer
2772 // ---------------------------------------------------------
2774 IMPLEMENT_CLASS(wxDataViewIconTextRenderer
, wxDataViewCustomRenderer
)
2776 wxDataViewIconTextRenderer
::wxDataViewIconTextRenderer
2778 const wxString
&varianttype
,
2779 wxDataViewCellMode mode
,
2782 : wxDataViewTextRenderer(varianttype
, mode
, align
)
2784 m_rendererIcon
= gtk_cell_renderer_pixbuf_new();
2787 wxDataViewIconTextRenderer
::~wxDataViewIconTextRenderer()
2791 void wxDataViewIconTextRenderer
::GtkPackIntoColumn(GtkTreeViewColumn
*column
)
2793 // add the icon renderer first
2794 gtk_tree_view_column_pack_start(column
, m_rendererIcon
, FALSE
/* !expand */);
2796 // add the text renderer too
2797 wxDataViewRenderer
::GtkPackIntoColumn(column
);
2800 bool wxDataViewIconTextRenderer
::SetValue( const wxVariant
&value
)
2804 SetTextValue(m_value
.GetText());
2805 SetPixbufProp(m_rendererIcon
, m_value
.GetIcon().GetPixbuf());
2810 bool wxDataViewIconTextRenderer
::GetValue(wxVariant
& value
) const
2813 if ( !GetTextValue(str
) )
2816 // user doesn't have any way to edit the icon so leave it unchanged
2817 value
<< wxDataViewIconText(str
, m_value
.GetIcon());
2823 wxDataViewIconTextRenderer
::GtkOnCellChanged(const wxVariant
& value
,
2824 const wxDataViewItem
& item
,
2827 // we receive just the text part of our value as it's the only one which
2828 // can be edited, but we need the full wxDataViewIconText value for the
2830 wxVariant valueIconText
;
2831 valueIconText
<< wxDataViewIconText(value
.GetString(), m_value
.GetIcon());
2832 wxDataViewTextRenderer
::GtkOnCellChanged(valueIconText
, item
, col
);
2835 // ---------------------------------------------------------
2837 // ---------------------------------------------------------
2841 gtk_dataview_header_button_press_callback( GtkWidget
*WXUNUSED(widget
),
2842 GdkEventButton
*gdk_event
,
2843 wxDataViewColumn
*column
)
2845 if (gdk_event
->type
!= GDK_BUTTON_PRESS
)
2848 if (gdk_event
->button
== 1)
2850 gs_lastLeftClickHeader
= column
;
2852 wxDataViewCtrl
*dv
= column
->GetOwner();
2853 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK
, dv
->GetId() );
2854 event
.SetDataViewColumn( column
);
2855 event
.SetModel( dv
->GetModel() );
2856 if (dv
->HandleWindowEvent( event
))
2860 if (gdk_event
->button
== 3)
2862 wxDataViewCtrl
*dv
= column
->GetOwner();
2863 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK
, dv
->GetId() );
2864 event
.SetDataViewColumn( column
);
2865 event
.SetModel( dv
->GetModel() );
2866 if (dv
->HandleWindowEvent( event
))
2876 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn
*WXUNUSED(column
),
2877 GtkCellRenderer
*renderer
,
2878 GtkTreeModel
*model
,
2882 g_return_if_fail (GTK_IS_WX_TREE_MODEL (model
));
2883 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) model
;
2885 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) data
;
2887 wxDataViewItem
item( (void*) iter
->user_data
);
2889 wxDataViewModel
*wx_model
= tree_model
->internal
->GetDataViewModel();
2891 if (!wx_model
->IsVirtualListModel())
2894 if (wx_model
->IsContainer( item
))
2896 visible
= wx_model
->HasContainerColumns( item
) ||
2897 (cell
->GetOwner()->GetModelColumn() == 0);
2904 GValue gvalue
= { 0, };
2905 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2906 g_value_set_boolean( &gvalue
, visible
);
2907 g_object_set_property( G_OBJECT(renderer
), "visible", &gvalue
);
2908 g_value_unset( &gvalue
);
2915 wx_model
->GetValue( value
, item
, cell
->GetOwner()->GetModelColumn() );
2917 if (value
.GetType() != cell
->GetVariantType())
2919 wxLogError( wxT("Wrong type, required: %s but: %s"),
2920 value
.GetType().c_str(),
2921 cell
->GetVariantType().c_str() );
2924 cell
->SetValue( value
);
2927 // deal with attributes: if the renderer doesn't support them at all, we
2928 // don't even need to query the model for them
2929 if ( !cell
->GtkSupportsAttrs() )
2932 // it can support attributes so check if this item has any
2933 wxDataViewItemAttr attr
;
2934 if ( wx_model
->GetAttr( item
, cell
->GetOwner()->GetModelColumn(), attr
)
2935 || !cell
->GtkIsUsingDefaultAttrs() )
2937 bool usingDefaultAttrs
= !cell
->GtkSetAttr(attr
);
2938 cell
->GtkSetUsingDefaultAttrs(usingDefaultAttrs
);
2940 // else: no custom attributes specified and we're already using the default
2941 // ones -- nothing to do
2946 #include <wx/listimpl.cpp>
2947 WX_DEFINE_LIST(wxDataViewColumnList
)
2949 wxDataViewColumn
::wxDataViewColumn( const wxString
&title
, wxDataViewRenderer
*cell
,
2950 unsigned int model_column
, int width
,
2951 wxAlignment align
, int flags
)
2952 : wxDataViewColumnBase( cell
, model_column
)
2954 Init( align
, flags
, width
);
2959 wxDataViewColumn
::wxDataViewColumn( const wxBitmap
&bitmap
, wxDataViewRenderer
*cell
,
2960 unsigned int model_column
, int width
,
2961 wxAlignment align
, int flags
)
2962 : wxDataViewColumnBase( bitmap
, cell
, model_column
)
2964 Init( align
, flags
, width
);
2966 SetBitmap( bitmap
);
2969 void wxDataViewColumn
::Init(wxAlignment align
, int flags
, int width
)
2971 m_isConnected
= false;
2973 GtkTreeViewColumn
*column
= gtk_tree_view_column_new();
2974 m_column
= (GtkWidget
*) column
;
2977 SetAlignment( align
);
2981 // Create container for icon and label
2982 GtkWidget
*box
= gtk_hbox_new( FALSE
, 1 );
2983 gtk_widget_show( box
);
2984 // gtk_container_set_border_width((GtkContainer*)box, 2);
2985 m_image
= gtk_image_new();
2986 gtk_box_pack_start(GTK_BOX(box
), m_image
, FALSE
, FALSE
, 1);
2987 m_label
= gtk_label_new("");
2988 gtk_box_pack_end( GTK_BOX(box
), GTK_WIDGET(m_label
), FALSE
, FALSE
, 1 );
2989 gtk_tree_view_column_set_widget( column
, box
);
2991 wxDataViewRenderer
* const colRenderer
= GetRenderer();
2992 GtkCellRenderer
* const cellRenderer
= colRenderer
->GetGtkHandle();
2994 colRenderer
->GtkPackIntoColumn(column
);
2996 gtk_tree_view_column_set_cell_data_func( column
, cellRenderer
,
2997 wxGtkTreeCellDataFunc
, (gpointer
) colRenderer
, NULL
);
3000 void wxDataViewColumn
::OnInternalIdle()
3005 if (GTK_WIDGET_REALIZED(GetOwner()->m_treeview
))
3007 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3010 g_signal_connect(column
->button
, "button_press_event",
3011 G_CALLBACK (gtk_dataview_header_button_press_callback
), this);
3013 // otherwise the event will be blocked by GTK+
3014 gtk_tree_view_column_set_clickable( column
, TRUE
);
3016 m_isConnected
= true;
3021 void wxDataViewColumn
::SetOwner( wxDataViewCtrl
*owner
)
3023 wxDataViewColumnBase
::SetOwner( owner
);
3025 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3027 gtk_tree_view_column_set_title( column
, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
3030 void wxDataViewColumn
::SetTitle( const wxString
&title
)
3032 wxDataViewCtrl
*ctrl
= GetOwner();
3033 gtk_label_set_text( GTK_LABEL(m_label
), ctrl ?
wxGTK_CONV_FONT(title
, ctrl
->GetFont())
3034 : wxGTK_CONV_SYS(title
) );
3036 gtk_widget_hide( m_label
);
3038 gtk_widget_show( m_label
);
3041 wxString wxDataViewColumn
::GetTitle() const
3043 return wxGTK_CONV_BACK_FONT(
3044 gtk_label_get_text( GTK_LABEL(m_label
) ),
3045 GetOwner()->GetFont()
3049 void wxDataViewColumn
::SetBitmap( const wxBitmap
&bitmap
)
3051 wxDataViewColumnBase
::SetBitmap( bitmap
);
3055 GtkImage
*gtk_image
= GTK_IMAGE(m_image
);
3057 GdkBitmap
*mask
= NULL
;
3058 if (bitmap
.GetMask())
3059 mask
= bitmap
.GetMask()->GetBitmap();
3061 if (bitmap
.HasPixbuf())
3063 gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image
),
3064 bitmap
.GetPixbuf());
3068 gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image
),
3069 bitmap
.GetPixmap(), mask
);
3071 gtk_widget_show( m_image
);
3075 gtk_widget_hide( m_image
);
3079 void wxDataViewColumn
::SetHidden( bool hidden
)
3081 gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column
), !hidden
);
3084 void wxDataViewColumn
::SetResizeable( bool resizeable
)
3086 gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column
), resizeable
);
3089 void wxDataViewColumn
::SetAlignment( wxAlignment align
)
3091 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3093 gfloat xalign
= 0.0;
3094 if (align
== wxALIGN_RIGHT
)
3096 if (align
== wxALIGN_CENTER_HORIZONTAL
||
3097 align
== wxALIGN_CENTER
)
3100 gtk_tree_view_column_set_alignment( column
, xalign
);
3102 if (m_renderer
&& m_renderer
->GetAlignment() == -1)
3103 m_renderer
->GtkUpdateAlignment();
3106 wxAlignment wxDataViewColumn
::GetAlignment() const
3108 gfloat xalign
= gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column
) );
3111 return wxALIGN_RIGHT
;
3113 return wxALIGN_CENTER_HORIZONTAL
;
3115 return wxALIGN_LEFT
;
3118 void wxDataViewColumn
::SetSortable( bool sortable
)
3120 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3124 gtk_tree_view_column_set_sort_column_id( column
, GetModelColumn() );
3128 gtk_tree_view_column_set_sort_column_id( column
, -1 );
3129 gtk_tree_view_column_set_sort_indicator( column
, FALSE
);
3130 gtk_tree_view_column_set_clickable( column
, FALSE
);
3134 bool wxDataViewColumn
::IsSortable() const
3136 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3137 return gtk_tree_view_column_get_clickable( column
);
3140 void wxDataViewColumn
::SetAsSortKey( bool WXUNUSED(sort
) )
3142 // it might not make sense to have this function in wxHeaderColumn at
3143 // all in fact, changing of the sort order should only be done using the
3144 // associated control API
3145 wxFAIL_MSG( "not implemented" );
3148 bool wxDataViewColumn
::IsSortKey() const
3150 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3151 return gtk_tree_view_column_get_sort_indicator( column
);
3154 bool wxDataViewColumn
::IsResizeable() const
3156 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3157 return gtk_tree_view_column_get_resizable( column
);
3160 bool wxDataViewColumn
::IsHidden() const
3162 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3163 return !gtk_tree_view_column_get_visible( column
);
3166 void wxDataViewColumn
::SetSortOrder( bool ascending
)
3168 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3171 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_ASCENDING
);
3173 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_DESCENDING
);
3175 gtk_tree_view_column_set_sort_indicator( column
, TRUE
);
3178 bool wxDataViewColumn
::IsSortOrderAscending() const
3180 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3182 return (gtk_tree_view_column_get_sort_order( column
) != GTK_SORT_DESCENDING
);
3185 void wxDataViewColumn
::SetMinWidth( int width
)
3187 gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
3190 int wxDataViewColumn
::GetMinWidth() const
3192 return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column
) );
3195 int wxDataViewColumn
::GetWidth() const
3197 return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column
) );
3200 void wxDataViewColumn
::SetWidth( int width
)
3205 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
3207 // TODO find a better calculation
3208 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), wxDVC_DEFAULT_WIDTH
);
3210 // this is unpractical for large numbers of items and disables
3211 // user resizing, which is totally unexpected
3212 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_AUTOSIZE
);
3217 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
3219 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
3223 void wxDataViewColumn
::SetReorderable( bool reorderable
)
3225 gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column
), reorderable
);
3228 bool wxDataViewColumn
::IsReorderable() const
3230 return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column
) );
3233 //-----------------------------------------------------------------------------
3234 // wxGtkTreeModelNode
3235 //-----------------------------------------------------------------------------
3238 class wxGtkTreeModelChildWithPos
3246 int wxGtkTreeModelChildWithPosCmp( const void* data1
, const void* data2
, const void* user_data
)
3248 const wxGtkTreeModelChildWithPos
* child1
= (const wxGtkTreeModelChildWithPos
*) data1
;
3249 const wxGtkTreeModelChildWithPos
* child2
= (const wxGtkTreeModelChildWithPos
*) data2
;
3250 const wxDataViewCtrlInternal
*internal
= (const wxDataViewCtrlInternal
*) user_data
;
3251 int ret
= internal
->GetDataViewModel()->Compare( child1
->id
, child2
->id
,
3252 internal
->GetSortColumn(), (internal
->GetSortOrder() == GTK_SORT_DESCENDING
) );
3258 int LINKAGEMODE
wxGtkTreeModelChildPtrCmp( void*** data1
, void*** data2
)
3260 return gs_internal
->GetDataViewModel()->Compare( **data1
, **data2
,
3261 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
3264 WX_DEFINE_ARRAY_PTR( void**, wxGtkTreeModelChildrenPtr
);
3267 void wxGtkTreeModelNode
::Resort()
3269 size_t child_count
= GetChildCount();
3270 if (child_count
== 0)
3273 size_t node_count
= GetNodesCount();
3275 if (child_count
== 1)
3277 if (node_count
== 1)
3279 wxGtkTreeModelNode
*node
= m_nodes
.Item( 0 );
3285 gint
*new_order
= new gint
[child_count
];
3288 // m_children has the original *void
3289 // ptrs points to these
3290 wxGtkTreeModelChildrenPtr ptrs
;
3292 for (i
= 0; i
< child_count
; i
++)
3293 ptrs
.Add( &(m_children
[i
]) );
3295 gs_internal
= m_internal
;
3296 ptrs
.Sort( &wxGtkTreeModelChildPtrCmp
);
3298 wxGtkTreeModelChildren temp
;
3299 void** base_ptr
= &(m_children
[0]);
3300 // Transfer positions to new_order array and
3302 for (i
= 0; i
< child_count
; i
++)
3304 new_order
[i
] = ptrs
[i
] - base_ptr
;
3305 temp
.Add( *ptrs
[i
] );
3308 // Transfer IDs back to m_children
3310 WX_APPEND_ARRAY( temp
, m_children
);
3315 // Build up array with IDs and original positions
3316 wxGtkTreeModelChildWithPos
* temp
= new wxGtkTreeModelChildWithPos
[child_count
];
3318 for (i
= 0; i
< child_count
; i
++)
3321 temp
[i
].id
= m_children
[i
];
3323 // Sort array keeping original positions
3324 wxQsort( temp
, child_count
, sizeof(wxGtkTreeModelChildWithPos
),
3325 &wxGtkTreeModelChildWithPosCmp
, m_internal
);
3326 // Transfer positions to new_order array and
3327 // IDs to m_children
3329 for (i
= 0; i
< child_count
; i
++)
3331 new_order
[i
] = temp
[i
].pos
;
3332 m_children
.Add( temp
[i
].id
);
3341 wxGtkTreeModelChildren temp
;
3342 WX_APPEND_ARRAY( temp
, m_children
);
3344 gs_internal
= m_internal
;
3345 m_children
.Sort( &wxGtkTreeModelChildCmp
);
3348 for (pos
= 0; pos
< child_count
; pos
++)
3350 void *id
= m_children
.Item( pos
);
3351 int old_pos
= temp
.Index( id
);
3352 new_order
[pos
] = old_pos
;
3356 GtkTreeModel
*gtk_tree_model
= GTK_TREE_MODEL( m_internal
->GetGtkModel() );
3359 iter
.user_data
= GetItem().GetID();
3360 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
3362 gtk_tree_model_rows_reordered( gtk_tree_model
,
3363 wxGtkTreePath(m_internal
->get_path(&iter
)), &iter
, new_order
);
3365 delete [] new_order
;
3368 for (pos
= 0; pos
< node_count
; pos
++)
3370 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
3375 //-----------------------------------------------------------------------------
3376 // wxDataViewCtrlInternal
3377 //-----------------------------------------------------------------------------
3379 wxDataViewCtrlInternal
::wxDataViewCtrlInternal( wxDataViewCtrl
*owner
, wxDataViewModel
*wx_model
)
3382 m_wx_model
= wx_model
;
3386 m_sort_order
= GTK_SORT_ASCENDING
;
3388 m_dataview_sort_column
= NULL
;
3390 m_dragDataObject
= NULL
;
3391 m_dropDataObject
= NULL
;
3393 m_gtk_model
= wxgtk_tree_model_new();
3394 m_gtk_model
->internal
= this;
3396 m_notifier
= new wxGtkDataViewModelNotifier( wx_model
, this );
3398 wx_model
->AddNotifier( m_notifier
);
3400 // g_object_unref( gtk_model ); ???
3402 if (!m_wx_model
->IsVirtualListModel())
3405 gtk_tree_view_set_model( GTK_TREE_VIEW(m_owner
->GtkGetTreeView()), GTK_TREE_MODEL(m_gtk_model
) );
3408 wxDataViewCtrlInternal
::~wxDataViewCtrlInternal()
3410 m_wx_model
->RemoveNotifier( m_notifier
);
3412 // remove the model from the GtkTreeView before it gets destroyed
3413 gtk_tree_view_set_model( GTK_TREE_VIEW( m_owner
->GtkGetTreeView() ), NULL
);
3415 g_object_unref( m_gtk_model
);
3417 delete m_dragDataObject
;
3418 delete m_dropDataObject
;
3421 void wxDataViewCtrlInternal
::InitTree()
3423 wxDataViewItem item
;
3424 m_root
= new wxGtkTreeModelNode( NULL
, item
, this );
3426 BuildBranch( m_root
);
3429 void wxDataViewCtrlInternal
::BuildBranch( wxGtkTreeModelNode
*node
)
3431 if (node
->GetChildCount() == 0)
3433 wxDataViewItemArray children
;
3434 unsigned int count
= m_wx_model
->GetChildren( node
->GetItem(), children
);
3437 for (pos
= 0; pos
< count
; pos
++)
3439 wxDataViewItem child
= children
[pos
];
3441 if (m_wx_model
->IsContainer( child
))
3442 node
->AddNode( new wxGtkTreeModelNode( node
, child
, this ) );
3444 node
->AddLeave( child
.GetID() );
3446 // Don't send any events here
3453 bool wxDataViewCtrlInternal
::EnableDragSource( const wxDataFormat
&format
)
3455 wxGtkString
atom_str( gdk_atom_name( format
) );
3456 m_dragSourceTargetEntryTarget
= wxCharBuffer( atom_str
);
3458 m_dragSourceTargetEntry
.target
= m_dragSourceTargetEntryTarget
.data();
3459 m_dragSourceTargetEntry
.flags
= 0;
3460 m_dragSourceTargetEntry
.info
= static_cast<guint
>(-1);
3462 gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
3463 GDK_BUTTON1_MASK
, &m_dragSourceTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
3468 bool wxDataViewCtrlInternal
::EnableDropTarget( const wxDataFormat
&format
)
3470 wxGtkString
atom_str( gdk_atom_name( format
) );
3471 m_dropTargetTargetEntryTarget
= wxCharBuffer( atom_str
);
3473 m_dropTargetTargetEntry
.target
= m_dropTargetTargetEntryTarget
.data();
3474 m_dropTargetTargetEntry
.flags
= 0;
3475 m_dropTargetTargetEntry
.info
= static_cast<guint
>(-1);
3477 gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
3478 &m_dropTargetTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
3483 gboolean wxDataViewCtrlInternal
::row_draggable( GtkTreeDragSource
*WXUNUSED(drag_source
),
3486 delete m_dragDataObject
;
3488 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3492 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG
, m_owner
->GetId() );
3493 event
.SetEventObject( m_owner
);
3494 event
.SetItem( item
);
3495 event
.SetModel( m_wx_model
);
3496 if (!m_owner
->HandleWindowEvent( event
))
3499 if (!event
.IsAllowed())
3502 wxDataObject
*obj
= event
.GetDataObject();
3506 m_dragDataObject
= obj
;
3512 wxDataViewCtrlInternal
::drag_data_delete(GtkTreeDragSource
*WXUNUSED(drag_source
),
3513 GtkTreePath
*WXUNUSED(path
))
3518 gboolean wxDataViewCtrlInternal
::drag_data_get( GtkTreeDragSource
*WXUNUSED(drag_source
),
3519 GtkTreePath
*path
, GtkSelectionData
*selection_data
)
3521 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3525 if (!m_dragDataObject
->IsSupported( selection_data
->target
))
3528 size_t size
= m_dragDataObject
->GetDataSize( selection_data
->target
);
3532 void *buf
= malloc( size
);
3534 gboolean res
= FALSE
;
3535 if (m_dragDataObject
->GetDataHere( selection_data
->target
, buf
))
3539 gtk_selection_data_set( selection_data
, selection_data
->target
,
3540 8, (const guchar
*) buf
, size
);
3549 wxDataViewCtrlInternal
::drag_data_received(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3551 GtkSelectionData
*selection_data
)
3553 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3557 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP
, m_owner
->GetId() );
3558 event
.SetEventObject( m_owner
);
3559 event
.SetItem( item
);
3560 event
.SetModel( m_wx_model
);
3561 event
.SetDataFormat( selection_data
->target
);
3562 event
.SetDataSize( selection_data
->length
);
3563 event
.SetDataBuffer( selection_data
->data
);
3564 if (!m_owner
->HandleWindowEvent( event
))
3567 if (!event
.IsAllowed())
3574 wxDataViewCtrlInternal
::row_drop_possible(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3576 GtkSelectionData
*selection_data
)
3578 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3582 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE
, m_owner
->GetId() );
3583 event
.SetEventObject( m_owner
);
3584 event
.SetItem( item
);
3585 event
.SetModel( m_wx_model
);
3586 event
.SetDataFormat( selection_data
->target
);
3587 if (!m_owner
->HandleWindowEvent( event
))
3590 if (!event
.IsAllowed())
3596 // notifications from wxDataViewModel
3598 bool wxDataViewCtrlInternal
::Cleared()
3611 void wxDataViewCtrlInternal
::Resort()
3613 if (!m_wx_model
->IsVirtualListModel())
3617 bool wxDataViewCtrlInternal
::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3619 if (!m_wx_model
->IsVirtualListModel())
3621 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3622 wxASSERT_MSG(parent_node
,
3623 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3625 if (m_wx_model
->IsContainer( item
))
3626 parent_node
->AddNode( new wxGtkTreeModelNode( parent_node
, item
, this ) );
3628 parent_node
->AddLeave( item
.GetID() );
3634 bool wxDataViewCtrlInternal
::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3636 if (!m_wx_model
->IsVirtualListModel())
3638 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3639 wxASSERT_MSG(parent_node
,
3640 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3642 parent_node
->DeleteChild( item
.GetID() );
3648 bool wxDataViewCtrlInternal
::ItemChanged( const wxDataViewItem
&item
)
3650 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3651 event
.SetEventObject( m_owner
);
3652 event
.SetModel( m_owner
->GetModel() );
3653 event
.SetItem( item
);
3654 m_owner
->HandleWindowEvent( event
);
3659 bool wxDataViewCtrlInternal
::ValueChanged( const wxDataViewItem
&item
, unsigned int col
)
3661 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3662 event
.SetEventObject( m_owner
);
3663 event
.SetModel( m_owner
->GetModel() );
3664 event
.SetColumn( col
);
3665 event
.SetDataViewColumn( GetOwner()->GetColumn(col
) );
3666 event
.SetItem( item
);
3667 m_owner
->HandleWindowEvent( event
);
3674 GtkTreeModelFlags wxDataViewCtrlInternal
::get_flags()
3678 if ( m_wx_model
->IsListModel() )
3679 flags
|= GTK_TREE_MODEL_LIST_ONLY
;
3681 if ( !m_wx_model
->IsVirtualListModel() )
3682 flags
|= GTK_TREE_MODEL_ITERS_PERSIST
;
3684 return GtkTreeModelFlags(flags
);
3687 gboolean wxDataViewCtrlInternal
::get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
)
3690 if (m_wx_model
->IsVirtualListModel())
3692 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3694 unsigned int i
= (unsigned int)gtk_tree_path_get_indices (path
)[0];
3696 if (i
>= wx_model
->GetCount())
3699 iter
->stamp
= m_gtk_model
->stamp
;
3700 // user_data is just the index +1
3701 iter
->user_data
= (gpointer
) (i
+1);
3707 int depth
= gtk_tree_path_get_depth( path
);
3709 wxGtkTreeModelNode
*node
= m_root
;
3712 for (i
= 0; i
< depth
; i
++)
3714 BuildBranch( node
);
3716 gint pos
= gtk_tree_path_get_indices (path
)[i
];
3717 if (pos
< 0) return FALSE
;
3718 if ((size_t)pos
>= node
->GetChildCount()) return FALSE
;
3720 void* id
= node
->GetChildren().Item( (size_t) pos
);
3724 iter
->stamp
= m_gtk_model
->stamp
;
3725 iter
->user_data
= id
;
3729 size_t count
= node
->GetNodes().GetCount();
3731 for (pos2
= 0; pos2
< count
; pos2
++)
3733 wxGtkTreeModelNode
*child_node
= node
->GetNodes().Item( pos2
);
3734 if (child_node
->GetItem().GetID() == id
)
3746 GtkTreePath
*wxDataViewCtrlInternal
::get_path( GtkTreeIter
*iter
)
3748 // When this is called from ItemDeleted(), the item is already
3749 // deleted in the model.
3751 GtkTreePath
*retval
= gtk_tree_path_new ();
3753 if (m_wx_model
->IsVirtualListModel())
3755 // iter is root, add nothing
3756 if (!iter
->user_data
)
3759 // user_data is just the index +1
3760 int i
= ( (wxUIntPtr
) iter
->user_data
) -1;
3761 gtk_tree_path_append_index (retval
, i
);
3765 void *id
= iter
->user_data
;
3767 wxGtkTreeModelNode
*node
= FindParentNode( iter
);
3770 int pos
= node
->GetChildren().Index( id
);
3772 gtk_tree_path_prepend_index( retval
, pos
);
3774 id
= node
->GetItem().GetID();
3775 node
= node
->GetParent();
3782 gboolean wxDataViewCtrlInternal
::iter_next( GtkTreeIter
*iter
)
3784 if (m_wx_model
->IsVirtualListModel())
3786 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3788 // user_data is just the index +1
3789 int n
= ( (wxUIntPtr
) iter
->user_data
) -1;
3793 iter
->user_data
= NULL
;
3797 if (n
>= (int) wx_model
->GetCount()-1)
3799 iter
->user_data
= NULL
;
3803 // user_data is just the index +1 (+2 because we need the next)
3804 iter
->user_data
= (gpointer
) (n
+2);
3808 wxGtkTreeModelNode
*parent
= FindParentNode( iter
);
3809 if( parent
== NULL
)
3811 iter
->user_data
= NULL
;
3815 int pos
= parent
->GetChildren().Index( iter
->user_data
);
3817 if (pos
== (int) parent
->GetChildCount()-1)
3819 iter
->user_data
= NULL
;
3823 iter
->user_data
= parent
->GetChildren().Item( pos
+1 );
3829 gboolean wxDataViewCtrlInternal
::iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
)
3831 if (m_wx_model
->IsVirtualListModel())
3833 // this is a list, nodes have no children
3837 iter
->stamp
= m_gtk_model
->stamp
;
3838 iter
->user_data
= (gpointer
) 1;
3846 if (m_root
->GetChildCount() == 0) return FALSE
;
3847 iter
->stamp
= m_gtk_model
->stamp
;
3848 iter
->user_data
= (gpointer
) m_root
->GetChildren().Item( 0 );
3853 wxDataViewItem item
;
3855 item
= wxDataViewItem( (void*) parent
->user_data
);
3857 if (!m_wx_model
->IsContainer( item
))
3860 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3861 wxASSERT_MSG(parent_node
,
3862 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3864 BuildBranch( parent_node
);
3866 if (parent_node
->GetChildCount() == 0)
3869 iter
->stamp
= m_gtk_model
->stamp
;
3870 iter
->user_data
= (gpointer
) parent_node
->GetChildren().Item( 0 );
3876 gboolean wxDataViewCtrlInternal
::iter_has_child( GtkTreeIter
*iter
)
3878 if (m_wx_model
->IsVirtualListModel())
3880 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3883 return (wx_model
->GetCount() > 0);
3885 // this is a list, nodes have no children
3891 return (m_root
->GetChildCount() > 0);
3893 wxDataViewItem
item( (void*) iter
->user_data
);
3895 bool is_container
= m_wx_model
->IsContainer( item
);
3900 wxGtkTreeModelNode
*node
= FindNode( iter
);
3902 "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
3904 BuildBranch( node
);
3906 return (node
->GetChildCount() > 0);
3910 gint wxDataViewCtrlInternal
::iter_n_children( GtkTreeIter
*iter
)
3912 if (m_wx_model
->IsVirtualListModel())
3914 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3917 return (gint
) wx_model
->GetCount();
3924 return m_root
->GetChildCount();
3926 wxDataViewItem
item( (void*) iter
->user_data
);
3928 if (!m_wx_model
->IsContainer( item
))
3931 wxGtkTreeModelNode
*parent_node
= FindNode( iter
);
3932 wxASSERT_MSG(parent_node
,
3933 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3935 BuildBranch( parent_node
);
3937 return parent_node
->GetChildCount();
3941 gboolean wxDataViewCtrlInternal
::iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
)
3943 if (m_wx_model
->IsVirtualListModel())
3945 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3953 if (n
>= (gint
) wx_model
->GetCount())
3956 iter
->stamp
= m_gtk_model
->stamp
;
3957 // user_data is just the index +1
3958 iter
->user_data
= (gpointer
) (n
+1);
3965 if (parent
) id
= (void*) parent
->user_data
;
3966 wxDataViewItem
item( id
);
3968 if (!m_wx_model
->IsContainer( item
))
3971 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3972 wxASSERT_MSG(parent_node
,
3973 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3975 BuildBranch( parent_node
);
3977 iter
->stamp
= m_gtk_model
->stamp
;
3978 iter
->user_data
= parent_node
->GetChildren().Item( n
);
3984 gboolean wxDataViewCtrlInternal
::iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
)
3986 if (m_wx_model
->IsVirtualListModel())
3992 wxGtkTreeModelNode
*node
= FindParentNode( child
);
3996 iter
->stamp
= m_gtk_model
->stamp
;
3997 iter
->user_data
= (gpointer
) node
->GetItem().GetID();
4003 // item can be deleted already in the model
4004 int wxDataViewCtrlInternal
::GetIndexOf( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
4006 if (m_wx_model
->IsVirtualListModel())
4008 return wxPtrToUInt(item
.GetID()) - 1;
4012 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
4013 wxGtkTreeModelChildren
&children
= parent_node
->GetChildren();
4015 for (j
= 0; j
< children
.GetCount(); j
++)
4017 if (children
[j
] == item
.GetID())
4025 static wxGtkTreeModelNode
*
4026 wxDataViewCtrlInternal_FindNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
4032 list
.DeleteContents( true );
4033 wxDataViewItem
it( item
);
4037 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
4038 list
.Insert( pItem
);
4039 it
= model
->GetParent( it
);
4042 wxGtkTreeModelNode
* node
= treeNode
;
4043 for( ItemList
::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
4045 if( node
&& node
->GetNodes().GetCount() != 0 )
4047 int len
= node
->GetNodes().GetCount();
4048 wxGtkTreeModelNodes
&nodes
= node
->GetNodes();
4050 for( ; j
< len
; j
++)
4052 if( nodes
[j
]->GetItem() == *(n
->GetData()))
4071 wxGtkTreeModelNode
*wxDataViewCtrlInternal
::FindNode( GtkTreeIter
*iter
)
4076 wxDataViewItem
item( (void*) iter
->user_data
);
4080 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
4085 wxLogDebug( "Not found %p", iter->user_data );
4089 // TODO: remove this code
4095 wxGtkTreeModelNode
*wxDataViewCtrlInternal
::FindNode( const wxDataViewItem
&item
)
4100 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
4105 wxLogDebug( "Not found %p", item.GetID() );
4109 // TODO: remove this code
4115 static wxGtkTreeModelNode
*
4116 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
4122 list
.DeleteContents( true );
4126 wxDataViewItem
it( model
->GetParent( item
) );
4129 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
4130 list
.Insert( pItem
);
4131 it
= model
->GetParent( it
);
4134 wxGtkTreeModelNode
* node
= treeNode
;
4135 for( ItemList
::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
4137 if( node
&& node
->GetNodes().GetCount() != 0 )
4139 int len
= node
->GetNodes().GetCount();
4140 wxGtkTreeModelNodes nodes
= node
->GetNodes();
4142 for( ; j
< len
; j
++)
4144 if( nodes
[j
]->GetItem() == *(n
->GetData()))
4159 //Examine whether the node is item's parent node
4160 int len
= node
->GetChildCount();
4161 for( int i
= 0; i
< len
; i
++ )
4163 if( node
->GetChildren().Item( i
) == item
.GetID() )
4169 wxGtkTreeModelNode
*wxDataViewCtrlInternal
::FindParentNode( GtkTreeIter
*iter
)
4174 wxDataViewItem
item( (void*) iter
->user_data
);
4178 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
4181 wxGtkTreeModelNode
*wxDataViewCtrlInternal
::FindParentNode( const wxDataViewItem
&item
)
4186 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
4189 //-----------------------------------------------------------------------------
4190 // wxDataViewCtrl signal callbacks
4191 //-----------------------------------------------------------------------------
4194 wxdataview_selection_changed_callback( GtkTreeSelection
* WXUNUSED(selection
), wxDataViewCtrl
*dv
)
4196 if (!GTK_WIDGET_REALIZED(dv
->m_widget
))
4199 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED
, dv
->GetId() );
4200 event
.SetItem( dv
->GetSelection() );
4201 event
.SetModel( dv
->GetModel() );
4202 dv
->HandleWindowEvent( event
);
4206 wxdataview_row_activated_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreePath
*path
,
4207 GtkTreeViewColumn
*WXUNUSED(column
), wxDataViewCtrl
*dv
)
4209 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED
, dv
->GetId() );
4211 wxDataViewItem
item(dv
->GTKPathToItem(path
));
4212 event
.SetItem( item
);
4213 event
.SetModel( dv
->GetModel() );
4214 dv
->HandleWindowEvent( event
);
4218 wxdataview_test_expand_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4219 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4221 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING
, dv
->GetId() );
4223 wxDataViewItem
item( (void*) iter
->user_data
);;
4224 event
.SetItem( item
);
4225 event
.SetModel( dv
->GetModel() );
4226 dv
->HandleWindowEvent( event
);
4228 return !event
.IsAllowed();
4232 wxdataview_row_expanded_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4233 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4235 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED
, dv
->GetId() );
4237 wxDataViewItem
item( (void*) iter
->user_data
);;
4238 event
.SetItem( item
);
4239 event
.SetModel( dv
->GetModel() );
4240 dv
->HandleWindowEvent( event
);
4244 wxdataview_test_collapse_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4245 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4247 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING
, dv
->GetId() );
4249 wxDataViewItem
item( (void*) iter
->user_data
);;
4250 event
.SetItem( item
);
4251 event
.SetModel( dv
->GetModel() );
4252 dv
->HandleWindowEvent( event
);
4254 return !event
.IsAllowed();
4258 wxdataview_row_collapsed_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4259 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4261 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED
, dv
->GetId() );
4263 wxDataViewItem
item( (void*) iter
->user_data
);;
4264 event
.SetItem( item
);
4265 event
.SetModel( dv
->GetModel() );
4266 dv
->HandleWindowEvent( event
);
4269 //-----------------------------------------------------------------------------
4271 //-----------------------------------------------------------------------------
4273 void wxDataViewCtrl
::AddChildGTK(wxWindowGTK
* child
)
4275 GtkWidget
* treeview
= GtkGetTreeView();
4277 // Insert widget in GtkTreeView
4278 if (GTK_WIDGET_REALIZED(treeview
))
4279 gtk_widget_set_parent_window( child
->m_widget
,
4280 gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview
) ) );
4281 gtk_widget_set_parent( child
->m_widget
, treeview
);
4285 void gtk_dataviewctrl_size_callback( GtkWidget
*WXUNUSED(widget
),
4286 GtkAllocation
*WXUNUSED(gtk_alloc
),
4287 wxDataViewCtrl
*win
)
4289 wxWindowList
::compatibility_iterator node
= win
->GetChildren().GetFirst();
4292 wxWindow
*child
= node
->GetData();
4295 gtk_widget_size_request( child
->m_widget
, &req
);
4297 GtkAllocation alloc
;
4298 alloc
.x
= child
->m_x
;
4299 alloc
.y
= child
->m_y
;
4300 alloc
.width
= child
->m_width
;
4301 alloc
.height
= child
->m_height
;
4302 gtk_widget_size_allocate( child
->m_widget
, &alloc
);
4304 node
= node
->GetNext();
4309 //-----------------------------------------------------------------------------
4310 // "motion_notify_event"
4311 //-----------------------------------------------------------------------------
4314 gtk_dataview_motion_notify_callback( GtkWidget
*WXUNUSED(widget
),
4315 GdkEventMotion
*gdk_event
,
4316 wxDataViewCtrl
*dv
)
4318 if (gdk_event
->is_hint
)
4322 GdkModifierType state
;
4323 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
4329 GtkTreeViewColumn
*column
= NULL
;
4332 if (gtk_tree_view_get_path_at_pos(
4333 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
4334 (int) gdk_event
->x
, (int) gdk_event
->y
,
4343 dv
->GtkGetInternal()->get_iter( &iter
, path
);
4351 //-----------------------------------------------------------------------------
4352 // "button_press_event"
4353 //-----------------------------------------------------------------------------
4356 gtk_dataview_button_press_callback( GtkWidget
*WXUNUSED(widget
),
4357 GdkEventButton
*gdk_event
,
4358 wxDataViewCtrl
*dv
)
4360 if ((gdk_event
->button
== 3) && (gdk_event
->type
== GDK_BUTTON_PRESS
))
4363 GtkTreeViewColumn
*column
= NULL
;
4366 if (gtk_tree_view_get_path_at_pos(
4367 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
4368 (int) gdk_event
->x
, (int) gdk_event
->y
,
4376 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU
, dv
->GetId() );
4377 event
.SetItem(dv
->GTKPathToItem(path
));
4378 event
.SetModel( dv
->GetModel() );
4379 return dv
->HandleWindowEvent( event
);
4387 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl
, wxDataViewCtrlBase
)
4389 wxDataViewCtrl
::~wxDataViewCtrl()
4396 void wxDataViewCtrl
::Init()
4400 m_cols
.DeleteContents( true );
4403 bool wxDataViewCtrl
::Create(wxWindow
*parent
,
4408 const wxValidator
& validator
,
4409 const wxString
& name
)
4411 if (!PreCreation( parent
, pos
, size
) ||
4412 !CreateBase( parent
, id
, pos
, size
, style
, validator
, name
))
4414 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
4418 m_widget
= gtk_scrolled_window_new (NULL
, NULL
);
4419 g_object_ref(m_widget
);
4421 GTKScrolledWindowSetBorder(m_widget
, style
);
4423 m_treeview
= gtk_tree_view_new();
4424 gtk_container_add (GTK_CONTAINER (m_widget
), m_treeview
);
4426 g_signal_connect (m_treeview
, "size_allocate",
4427 G_CALLBACK (gtk_dataviewctrl_size_callback
), this);
4430 if (!gtk_check_version(2,6,0))
4432 bool fixed
= (style
& wxDV_VARIABLE_LINE_HEIGHT
) == 0;
4433 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
4437 if (style
& wxDV_MULTIPLE
)
4439 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4440 gtk_tree_selection_set_mode( selection
, GTK_SELECTION_MULTIPLE
);
4443 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_NO_HEADER
) == 0 );
4446 if (!gtk_check_version(2,10,0))
4448 GtkTreeViewGridLines grid
= GTK_TREE_VIEW_GRID_LINES_NONE
;
4450 if ((style
& wxDV_HORIZ_RULES
) != 0 &&
4451 (style
& wxDV_VERT_RULES
) != 0)
4452 grid
= GTK_TREE_VIEW_GRID_LINES_BOTH
;
4453 else if (style
& wxDV_VERT_RULES
)
4454 grid
= GTK_TREE_VIEW_GRID_LINES_VERTICAL
;
4455 else if (style
& wxDV_HORIZ_RULES
)
4456 grid
= GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
;
4458 if (grid
!= GTK_TREE_VIEW_GRID_LINES_NONE
)
4459 gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview
), grid
);
4463 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_ROW_LINES
) != 0 );
4465 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget
),
4466 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
4467 gtk_widget_show (m_treeview
);
4469 m_parent
->DoAddChild( this );
4473 GtkEnableSelectionEvents();
4475 g_signal_connect_after (m_treeview
, "row-activated",
4476 G_CALLBACK (wxdataview_row_activated_callback
), this);
4478 g_signal_connect (m_treeview
, "test-collapse-row",
4479 G_CALLBACK (wxdataview_test_collapse_row_callback
), this);
4481 g_signal_connect_after (m_treeview
, "row-collapsed",
4482 G_CALLBACK (wxdataview_row_collapsed_callback
), this);
4484 g_signal_connect (m_treeview
, "test-expand-row",
4485 G_CALLBACK (wxdataview_test_expand_row_callback
), this);
4487 g_signal_connect_after (m_treeview
, "row-expanded",
4488 G_CALLBACK (wxdataview_row_expanded_callback
), this);
4490 g_signal_connect (m_treeview
, "motion_notify_event",
4491 G_CALLBACK (gtk_dataview_motion_notify_callback
), this);
4493 g_signal_connect (m_treeview
, "button_press_event",
4494 G_CALLBACK (gtk_dataview_button_press_callback
), this);
4499 wxDataViewItem wxDataViewCtrl
::GTKPathToItem(GtkTreePath
*path
) const
4502 return wxDataViewItem(path
&& m_internal
->get_iter(&iter
, path
)
4507 void wxDataViewCtrl
::OnInternalIdle()
4509 wxWindow
::OnInternalIdle();
4511 unsigned int cols
= GetColumnCount();
4513 for (i
= 0; i
< cols
; i
++)
4515 wxDataViewColumn
*col
= GetColumn( i
);
4516 col
->OnInternalIdle();
4520 bool wxDataViewCtrl
::AssociateModel( wxDataViewModel
*model
)
4522 wxDELETE(m_internal
);
4524 if (!wxDataViewCtrlBase
::AssociateModel( model
))
4528 if (!gtk_check_version(2,6,0))
4530 bool fixed
= (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT
) == 0) || (model
->IsVirtualListModel()));
4531 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
4535 m_internal
= new wxDataViewCtrlInternal( this, model
);
4540 bool wxDataViewCtrl
::EnableDragSource( const wxDataFormat
&format
)
4542 return m_internal
->EnableDragSource( format
);
4545 bool wxDataViewCtrl
::EnableDropTarget( const wxDataFormat
&format
)
4547 return m_internal
->EnableDropTarget( format
);
4550 bool wxDataViewCtrl
::AppendColumn( wxDataViewColumn
*col
)
4552 if (!wxDataViewCtrlBase
::AppendColumn(col
))
4555 m_cols
.Append( col
);
4558 if (!gtk_check_version(2,6,0))
4560 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4561 GTK_TREE_VIEW_COLUMN_FIXED
)
4562 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4566 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview
),
4567 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4572 bool wxDataViewCtrl
::PrependColumn( wxDataViewColumn
*col
)
4574 if (!wxDataViewCtrlBase
::PrependColumn(col
))
4577 m_cols
.Insert( col
);
4580 if (!gtk_check_version(2,6,0))
4582 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4583 GTK_TREE_VIEW_COLUMN_FIXED
)
4584 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4588 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4589 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), 0 );
4594 bool wxDataViewCtrl
::InsertColumn( unsigned int pos
, wxDataViewColumn
*col
)
4596 if (!wxDataViewCtrlBase
::InsertColumn(pos
,col
))
4599 m_cols
.Insert( pos
, col
);
4602 if (!gtk_check_version(2,6,0))
4604 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4605 GTK_TREE_VIEW_COLUMN_FIXED
)
4606 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4610 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4611 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), pos
);
4616 unsigned int wxDataViewCtrl
::GetColumnCount() const
4618 return m_cols
.GetCount();
4621 wxDataViewColumn
* wxDataViewCtrl
::GetColumn( unsigned int pos
) const
4623 GtkTreeViewColumn
*gtk_col
= gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview
), pos
);
4627 wxDataViewColumnList
::const_iterator iter
;
4628 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4630 wxDataViewColumn
*col
= *iter
;
4631 if (GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) == gtk_col
)
4640 bool wxDataViewCtrl
::DeleteColumn( wxDataViewColumn
*column
)
4642 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4643 GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle()) );
4645 m_cols
.DeleteObject( column
);
4650 bool wxDataViewCtrl
::ClearColumns()
4652 wxDataViewColumnList
::iterator iter
;
4653 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4655 wxDataViewColumn
*col
= *iter
;
4656 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4657 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4665 int wxDataViewCtrl
::GetColumnPosition( const wxDataViewColumn
*column
) const
4667 GtkTreeViewColumn
*gtk_column
= GTK_TREE_VIEW_COLUMN(column
->GetConstGtkHandle());
4669 GList
*list
= gtk_tree_view_get_columns( GTK_TREE_VIEW(m_treeview
) );
4671 gint pos
= g_list_index( list
, (gconstpointer
) gtk_column
);
4673 g_list_free( list
);
4678 wxDataViewColumn
*wxDataViewCtrl
::GetSortingColumn() const
4680 return m_internal
->GetDataViewSortColumn();
4683 void wxDataViewCtrl
::Expand( const wxDataViewItem
& item
)
4686 iter
.user_data
= item
.GetID();
4687 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4688 gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview
), path
, false );
4691 void wxDataViewCtrl
::Collapse( const wxDataViewItem
& item
)
4694 iter
.user_data
= item
.GetID();
4695 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4696 gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview
), path
);
4699 bool wxDataViewCtrl
::IsExpanded( const wxDataViewItem
& item
) const
4702 iter
.user_data
= item
.GetID();
4703 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4704 return gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview
), path
);
4707 wxDataViewItem wxDataViewCtrl
::DoGetCurrentItem() const
4709 // The tree doesn't have any current item if it hadn't been created yet but
4710 // it's arguably not an error to call this function in this case so just
4711 // return an invalid item without asserting.
4713 return wxDataViewItem();
4716 gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview
), path
.ByRef(), NULL
);
4718 return GTKPathToItem(path
);
4721 void wxDataViewCtrl
::DoSetCurrentItem(const wxDataViewItem
& item
)
4723 wxCHECK_RET( m_treeview
,
4724 "Current item can't be set before creating the control." );
4726 // We need to make sure the model knows about this item or the path would
4727 // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4728 ExpandAncestors(item
);
4730 // We also need to preserve the existing selection from changing.
4731 // Unfortunately the only way to do it seems to use our own selection
4732 // function and forbid any selection changes during set cursor call.
4733 wxGtkTreeSelectionLock
4734 lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview
)));
4736 // Do move the cursor now.
4738 iter
.user_data
= item
.GetID();
4739 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4741 gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview
), path
, NULL
, FALSE
);
4744 wxDataViewItem wxDataViewCtrl
::GetSelection() const
4746 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4748 if (m_windowStyle
& wxDV_MULTIPLE
)
4750 // Report the first one
4751 GtkTreeModel
*model
;
4752 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4756 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4757 wxDataViewItem
item(GTKPathToItem(path
));
4760 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4761 g_list_free( list
);
4769 if (gtk_tree_selection_get_selected( selection
, NULL
, &iter
))
4771 wxDataViewItem
item( iter
.user_data
);
4776 return wxDataViewItem(0);
4779 int wxDataViewCtrl
::GetSelections( wxDataViewItemArray
& sel
) const
4783 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4784 if (HasFlag(wxDV_MULTIPLE
))
4786 GtkTreeModel
*model
;
4787 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4792 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4794 sel
.Add(GTKPathToItem(path
));
4796 list
= g_list_next( list
);
4801 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4802 g_list_free( list
);
4808 GtkTreeModel
*model
;
4810 gboolean has_selection
= gtk_tree_selection_get_selected( selection
, &model
, &iter
);
4813 sel
.Add( wxDataViewItem( (void*) iter
.user_data
) );
4821 void wxDataViewCtrl
::SetSelections( const wxDataViewItemArray
& sel
)
4823 GtkDisableSelectionEvents();
4825 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4827 gtk_tree_selection_unselect_all( selection
);
4829 wxDataViewItem last_parent
;
4832 for (i
= 0; i
< sel
.GetCount(); i
++)
4834 wxDataViewItem item
= sel
[i
];
4835 wxDataViewItem parent
= GetModel()->GetParent( item
);
4838 if (parent
!= last_parent
)
4839 ExpandAncestors(item
);
4841 last_parent
= parent
;
4844 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4845 iter
.user_data
= (gpointer
) item
.GetID();
4846 gtk_tree_selection_select_iter( selection
, &iter
);
4849 GtkEnableSelectionEvents();
4852 void wxDataViewCtrl
::Select( const wxDataViewItem
& item
)
4854 ExpandAncestors(item
);
4856 GtkDisableSelectionEvents();
4858 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4861 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4862 iter
.user_data
= (gpointer
) item
.GetID();
4863 gtk_tree_selection_select_iter( selection
, &iter
);
4865 GtkEnableSelectionEvents();
4868 void wxDataViewCtrl
::Unselect( const wxDataViewItem
& item
)
4870 GtkDisableSelectionEvents();
4872 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4875 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4876 iter
.user_data
= (gpointer
) item
.GetID();
4877 gtk_tree_selection_unselect_iter( selection
, &iter
);
4879 GtkEnableSelectionEvents();
4882 bool wxDataViewCtrl
::IsSelected( const wxDataViewItem
& item
) const
4884 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4887 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4888 iter
.user_data
= (gpointer
) item
.GetID();
4890 return gtk_tree_selection_iter_is_selected( selection
, &iter
);
4893 void wxDataViewCtrl
::SelectAll()
4895 GtkDisableSelectionEvents();
4897 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4899 gtk_tree_selection_select_all( selection
);
4901 GtkEnableSelectionEvents();
4904 void wxDataViewCtrl
::UnselectAll()
4906 GtkDisableSelectionEvents();
4908 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4910 gtk_tree_selection_unselect_all( selection
);
4912 GtkEnableSelectionEvents();
4915 void wxDataViewCtrl
::EnsureVisible(const wxDataViewItem
& item
,
4916 const wxDataViewColumn
*WXUNUSED(column
))
4918 ExpandAncestors(item
);
4921 iter
.user_data
= (gpointer
) item
.GetID();
4922 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4923 gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview
), path
, NULL
, false, 0.0, 0.0 );
4926 void wxDataViewCtrl
::HitTest(const wxPoint
& WXUNUSED(point
),
4927 wxDataViewItem
& item
,
4928 wxDataViewColumn
*& column
) const
4930 item
= wxDataViewItem(0);
4935 wxDataViewCtrl
::GetItemRect(const wxDataViewItem
& WXUNUSED(item
),
4936 const wxDataViewColumn
*WXUNUSED(column
)) const
4941 void wxDataViewCtrl
::DoSetExpanderColumn()
4943 gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview
),
4944 GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
4947 void wxDataViewCtrl
::DoSetIndent()
4951 void wxDataViewCtrl
::GtkDisableSelectionEvents()
4953 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4954 g_signal_handlers_disconnect_by_func( selection
,
4955 (gpointer
) (wxdataview_selection_changed_callback
), this);
4958 void wxDataViewCtrl
::GtkEnableSelectionEvents()
4960 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4961 g_signal_connect_after (selection
, "changed",
4962 G_CALLBACK (wxdataview_selection_changed_callback
), this);
4965 // ----------------------------------------------------------------------------
4966 // visual attributes stuff
4967 // ----------------------------------------------------------------------------
4971 wxDataViewCtrl
::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
4973 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new
);
4976 void wxDataViewCtrl
::DoApplyWidgetStyle(GtkRcStyle
*style
)
4978 wxDataViewCtrlBase
::DoApplyWidgetStyle(style
);
4979 gtk_widget_modify_style(m_treeview
, style
);
4982 #endif // !wxUSE_GENERICDATAVIEWCTRL
4984 #endif // wxUSE_DATAVIEWCTRL