1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/dataview.cpp
3 // Purpose: wxDataViewCtrl GTK+2 implementation
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
13 #if wxUSE_DATAVIEWCTRL
15 #include "wx/dataview.h"
17 #ifndef wxUSE_GENERICDATAVIEWCTRL
21 #include "wx/dcclient.h"
23 #include "wx/settings.h"
27 #include "wx/stockitem.h"
28 #include "wx/calctrl.h"
29 #include "wx/popupwin.h"
30 #include "wx/listimpl.cpp"
32 #include "wx/gtk/private.h"
33 #include "wx/gtk/dc.h"
34 #include "wx/gtk/dcclient.h"
36 #include "wx/gtk/private/gdkconv.h"
37 using namespace wxGTKImpl
;
39 //-----------------------------------------------------------------------------
40 //-----------------------------------------------------------------------------
42 static wxDataViewCtrlInternal
*gs_internal
= NULL
;
44 class wxGtkTreeModelNode
;
47 typedef struct _GtkWxTreeModel GtkWxTreeModel
;
50 // ----------------------------------------------------------------------------
51 // wxGtkTreePath: self-destroying GtkTreePath
52 // ----------------------------------------------------------------------------
54 // Usually this object is initialized with the associated GtkTreePath
55 // immediately when it's constructed but it can also be changed later either by
56 // using Assign() or by getting the pointer to the internally stored pointer
57 // value using ByRef(). The latter should be avoided but is very convenient
58 // when using GTK functions with GtkTreePath output parameters.
62 // Ctor takes ownership of the given path and will free it if non-NULL.
63 wxGtkTreePath(GtkTreePath
*path
= NULL
) : m_path(path
) { }
65 // Creates a tree path for the given string path.
66 wxGtkTreePath(const gchar
*strpath
)
67 : m_path(gtk_tree_path_new_from_string(strpath
))
71 // Set the stored pointer if not done by ctor.
72 void Assign(GtkTreePath
*path
)
74 wxASSERT_MSG( !m_path
, "shouldn't be already initialized" );
79 // Return the pointer to the internally stored pointer. This should only be
80 // used to initialize the object by passing it to some GTK function.
83 wxASSERT_MSG( !m_path
, "shouldn't be already initialized" );
89 operator GtkTreePath
*() const { return m_path
; }
91 ~wxGtkTreePath() { if ( m_path
) gtk_tree_path_free(m_path
); }
96 wxDECLARE_NO_COPY_CLASS(wxGtkTreePath
);
99 // ----------------------------------------------------------------------------
100 // wxGtkTreeSelectionLock: prevent selection from changing during the
101 // lifetime of this object
102 // ----------------------------------------------------------------------------
104 // Implementation note: it could be expected that setting the selection
105 // function in this class ctor and resetting it back to the old value in its
106 // dtor would work. However currently gtk_tree_selection_get_select_function()
107 // can't be passed NULL (see https://bugzilla.gnome.org/show_bug.cgi?id=626276)
108 // so we can't do this. Instead, we always use the selection function (which
109 // imposes extra overhead, albeit minimal one, on all selection operations) and
110 // just set/reset the flag telling it whether it should allow or forbid the
113 // Also notice that currently only a single object of this class may exist at
114 // any given moment. It's just simpler like this and we don't need anything
118 gboolean
wxdataview_selection_func(GtkTreeSelection
* WXUNUSED(selection
),
119 GtkTreeModel
* WXUNUSED(model
),
120 GtkTreePath
* WXUNUSED(path
),
121 gboolean
WXUNUSED(path_currently_selected
),
127 class wxGtkTreeSelectionLock
130 wxGtkTreeSelectionLock(GtkTreeSelection
*selection
)
131 : m_selection(selection
)
133 wxASSERT_MSG( !ms_instance
, "this class is not reentrant currently" );
137 CheckCurrentSelectionFunc(NULL
);
139 // Pass some non-NULL pointer as "data" for the callback, it doesn't
140 // matter what it is as long as it's non-NULL.
141 gtk_tree_selection_set_select_function(selection
,
142 wxdataview_selection_func
,
147 ~wxGtkTreeSelectionLock()
149 CheckCurrentSelectionFunc(wxdataview_selection_func
);
151 gtk_tree_selection_set_select_function(m_selection
,
152 wxdataview_selection_func
,
160 void CheckCurrentSelectionFunc(GtkTreeSelectionFunc func
)
162 // We can only use gtk_tree_selection_get_select_function() with 2.14+
163 // so check for its availability both during compile- and run-time.
164 #if GTK_CHECK_VERSION(2, 14, 0)
165 if ( gtk_check_version(2, 14, 0) != NULL
)
168 // If this assert is triggered, it means the code elsewhere has called
169 // gtk_tree_selection_set_select_function() but currently doing this
170 // breaks this class so the code here needs to be changed.
173 gtk_tree_selection_get_select_function(m_selection
) == func
,
174 "selection function has changed unexpectedly, review this code!"
181 static wxGtkTreeSelectionLock
*ms_instance
;
183 GtkTreeSelection
* const m_selection
;
185 wxDECLARE_NO_COPY_CLASS(wxGtkTreeSelectionLock
);
188 wxGtkTreeSelectionLock
*wxGtkTreeSelectionLock::ms_instance
= NULL
;
190 //-----------------------------------------------------------------------------
191 // wxDataViewCtrlInternal
192 //-----------------------------------------------------------------------------
194 WX_DECLARE_LIST(wxDataViewItem
, ItemList
);
195 WX_DEFINE_LIST(ItemList
)
197 class wxDataViewCtrlInternal
200 wxDataViewCtrlInternal( wxDataViewCtrl
*owner
, wxDataViewModel
*wx_model
, GtkWxTreeModel
*gtk_model
);
201 ~wxDataViewCtrlInternal();
204 GtkTreeModelFlags
get_flags();
205 gboolean
get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
);
206 GtkTreePath
*get_path( GtkTreeIter
*iter
);
207 gboolean
iter_next( GtkTreeIter
*iter
);
208 gboolean
iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
);
209 gboolean
iter_has_child( GtkTreeIter
*iter
);
210 gint
iter_n_children( GtkTreeIter
*iter
);
211 gboolean
iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
);
212 gboolean
iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
);
216 bool EnableDragSource( const wxDataFormat
&format
);
217 bool EnableDropTarget( const wxDataFormat
&format
);
219 gboolean
row_draggable( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
);
220 gboolean
drag_data_delete( GtkTreeDragSource
*drag_source
, GtkTreePath
* path
);
221 gboolean
drag_data_get( GtkTreeDragSource
*drag_source
, GtkTreePath
*path
,
222 GtkSelectionData
*selection_data
);
223 gboolean
drag_data_received( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest
,
224 GtkSelectionData
*selection_data
);
225 gboolean
row_drop_possible( GtkTreeDragDest
*drag_dest
, GtkTreePath
*dest_path
,
226 GtkSelectionData
*selection_data
);
228 // notifactions from wxDataViewModel
229 bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
230 bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
231 bool ItemChanged( const wxDataViewItem
&item
);
232 bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
237 void SetSortOrder( GtkSortType sort_order
) { m_sort_order
= sort_order
; }
238 GtkSortType
GetSortOrder() const { return m_sort_order
; }
240 void SetSortColumn( int column
) { m_sort_column
= column
; }
241 int GetSortColumn() const { return m_sort_column
; }
243 void SetDataViewSortColumn( wxDataViewColumn
*column
) { m_dataview_sort_column
= column
; }
244 wxDataViewColumn
*GetDataViewSortColumn() { return m_dataview_sort_column
; }
246 bool IsSorted() { return (m_sort_column
>= 0); }
249 wxDataViewModel
* GetDataViewModel() { return m_wx_model
; }
250 const wxDataViewModel
* GetDataViewModel() const { return m_wx_model
; }
251 wxDataViewCtrl
* GetOwner() { return m_owner
; }
252 GtkWxTreeModel
* GetGtkModel() { return m_gtk_model
; }
254 // item can be deleted already in the model
255 int GetIndexOf( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
259 wxGtkTreeModelNode
*FindNode( const wxDataViewItem
&item
);
260 wxGtkTreeModelNode
*FindNode( GtkTreeIter
*iter
);
261 wxGtkTreeModelNode
*FindParentNode( const wxDataViewItem
&item
);
262 wxGtkTreeModelNode
*FindParentNode( GtkTreeIter
*iter
);
263 void BuildBranch( wxGtkTreeModelNode
*branch
);
266 wxGtkTreeModelNode
*m_root
;
267 wxDataViewModel
*m_wx_model
;
268 GtkWxTreeModel
*m_gtk_model
;
269 wxDataViewCtrl
*m_owner
;
270 GtkSortType m_sort_order
;
271 wxDataViewColumn
*m_dataview_sort_column
;
274 GtkTargetEntry m_dragSourceTargetEntry
;
275 wxCharBuffer m_dragSourceTargetEntryTarget
;
276 wxDataObject
*m_dragDataObject
;
278 GtkTargetEntry m_dropTargetTargetEntry
;
279 wxCharBuffer m_dropTargetTargetEntryTarget
;
280 wxDataObject
*m_dropDataObject
;
284 //-----------------------------------------------------------------------------
285 // wxGtkTreeModelNode
286 //-----------------------------------------------------------------------------
289 int LINKAGEMODE
wxGtkTreeModelChildCmp( void** id1
, void** id2
)
291 int ret
= gs_internal
->GetDataViewModel()->Compare( *id1
, *id2
,
292 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
297 WX_DEFINE_ARRAY_PTR( wxGtkTreeModelNode
*, wxGtkTreeModelNodes
);
298 WX_DEFINE_ARRAY_PTR( void*, wxGtkTreeModelChildren
);
300 class wxGtkTreeModelNode
303 wxGtkTreeModelNode( wxGtkTreeModelNode
* parent
, const wxDataViewItem
&item
,
304 wxDataViewCtrlInternal
*internal
)
308 m_internal
= internal
;
311 ~wxGtkTreeModelNode()
313 size_t count
= m_nodes
.GetCount();
315 for (i
= 0; i
< count
; i
++)
317 wxGtkTreeModelNode
*child
= m_nodes
.Item( i
);
322 unsigned int AddNode( wxGtkTreeModelNode
* child
)
324 m_nodes
.Add( child
);
326 void *id
= child
->GetItem().GetID();
328 m_children
.Add( id
);
330 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
332 gs_internal
= m_internal
;
333 m_children
.Sort( &wxGtkTreeModelChildCmp
);
334 return m_children
.Index( id
);
337 return m_children
.GetCount()-1;
340 unsigned int AddLeave( void* id
)
342 m_children
.Add( id
);
344 if (m_internal
->IsSorted() || m_internal
->GetDataViewModel()->HasDefaultCompare())
346 gs_internal
= m_internal
;
347 m_children
.Sort( &wxGtkTreeModelChildCmp
);
348 return m_children
.Index( id
);
351 return m_children
.GetCount()-1;
354 void DeleteChild( void* id
)
356 m_children
.Remove( id
);
358 unsigned int count
= m_nodes
.GetCount();
360 for (pos
= 0; pos
< count
; pos
++)
362 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
363 if (node
->GetItem().GetID() == id
)
365 m_nodes
.RemoveAt( pos
);
372 wxGtkTreeModelNode
* GetParent()
374 wxGtkTreeModelNodes
&GetNodes()
376 wxGtkTreeModelChildren
&GetChildren()
377 { return m_children
; }
379 unsigned int GetChildCount() const { return m_children
.GetCount(); }
380 unsigned int GetNodesCount() const { return m_nodes
.GetCount(); }
382 wxDataViewItem
&GetItem() { return m_item
; }
383 wxDataViewCtrlInternal
*GetInternal() { return m_internal
; }
388 wxGtkTreeModelNode
*m_parent
;
389 wxGtkTreeModelNodes m_nodes
;
390 wxGtkTreeModelChildren m_children
;
391 wxDataViewItem m_item
;
392 wxDataViewCtrlInternal
*m_internal
;
396 //-----------------------------------------------------------------------------
398 //-----------------------------------------------------------------------------
400 extern bool g_blockEventsOnDrag
;
402 //-----------------------------------------------------------------------------
403 // define new GTK+ class wxGtkTreeModel
404 //-----------------------------------------------------------------------------
408 #define GTK_TYPE_WX_TREE_MODEL (gtk_wx_tree_model_get_type ())
409 #define GTK_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
410 #define GTK_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
411 #define GTK_IS_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
412 #define GTK_IS_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
413 #define GTK_WX_TREE_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
415 GType
gtk_wx_tree_model_get_type (void);
417 typedef struct _GtkWxTreeModelClass GtkWxTreeModelClass
;
419 struct _GtkWxTreeModel
425 wxDataViewCtrlInternal
*internal
;
428 struct _GtkWxTreeModelClass
430 GObjectClass list_parent_class
;
433 static GtkWxTreeModel
*wxgtk_tree_model_new (void);
434 static void wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
);
435 static void wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
);
437 static void wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
);
438 static void wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
);
439 static void wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
);
440 static void wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
);
442 static void wxgtk_tree_model_finalize (GObject
*object
);
443 static GtkTreeModelFlags
wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
);
444 static gint
wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
);
445 static GType
wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
447 static gboolean
wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
450 static GtkTreePath
*wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
452 static void wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
456 static gboolean
wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
458 static gboolean
wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
460 GtkTreeIter
*parent
);
461 static gboolean
wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
463 static gint
wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
465 static gboolean
wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
469 static gboolean
wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
474 static gboolean
wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
475 gint
*sort_column_id
,
477 static void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
480 static void wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
482 GtkTreeIterCompareFunc func
,
484 GtkDestroyNotify destroy
);
485 static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
486 GtkTreeIterCompareFunc func
,
488 GtkDestroyNotify destroy
);
489 static gboolean
wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
);
492 static gboolean
wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
494 static gboolean
wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
496 static gboolean
wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
498 GtkSelectionData
*selection_data
);
499 static gboolean
wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
501 GtkSelectionData
*selection_data
);
502 static gboolean
wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
503 GtkTreePath
*dest_path
,
504 GtkSelectionData
*selection_data
);
507 static GObjectClass
*list_parent_class
= NULL
;
510 gtk_wx_tree_model_get_type (void)
512 static GType tree_model_type
= 0;
514 if (!tree_model_type
)
516 const GTypeInfo tree_model_info
=
518 sizeof (GtkWxTreeModelClass
),
519 NULL
, /* base_init */
520 NULL
, /* base_finalize */
521 (GClassInitFunc
) wxgtk_tree_model_class_init
,
522 NULL
, /* class_finalize */
523 NULL
, /* class_data */
524 sizeof (GtkWxTreeModel
),
526 (GInstanceInitFunc
) wxgtk_tree_model_init
,
529 static const GInterfaceInfo tree_model_iface_info
=
531 (GInterfaceInitFunc
) wxgtk_tree_model_tree_model_init
,
536 static const GInterfaceInfo sortable_iface_info
=
538 (GInterfaceInitFunc
) wxgtk_tree_model_sortable_init
,
543 static const GInterfaceInfo drag_source_iface_info
=
545 (GInterfaceInitFunc
) wxgtk_tree_model_drag_source_init
,
550 static const GInterfaceInfo drag_dest_iface_info
=
552 (GInterfaceInitFunc
) wxgtk_tree_model_drag_dest_init
,
557 tree_model_type
= g_type_register_static (G_TYPE_OBJECT
, "GtkWxTreeModel",
558 &tree_model_info
, (GTypeFlags
)0 );
560 g_type_add_interface_static (tree_model_type
,
562 &tree_model_iface_info
);
563 g_type_add_interface_static (tree_model_type
,
564 GTK_TYPE_TREE_SORTABLE
,
565 &sortable_iface_info
);
566 g_type_add_interface_static (tree_model_type
,
567 GTK_TYPE_TREE_DRAG_DEST
,
568 &drag_dest_iface_info
);
569 g_type_add_interface_static (tree_model_type
,
570 GTK_TYPE_TREE_DRAG_SOURCE
,
571 &drag_source_iface_info
);
574 return tree_model_type
;
577 static GtkWxTreeModel
*
578 wxgtk_tree_model_new(void)
580 GtkWxTreeModel
*retval
= (GtkWxTreeModel
*) g_object_new (GTK_TYPE_WX_TREE_MODEL
, NULL
);
585 wxgtk_tree_model_class_init (GtkWxTreeModelClass
*klass
)
587 list_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
588 GObjectClass
*object_class
= (GObjectClass
*) klass
;
589 object_class
->finalize
= wxgtk_tree_model_finalize
;
593 wxgtk_tree_model_tree_model_init (GtkTreeModelIface
*iface
)
595 iface
->get_flags
= wxgtk_tree_model_get_flags
;
596 iface
->get_n_columns
= wxgtk_tree_model_get_n_columns
;
597 iface
->get_column_type
= wxgtk_tree_model_get_column_type
;
598 iface
->get_iter
= wxgtk_tree_model_get_iter
;
599 iface
->get_path
= wxgtk_tree_model_get_path
;
600 iface
->get_value
= wxgtk_tree_model_get_value
;
601 iface
->iter_next
= wxgtk_tree_model_iter_next
;
602 iface
->iter_children
= wxgtk_tree_model_iter_children
;
603 iface
->iter_has_child
= wxgtk_tree_model_iter_has_child
;
604 iface
->iter_n_children
= wxgtk_tree_model_iter_n_children
;
605 iface
->iter_nth_child
= wxgtk_tree_model_iter_nth_child
;
606 iface
->iter_parent
= wxgtk_tree_model_iter_parent
;
610 wxgtk_tree_model_sortable_init (GtkTreeSortableIface
*iface
)
612 iface
->get_sort_column_id
= wxgtk_tree_model_get_sort_column_id
;
613 iface
->set_sort_column_id
= wxgtk_tree_model_set_sort_column_id
;
614 iface
->set_sort_func
= wxgtk_tree_model_set_sort_func
;
615 iface
->set_default_sort_func
= wxgtk_tree_model_set_default_sort_func
;
616 iface
->has_default_sort_func
= wxgtk_tree_model_has_default_sort_func
;
620 wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface
*iface
)
622 iface
->row_draggable
= wxgtk_tree_model_row_draggable
;
623 iface
->drag_data_delete
= wxgtk_tree_model_drag_data_delete
;
624 iface
->drag_data_get
= wxgtk_tree_model_drag_data_get
;
628 wxgtk_tree_model_drag_dest_init (GtkTreeDragDestIface
*iface
)
630 iface
->drag_data_received
= wxgtk_tree_model_drag_data_received
;
631 iface
->row_drop_possible
= wxgtk_tree_model_row_drop_possible
;
635 wxgtk_tree_model_init (GtkWxTreeModel
*tree_model
)
637 tree_model
->internal
= NULL
;
638 tree_model
->stamp
= g_random_int();
642 wxgtk_tree_model_finalize (GObject
*object
)
645 (* list_parent_class
->finalize
) (object
);
650 //-----------------------------------------------------------------------------
651 // implement callbacks from wxGtkTreeModel class by letting
652 // them call the methods of wxWidgets' wxDataViewModel
653 //-----------------------------------------------------------------------------
655 static GtkTreeModelFlags
656 wxgtk_tree_model_get_flags (GtkTreeModel
*tree_model
)
658 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
659 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), (GtkTreeModelFlags
)0 );
661 return wxtree_model
->internal
->get_flags();
665 wxgtk_tree_model_get_n_columns (GtkTreeModel
*tree_model
)
667 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
668 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
670 return wxtree_model
->internal
->GetDataViewModel()->GetColumnCount();
674 wxgtk_tree_model_get_column_type (GtkTreeModel
*tree_model
,
677 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
678 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), G_TYPE_INVALID
);
680 GType gtype
= G_TYPE_INVALID
;
682 wxString wxtype
= wxtree_model
->internal
->GetDataViewModel()->GetColumnType( (unsigned int) index
);
684 if (wxtype
== wxT("string"))
685 gtype
= G_TYPE_STRING
;
688 gtype
= G_TYPE_POINTER
;
689 // wxFAIL_MSG( wxT("non-string columns not supported for searching yet") );
696 wxgtk_tree_model_get_iter (GtkTreeModel
*tree_model
,
700 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
701 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
702 g_return_val_if_fail (gtk_tree_path_get_depth (path
) > 0, FALSE
);
704 return wxtree_model
->internal
->get_iter( iter
, path
);
708 wxgtk_tree_model_get_path (GtkTreeModel
*tree_model
,
711 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
712 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), NULL
);
713 g_return_val_if_fail (iter
->stamp
== GTK_WX_TREE_MODEL (wxtree_model
)->stamp
, NULL
);
715 return wxtree_model
->internal
->get_path( iter
);
719 wxgtk_tree_model_get_value (GtkTreeModel
*tree_model
,
724 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
725 g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
) );
727 wxDataViewModel
*model
= wxtree_model
->internal
->GetDataViewModel();
728 wxString mtype
= model
->GetColumnType( (unsigned int) column
);
729 if (mtype
== wxT("string"))
732 g_value_init( value
, G_TYPE_STRING
);
733 wxDataViewItem
item( (void*) iter
->user_data
);
734 model
->GetValue( variant
, item
, (unsigned int) column
);
736 g_value_set_string( value
, variant
.GetString().utf8_str() );
740 wxFAIL_MSG( wxT("non-string columns not supported yet") );
745 wxgtk_tree_model_iter_next (GtkTreeModel
*tree_model
,
748 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
750 // This happens when clearing the view by calling .._set_model( NULL );
751 if (iter
->stamp
== 0) return FALSE
;
753 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
754 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
756 return wxtree_model
->internal
->iter_next( iter
);
760 wxgtk_tree_model_iter_children (GtkTreeModel
*tree_model
,
764 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
765 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
768 g_return_val_if_fail (wxtree_model
->stamp
== parent
->stamp
, FALSE
);
771 return wxtree_model
->internal
->iter_children( iter
, parent
);
775 wxgtk_tree_model_iter_has_child (GtkTreeModel
*tree_model
,
778 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
779 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
780 g_return_val_if_fail (wxtree_model
->stamp
== iter
->stamp
, FALSE
);
782 return wxtree_model
->internal
->iter_has_child( iter
);
786 wxgtk_tree_model_iter_n_children (GtkTreeModel
*tree_model
,
789 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
790 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), 0);
791 g_return_val_if_fail ( !iter
|| wxtree_model
->stamp
== iter
->stamp
, 0);
793 return wxtree_model
->internal
->iter_n_children( iter
);
797 wxgtk_tree_model_iter_nth_child (GtkTreeModel
*tree_model
,
802 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
803 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
805 return wxtree_model
->internal
->iter_nth_child( iter
, parent
, n
);
809 wxgtk_tree_model_iter_parent (GtkTreeModel
*tree_model
,
813 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) tree_model
;
814 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
815 g_return_val_if_fail (wxtree_model
->stamp
== child
->stamp
, FALSE
);
817 return wxtree_model
->internal
->iter_parent( iter
, child
);
820 /* drag'n'drop iface */
822 wxgtk_tree_model_row_draggable (GtkTreeDragSource
*drag_source
,
825 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
826 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
828 return wxtree_model
->internal
->row_draggable( drag_source
, path
);
832 wxgtk_tree_model_drag_data_delete (GtkTreeDragSource
*drag_source
,
835 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
836 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
838 return wxtree_model
->internal
->drag_data_delete( drag_source
, path
);
842 wxgtk_tree_model_drag_data_get (GtkTreeDragSource
*drag_source
,
844 GtkSelectionData
*selection_data
)
846 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_source
;
847 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
850 wxPrintf( "drag_get_data\n");
852 wxGtkString
atom_selection(gdk_atom_name(selection_data
->selection
));
853 wxPrintf( "selection %s\n", wxString::FromAscii(atom_selection
) );
855 wxGtkString
atom_target(gdk_atom_name(selection_data
->target
));
856 wxPrintf( "target %s\n", wxString::FromAscii(atom_target
) );
858 wxGtkString
atom_type(gdk_atom_name(selection_data
->type
));
859 wxPrintf( "type %s\n", wxString::FromAscii(atom_type
) );
861 wxPrintf( "format %d\n", selection_data
->format
);
864 return wxtree_model
->internal
->drag_data_get( drag_source
, path
, selection_data
);
868 wxgtk_tree_model_drag_data_received (GtkTreeDragDest
*drag_dest
,
870 GtkSelectionData
*selection_data
)
872 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
873 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
875 return wxtree_model
->internal
->drag_data_received( drag_dest
, dest
, selection_data
);
879 wxgtk_tree_model_row_drop_possible (GtkTreeDragDest
*drag_dest
,
880 GtkTreePath
*dest_path
,
881 GtkSelectionData
*selection_data
)
883 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) drag_dest
;
884 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model
), FALSE
);
886 return wxtree_model
->internal
->row_drop_possible( drag_dest
, dest_path
, selection_data
);
891 wxgtk_tree_model_get_sort_column_id (GtkTreeSortable
*sortable
,
892 gint
*sort_column_id
,
895 GtkWxTreeModel
*wxtree_model
= (GtkWxTreeModel
*) sortable
;
897 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
899 if (!wxtree_model
->internal
->IsSorted())
902 *sort_column_id
= -1;
909 *sort_column_id
= wxtree_model
->internal
->GetSortColumn();
912 *order
= wxtree_model
->internal
->GetSortOrder();
917 wxDataViewColumn
*gs_lastLeftClickHeader
= NULL
;
920 wxgtk_tree_model_set_sort_column_id (GtkTreeSortable
*sortable
,
924 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) sortable
;
925 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
927 tree_model
->internal
->SetDataViewSortColumn( gs_lastLeftClickHeader
);
929 if ((sort_column_id
!= (gint
) tree_model
->internal
->GetSortColumn()) ||
930 (order
!= tree_model
->internal
->GetSortOrder()))
932 tree_model
->internal
->SetSortColumn( sort_column_id
);
933 tree_model
->internal
->SetSortOrder( order
);
935 gtk_tree_sortable_sort_column_changed (sortable
);
937 tree_model
->internal
->GetDataViewModel()->Resort();
940 if (gs_lastLeftClickHeader
)
942 wxDataViewCtrl
*dv
= tree_model
->internal
->GetOwner();
943 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED
, dv
->GetId() );
944 event
.SetDataViewColumn( gs_lastLeftClickHeader
);
945 event
.SetModel( dv
->GetModel() );
946 dv
->HandleWindowEvent( event
);
949 gs_lastLeftClickHeader
= NULL
;
953 wxgtk_tree_model_set_sort_func (GtkTreeSortable
*sortable
,
954 gint
WXUNUSED(sort_column_id
),
955 GtkTreeIterCompareFunc func
,
956 gpointer
WXUNUSED(data
),
957 GtkDestroyNotify
WXUNUSED(destroy
))
959 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
960 g_return_if_fail (func
!= NULL
);
964 wxgtk_tree_model_set_default_sort_func (GtkTreeSortable
*sortable
,
965 GtkTreeIterCompareFunc func
,
966 gpointer
WXUNUSED(data
),
967 GtkDestroyNotify
WXUNUSED(destroy
))
969 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable
) );
970 g_return_if_fail (func
!= NULL
);
972 //wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
973 // TODO: remove this code
977 wxgtk_tree_model_has_default_sort_func (GtkTreeSortable
*sortable
)
979 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable
), FALSE
);
984 //-----------------------------------------------------------------------------
985 // define new GTK+ class GtkWxRendererText
986 //-----------------------------------------------------------------------------
990 #define GTK_TYPE_WX_CELL_RENDERER_TEXT (gtk_wx_cell_renderer_text_get_type ())
991 #define GTK_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererText))
992 #define GTK_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
993 #define GTK_IS_WX_CELL_RENDERER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT))
994 #define GTK_IS_WX_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT))
995 #define GTK_WX_CELL_RENDERER_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
997 GType
gtk_wx_cell_renderer_text_get_type (void);
999 typedef struct _GtkWxCellRendererText GtkWxCellRendererText
;
1000 typedef struct _GtkWxCellRendererTextClass GtkWxCellRendererTextClass
;
1002 struct _GtkWxCellRendererText
1004 GtkCellRendererText parent
;
1006 wxDataViewRenderer
*wx_renderer
;
1009 struct _GtkWxCellRendererTextClass
1011 GtkCellRendererTextClass cell_parent_class
;
1015 static GtkWxCellRendererText
*gtk_wx_cell_renderer_text_new (void);
1016 static void gtk_wx_cell_renderer_text_init (
1017 GtkWxCellRendererText
*cell
);
1018 static void gtk_wx_cell_renderer_text_class_init(
1019 GtkWxCellRendererTextClass
*klass
);
1020 static void gtk_wx_cell_renderer_text_finalize (
1022 static GtkCellEditable
*gtk_wx_cell_renderer_text_start_editing(
1023 GtkCellRenderer
*cell
,
1027 GdkRectangle
*background_area
,
1028 GdkRectangle
*cell_area
,
1029 GtkCellRendererState flags
);
1032 static GObjectClass
*text_cell_parent_class
= NULL
;
1037 gtk_wx_cell_renderer_text_get_type (void)
1039 static GType cell_wx_type
= 0;
1043 const GTypeInfo cell_wx_info
=
1045 sizeof (GtkWxCellRendererTextClass
),
1046 NULL
, /* base_init */
1047 NULL
, /* base_finalize */
1048 (GClassInitFunc
) gtk_wx_cell_renderer_text_class_init
,
1049 NULL
, /* class_finalize */
1050 NULL
, /* class_data */
1051 sizeof (GtkWxCellRendererText
),
1052 0, /* n_preallocs */
1053 (GInstanceInitFunc
) gtk_wx_cell_renderer_text_init
,
1056 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER_TEXT
,
1057 "GtkWxCellRendererText", &cell_wx_info
, (GTypeFlags
)0 );
1060 return cell_wx_type
;
1064 gtk_wx_cell_renderer_text_init (GtkWxCellRendererText
*cell
)
1066 cell
->wx_renderer
= NULL
;
1070 gtk_wx_cell_renderer_text_class_init (GtkWxCellRendererTextClass
*klass
)
1072 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
1073 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
1075 text_cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
1077 object_class
->finalize
= gtk_wx_cell_renderer_text_finalize
;
1079 cell_class
->start_editing
= gtk_wx_cell_renderer_text_start_editing
;
1083 gtk_wx_cell_renderer_text_finalize (GObject
*object
)
1086 (* G_OBJECT_CLASS (text_cell_parent_class
)->finalize
) (object
);
1089 GtkWxCellRendererText
*
1090 gtk_wx_cell_renderer_text_new (void)
1092 return (GtkWxCellRendererText
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER_TEXT
, NULL
);
1095 static GtkCellEditable
*gtk_wx_cell_renderer_text_start_editing(
1096 GtkCellRenderer
*gtk_renderer
,
1097 GdkEvent
*gdk_event
,
1100 GdkRectangle
*background_area
,
1101 GdkRectangle
*cell_area
,
1102 GtkCellRendererState flags
)
1104 GtkWxCellRendererText
*wxgtk_renderer
= (GtkWxCellRendererText
*) gtk_renderer
;
1105 wxDataViewRenderer
*wx_renderer
= wxgtk_renderer
->wx_renderer
;
1106 wxDataViewColumn
*column
= wx_renderer
->GetOwner();
1109 item(column
->GetOwner()->GTKPathToItem(wxGtkTreePath(path
)));
1111 wxDataViewCtrl
*dv
= column
->GetOwner();
1112 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING
, dv
->GetId() );
1113 event
.SetDataViewColumn( column
);
1114 event
.SetModel( dv
->GetModel() );
1115 event
.SetColumn( column
->GetModelColumn() );
1116 event
.SetItem( item
);
1117 dv
->HandleWindowEvent( event
);
1119 if (event
.IsAllowed())
1120 return GTK_CELL_RENDERER_CLASS(text_cell_parent_class
)->
1121 start_editing( gtk_renderer
, gdk_event
, widget
, path
, background_area
, cell_area
, flags
);
1126 //-----------------------------------------------------------------------------
1127 // define new GTK+ class GtkWxCellRenderer
1128 //-----------------------------------------------------------------------------
1132 #define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
1133 #define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
1134 #define GTK_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
1135 #define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
1136 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
1137 #define GTK_WX_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
1139 GType
gtk_wx_cell_renderer_get_type (void);
1141 typedef struct _GtkWxCellRenderer GtkWxCellRenderer
;
1142 typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass
;
1144 struct _GtkWxCellRenderer
1146 GtkCellRenderer parent
;
1149 wxDataViewCustomRenderer
*cell
;
1153 struct _GtkWxCellRendererClass
1155 GtkCellRendererClass cell_parent_class
;
1159 static GtkCellRenderer
*gtk_wx_cell_renderer_new (void);
1160 static void gtk_wx_cell_renderer_init (
1161 GtkWxCellRenderer
*cell
);
1162 static void gtk_wx_cell_renderer_class_init(
1163 GtkWxCellRendererClass
*klass
);
1164 static void gtk_wx_cell_renderer_finalize (
1166 static void gtk_wx_cell_renderer_get_size (
1167 GtkCellRenderer
*cell
,
1169 GdkRectangle
*rectangle
,
1174 static void gtk_wx_cell_renderer_render (
1175 GtkCellRenderer
*cell
,
1178 GdkRectangle
*background_area
,
1179 GdkRectangle
*cell_area
,
1180 GdkRectangle
*expose_area
,
1181 GtkCellRendererState flags
);
1182 static gboolean
gtk_wx_cell_renderer_activate(
1183 GtkCellRenderer
*cell
,
1187 GdkRectangle
*background_area
,
1188 GdkRectangle
*cell_area
,
1189 GtkCellRendererState flags
);
1190 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
1191 GtkCellRenderer
*cell
,
1195 GdkRectangle
*background_area
,
1196 GdkRectangle
*cell_area
,
1197 GtkCellRendererState flags
);
1200 static GObjectClass
*cell_parent_class
= NULL
;
1205 gtk_wx_cell_renderer_get_type (void)
1207 static GType cell_wx_type
= 0;
1211 const GTypeInfo cell_wx_info
=
1213 sizeof (GtkWxCellRendererClass
),
1214 NULL
, /* base_init */
1215 NULL
, /* base_finalize */
1216 (GClassInitFunc
) gtk_wx_cell_renderer_class_init
,
1217 NULL
, /* class_finalize */
1218 NULL
, /* class_data */
1219 sizeof (GtkWxCellRenderer
),
1220 0, /* n_preallocs */
1221 (GInstanceInitFunc
) gtk_wx_cell_renderer_init
,
1224 cell_wx_type
= g_type_register_static( GTK_TYPE_CELL_RENDERER
,
1225 "GtkWxCellRenderer", &cell_wx_info
, (GTypeFlags
)0 );
1228 return cell_wx_type
;
1232 gtk_wx_cell_renderer_init (GtkWxCellRenderer
*cell
)
1235 cell
->last_click
= 0;
1239 gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass
*klass
)
1241 GObjectClass
*object_class
= G_OBJECT_CLASS (klass
);
1242 GtkCellRendererClass
*cell_class
= GTK_CELL_RENDERER_CLASS (klass
);
1244 cell_parent_class
= (GObjectClass
*) g_type_class_peek_parent (klass
);
1246 object_class
->finalize
= gtk_wx_cell_renderer_finalize
;
1248 cell_class
->get_size
= gtk_wx_cell_renderer_get_size
;
1249 cell_class
->render
= gtk_wx_cell_renderer_render
;
1250 cell_class
->activate
= gtk_wx_cell_renderer_activate
;
1251 cell_class
->start_editing
= gtk_wx_cell_renderer_start_editing
;
1255 gtk_wx_cell_renderer_finalize (GObject
*object
)
1258 (* G_OBJECT_CLASS (cell_parent_class
)->finalize
) (object
);
1262 gtk_wx_cell_renderer_new (void)
1264 return (GtkCellRenderer
*) g_object_new (GTK_TYPE_WX_CELL_RENDERER
, NULL
);
1267 static GtkCellEditable
*gtk_wx_cell_renderer_start_editing(
1268 GtkCellRenderer
*renderer
,
1269 GdkEvent
*WXUNUSED(event
),
1272 GdkRectangle
*WXUNUSED(background_area
),
1273 GdkRectangle
*cell_area
,
1274 GtkCellRendererState
WXUNUSED(flags
) )
1276 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1277 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1279 // Renderer doesn't support in-place editing
1280 if (!cell
->HasEditorCtrl())
1283 // An in-place editing control is still around
1284 if (cell
->GetEditorCtrl())
1288 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1294 rect
.x
+= cell_area
->x
;
1295 rect
.y
+= cell_area
->y
;
1296 // rect.width -= renderer->xpad * 2;
1297 // rect.height -= renderer->ypad * 2;
1299 // wxRect renderrect(wxRectFromGDKRect(&rect));
1300 wxRect
renderrect(wxRectFromGDKRect(cell_area
));
1303 item(cell
->GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(path
)));
1305 cell
->StartEditing( item
, renderrect
);
1311 gtk_wx_cell_renderer_get_size (GtkCellRenderer
*renderer
,
1312 GtkWidget
*WXUNUSED(widget
),
1313 GdkRectangle
*cell_area
,
1319 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1320 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1322 wxSize size
= cell
->GetSize();
1324 gint calc_width
= (gint
) renderer
->xpad
* 2 + size
.x
;
1325 gint calc_height
= (gint
) renderer
->ypad
* 2 + size
.y
;
1332 if (cell_area
&& size
.x
> 0 && size
.y
> 0)
1336 *x_offset
= (gint
)((renderer
->xalign
*
1337 (cell_area
->width
- calc_width
- 2 * renderer
->xpad
)));
1338 *x_offset
= MAX (*x_offset
, 0) + renderer
->xpad
;
1342 *y_offset
= (gint
)((renderer
->yalign
*
1343 (cell_area
->height
- calc_height
- 2 * renderer
->ypad
)));
1344 *y_offset
= MAX (*y_offset
, 0) + renderer
->ypad
;
1349 *width
= calc_width
;
1352 *height
= calc_height
;
1356 gtk_wx_cell_renderer_render (GtkCellRenderer
*renderer
,
1359 GdkRectangle
*background_area
,
1360 GdkRectangle
*cell_area
,
1361 GdkRectangle
*expose_area
,
1362 GtkCellRendererState flags
)
1365 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1366 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1368 cell
->GTKStashRenderParams(window
, widget
,
1369 background_area
, expose_area
, flags
);
1371 wxRect
rect(wxRectFromGDKRect(cell_area
));
1372 rect
= rect
.Deflate(renderer
->xpad
, renderer
->ypad
);
1374 wxWindowDC
* dc
= (wxWindowDC
*) cell
->GetDC();
1375 wxWindowDCImpl
*impl
= (wxWindowDCImpl
*) dc
->GetImpl();
1377 // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1378 // window such as a DnD drop window.
1379 if (window
!= impl
->m_gdkwindow
)
1382 impl
->m_gdkwindow
= window
;
1387 if (flags
& GTK_CELL_RENDERER_SELECTED
)
1388 state
|= wxDATAVIEW_CELL_SELECTED
;
1389 if (flags
& GTK_CELL_RENDERER_PRELIT
)
1390 state
|= wxDATAVIEW_CELL_PRELIT
;
1391 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1392 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1393 if (flags
& GTK_CELL_RENDERER_INSENSITIVE
)
1394 state
|= wxDATAVIEW_CELL_INSENSITIVE
;
1395 if (flags
& GTK_CELL_RENDERER_FOCUSED
)
1396 state
|= wxDATAVIEW_CELL_FOCUSED
;
1397 cell
->WXCallRender( rect
, dc
, state
);
1401 gtk_wx_cell_renderer_activate(
1402 GtkCellRenderer
*renderer
,
1406 GdkRectangle
*WXUNUSED(background_area
),
1407 GdkRectangle
*cell_area
,
1408 GtkCellRendererState
WXUNUSED(flags
) )
1410 GtkWxCellRenderer
*wxrenderer
= (GtkWxCellRenderer
*) renderer
;
1411 wxDataViewCustomRenderer
*cell
= wxrenderer
->cell
;
1414 gtk_wx_cell_renderer_get_size (renderer
, widget
, cell_area
,
1420 rect
.x
+= cell_area
->x
;
1421 rect
.y
+= cell_area
->y
;
1422 rect
.width
-= renderer
->xpad
* 2;
1423 rect
.height
-= renderer
->ypad
* 2;
1425 wxRect
renderrect(wxRectFromGDKRect(&rect
));
1427 wxDataViewCtrl
* const ctrl
= cell
->GetOwner()->GetOwner();
1428 wxDataViewModel
*model
= ctrl
->GetModel();
1430 wxDataViewItem
item(ctrl
->GTKPathToItem(wxGtkTreePath(path
)));
1432 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
1438 // activated by <ENTER>
1439 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1444 else if (event
->type
== GDK_BUTTON_PRESS
)
1446 GdkEventButton
*button_event
= (GdkEventButton
*) event
;
1447 wxPoint
pt( ((int) button_event
->x
) - renderrect
.x
,
1448 ((int) button_event
->y
) - renderrect
.y
);
1451 if (button_event
->button
== 1)
1453 if (cell
->LeftClick( pt
, renderrect
, model
, item
, model_col
))
1455 // TODO: query system double-click time
1456 if (button_event
->time
- wxrenderer
->last_click
< 400)
1457 if (cell
->Activate( renderrect
, model
, item
, model_col
))
1460 wxrenderer
->last_click
= button_event
->time
;
1468 // ---------------------------------------------------------
1469 // wxGtkDataViewModelNotifier
1470 // ---------------------------------------------------------
1472 class wxGtkDataViewModelNotifier
: public wxDataViewModelNotifier
1475 wxGtkDataViewModelNotifier( GtkWxTreeModel
*wxgtk_model
,
1476 wxDataViewModel
*wx_model
,
1477 wxDataViewCtrl
*ctrl
);
1478 ~wxGtkDataViewModelNotifier();
1480 virtual bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1481 virtual bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
1482 virtual bool ItemChanged( const wxDataViewItem
&item
);
1483 virtual bool ValueChanged( const wxDataViewItem
&item
, unsigned int col
);
1484 virtual bool Cleared();
1485 virtual void Resort();
1487 void SetGtkModel( GtkWxTreeModel
*model
) { m_wxgtk_model
= model
; }
1490 GtkWxTreeModel
*m_wxgtk_model
;
1491 wxDataViewModel
*m_wx_model
;
1492 wxDataViewCtrl
*m_owner
;
1495 // ---------------------------------------------------------
1496 // wxGtkDataViewListModelNotifier
1497 // ---------------------------------------------------------
1499 wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
1500 GtkWxTreeModel
* wxgtk_model
, wxDataViewModel
*wx_model
,
1501 wxDataViewCtrl
*ctrl
)
1503 m_wxgtk_model
= wxgtk_model
;
1504 m_wx_model
= wx_model
;
1508 wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
1511 m_wxgtk_model
= NULL
;
1514 bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1516 m_owner
->GtkGetInternal()->ItemAdded( parent
, item
);
1519 iter
.stamp
= m_wxgtk_model
->stamp
;
1520 iter
.user_data
= item
.GetID();
1522 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1523 GTK_TREE_MODEL(m_wxgtk_model
), &iter
));
1524 gtk_tree_model_row_inserted(
1525 GTK_TREE_MODEL(m_wxgtk_model
), path
, &iter
);
1530 bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
1533 // using _get_path for a deleted item cannot be
1536 iter
.stamp
= m_wxgtk_model
->stamp
;
1537 iter
.user_data
= (gpointer
) item
.GetID();
1538 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1539 GTK_TREE_MODEL(m_wxgtk_model
), &iter
));
1541 // so get the path from the parent
1543 iter
.stamp
= m_wxgtk_model
->stamp
;
1544 iter
.user_data
= (gpointer
) parent
.GetID();
1545 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1546 GTK_TREE_MODEL(m_wxgtk_model
), &iter
));
1547 // and add the final index ourselves
1548 int index
= m_owner
->GtkGetInternal()->GetIndexOf( parent
, item
);
1549 gtk_tree_path_append_index( path
, index
);
1552 gtk_tree_model_row_deleted(
1553 GTK_TREE_MODEL(m_wxgtk_model
), path
);
1555 m_owner
->GtkGetInternal()->ItemDeleted( parent
, item
);
1560 void wxGtkDataViewModelNotifier::Resort()
1562 m_owner
->GtkGetInternal()->Resort();
1565 bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem
&item
)
1568 iter
.stamp
= m_wxgtk_model
->stamp
;
1569 iter
.user_data
= (gpointer
) item
.GetID();
1571 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1572 GTK_TREE_MODEL(m_wxgtk_model
), &iter
));
1573 gtk_tree_model_row_changed(
1574 GTK_TREE_MODEL(m_wxgtk_model
), path
, &iter
);
1576 m_owner
->GtkGetInternal()->ItemChanged( item
);
1581 bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem
&item
, unsigned int model_col
)
1583 // This adds GTK+'s missing MVC logic for ValueChanged
1585 for (index
= 0; index
< m_owner
->GetColumnCount(); index
++)
1587 wxDataViewColumn
*column
= m_owner
->GetColumn( index
);
1588 if (column
->GetModelColumn() == model_col
)
1590 GtkTreeView
*widget
= GTK_TREE_VIEW(m_owner
->m_treeview
);
1591 GtkTreeViewColumn
*gcolumn
= GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle());
1595 iter
.stamp
= m_wxgtk_model
->stamp
;
1596 iter
.user_data
= (gpointer
) item
.GetID();
1597 wxGtkTreePath
path(wxgtk_tree_model_get_path(
1598 GTK_TREE_MODEL(m_wxgtk_model
), &iter
));
1599 GdkRectangle cell_area
;
1600 gtk_tree_view_get_cell_area( widget
, path
, gcolumn
, &cell_area
);
1602 GtkAdjustment
* hadjust
= gtk_tree_view_get_hadjustment( widget
);
1603 double d
= gtk_adjustment_get_value( hadjust
);
1604 int xdiff
= (int) d
;
1606 int ydiff
= gcolumn
->button
->allocation
.height
;
1608 gtk_widget_queue_draw_area( GTK_WIDGET(widget
),
1609 cell_area
.x
- xdiff
, ydiff
+ cell_area
.y
, cell_area
.width
, cell_area
.height
);
1611 m_owner
->GtkGetInternal()->ValueChanged( item
, model_col
);
1620 bool wxGtkDataViewModelNotifier::Cleared()
1622 // There is no call to tell the model that everything
1623 // has been deleted so call row_deleted() for every
1626 int count
= m_owner
->GtkGetInternal()->iter_n_children( NULL
); // number of children of root
1628 GtkTreePath
*path
= gtk_tree_path_new_first(); // points to root
1631 for (i
= 0; i
< count
; i
++)
1632 gtk_tree_model_row_deleted( GTK_TREE_MODEL(m_wxgtk_model
), path
);
1634 gtk_tree_path_free( path
);
1636 m_owner
->GtkGetInternal()->Cleared();
1641 // ---------------------------------------------------------
1642 // wxDataViewRenderer
1643 // ---------------------------------------------------------
1645 static gpointer s_user_data
= NULL
;
1648 wxgtk_cell_editable_editing_done( GtkCellEditable
*WXUNUSED(editable
),
1649 wxDataViewRenderer
*wxrenderer
)
1651 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1652 wxDataViewCtrl
*dv
= column
->GetOwner();
1653 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE
, dv
->GetId() );
1654 event
.SetDataViewColumn( column
);
1655 event
.SetModel( dv
->GetModel() );
1656 wxDataViewItem
item( s_user_data
);
1657 event
.SetItem( item
);
1658 dv
->HandleWindowEvent( event
);
1662 wxgtk_renderer_editing_started( GtkCellRenderer
*WXUNUSED(cell
), GtkCellEditable
*editable
,
1663 gchar
*path
, wxDataViewRenderer
*wxrenderer
)
1668 wxDataViewColumn
*column
= wxrenderer
->GetOwner();
1669 wxDataViewCtrl
*dv
= column
->GetOwner();
1670 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED
, dv
->GetId() );
1671 event
.SetDataViewColumn( column
);
1672 event
.SetModel( dv
->GetModel() );
1673 wxDataViewItem
item(dv
->GTKPathToItem(wxGtkTreePath(path
)));
1674 event
.SetItem( item
);
1675 dv
->HandleWindowEvent( event
);
1677 if (GTK_IS_CELL_EDITABLE(editable
))
1679 s_user_data
= item
.GetID();
1681 g_signal_connect (GTK_CELL_EDITABLE (editable
), "editing_done",
1682 G_CALLBACK (wxgtk_cell_editable_editing_done
),
1683 (gpointer
) wxrenderer
);
1689 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer
, wxDataViewRendererBase
)
1691 wxDataViewRenderer::wxDataViewRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
1693 wxDataViewRendererBase( varianttype
, mode
, align
)
1697 // we haven't changed them yet
1698 m_usingDefaultAttrs
= true;
1700 // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1701 // after the m_renderer pointer has been initialized
1704 void wxDataViewRenderer::GtkPackIntoColumn(GtkTreeViewColumn
*column
)
1706 gtk_tree_view_column_pack_end( column
, m_renderer
, TRUE
/* expand */);
1709 void wxDataViewRenderer::GtkInitHandlers()
1711 if (!gtk_check_version(2,6,0))
1713 g_signal_connect (GTK_CELL_RENDERER(m_renderer
), "editing_started",
1714 G_CALLBACK (wxgtk_renderer_editing_started
),
1719 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode
)
1721 GtkCellRendererMode gtkMode
;
1724 case wxDATAVIEW_CELL_INERT
:
1725 gtkMode
= GTK_CELL_RENDERER_MODE_INERT
;
1728 case wxDATAVIEW_CELL_ACTIVATABLE
:
1729 gtkMode
= GTK_CELL_RENDERER_MODE_ACTIVATABLE
;
1732 case wxDATAVIEW_CELL_EDITABLE
:
1733 gtkMode
= GTK_CELL_RENDERER_MODE_EDITABLE
;
1737 wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1741 // This value is most often ignored in GtkTreeView
1742 GValue gvalue
= { 0, };
1743 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
1744 g_value_set_enum( &gvalue
, gtkMode
);
1745 g_object_set_property( G_OBJECT(m_renderer
), "mode", &gvalue
);
1746 g_value_unset( &gvalue
);
1749 wxDataViewCellMode
wxDataViewRenderer::GetMode() const
1751 wxDataViewCellMode ret
;
1754 g_object_get( G_OBJECT(m_renderer
), "mode", &gvalue
, NULL
);
1756 switch (g_value_get_enum(&gvalue
))
1759 wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1760 // fall through (we have to return something)
1762 case GTK_CELL_RENDERER_MODE_INERT
:
1763 ret
= wxDATAVIEW_CELL_INERT
;
1766 case GTK_CELL_RENDERER_MODE_ACTIVATABLE
:
1767 ret
= wxDATAVIEW_CELL_ACTIVATABLE
;
1770 case GTK_CELL_RENDERER_MODE_EDITABLE
:
1771 ret
= wxDATAVIEW_CELL_EDITABLE
;
1775 g_value_unset( &gvalue
);
1780 void wxDataViewRenderer::GtkUpdateAlignment()
1782 int align
= m_alignment
;
1784 // query alignment from column ?
1788 if (GetOwner() == NULL
)
1791 align
= GetOwner()->GetAlignment();
1792 align
|= wxALIGN_CENTRE_VERTICAL
;
1795 // horizontal alignment:
1797 gfloat xalign
= 0.0;
1798 if (align
& wxALIGN_RIGHT
)
1800 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
1803 GValue gvalue
= { 0, };
1804 g_value_init( &gvalue
, G_TYPE_FLOAT
);
1805 g_value_set_float( &gvalue
, xalign
);
1806 g_object_set_property( G_OBJECT(m_renderer
), "xalign", &gvalue
);
1807 g_value_unset( &gvalue
);
1809 // vertical alignment:
1811 gfloat yalign
= 0.0;
1812 if (align
& wxALIGN_BOTTOM
)
1814 else if (align
& wxALIGN_CENTER_VERTICAL
)
1817 GValue gvalue2
= { 0, };
1818 g_value_init( &gvalue2
, G_TYPE_FLOAT
);
1819 g_value_set_float( &gvalue2
, yalign
);
1820 g_object_set_property( G_OBJECT(m_renderer
), "yalign", &gvalue2
);
1821 g_value_unset( &gvalue2
);
1824 void wxDataViewRenderer::SetAlignment( int align
)
1826 m_alignment
= align
;
1827 GtkUpdateAlignment();
1830 int wxDataViewRenderer::GetAlignment() const
1835 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode
)
1838 if ( gtk_check_version(2, 6, 0) != NULL
)
1841 GtkCellRendererText
* const rend
= GtkGetTextRenderer();
1845 // we use the same values in wxEllipsizeMode as PangoEllipsizeMode so we
1846 // can just cast between them
1847 GValue gvalue
= { 0, };
1848 g_value_init( &gvalue
, PANGO_TYPE_ELLIPSIZE_MODE
);
1849 g_value_set_enum( &gvalue
, static_cast<PangoEllipsizeMode
>(mode
) );
1850 g_object_set_property( G_OBJECT(rend
), "ellipsize", &gvalue
);
1851 g_value_unset( &gvalue
);
1854 #endif // GTK 2.6/before
1857 wxEllipsizeMode
wxDataViewRenderer::GetEllipsizeMode() const
1860 if ( gtk_check_version(2, 6, 0) != NULL
)
1861 return wxELLIPSIZE_NONE
;
1863 GtkCellRendererText
* const rend
= GtkGetTextRenderer();
1865 return wxELLIPSIZE_NONE
;
1867 GValue gvalue
= { 0, };
1868 g_value_init( &gvalue
, PANGO_TYPE_ELLIPSIZE_MODE
);
1869 g_object_get_property( G_OBJECT(rend
), "ellipsize", &gvalue
);
1871 mode
= static_cast<wxEllipsizeMode
>(g_value_get_enum( &gvalue
));
1872 g_value_unset( &gvalue
);
1876 return wxELLIPSIZE_NONE
;
1877 #endif // GTK 2.6/before
1881 wxDataViewRenderer::GtkOnTextEdited(const gchar
*itempath
, const wxString
& str
)
1883 wxVariant
value(str
);
1884 if (!Validate( value
))
1888 item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath
)));
1890 GtkOnCellChanged(value
, item
, GetOwner()->GetModelColumn());
1894 wxDataViewRenderer::GtkOnCellChanged(const wxVariant
& value
,
1895 const wxDataViewItem
& item
,
1898 wxDataViewModel
*model
= GetOwner()->GetOwner()->GetModel();
1899 model
->ChangeValue( value
, item
, col
);
1902 // ---------------------------------------------------------
1903 // wxDataViewTextRenderer
1904 // ---------------------------------------------------------
1909 static void wxGtkTextRendererEditedCallback( GtkCellRendererText
*WXUNUSED(renderer
),
1910 gchar
*arg1
, gchar
*arg2
, gpointer user_data
)
1912 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) user_data
;
1914 cell
->GtkOnTextEdited(arg1
, wxGTK_CONV_BACK_FONT(
1915 arg2
, cell
->GetOwner()->GetOwner()->GetFont()));
1923 // helper function used by wxDataViewTextRenderer and
1924 // wxDataViewCustomRenderer::RenderText(): it applies the attributes to the
1925 // given text renderer and returns true if anything was done
1926 bool GtkApplyAttr(GtkCellRendererText
*renderer
, const wxDataViewItemAttr
& attr
)
1928 bool usingDefaultAttrs
= true;
1929 if (attr
.HasColour())
1931 const GdkColor
* const gcol
= attr
.GetColour().GetColor();
1933 GValue gvalue
= { 0, };
1934 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
1935 g_value_set_boxed( &gvalue
, gcol
);
1936 g_object_set_property( G_OBJECT(renderer
), "foreground_gdk", &gvalue
);
1937 g_value_unset( &gvalue
);
1939 usingDefaultAttrs
= false;
1943 GValue gvalue
= { 0, };
1944 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1945 g_value_set_boolean( &gvalue
, FALSE
);
1946 g_object_set_property( G_OBJECT(renderer
), "foreground-set", &gvalue
);
1947 g_value_unset( &gvalue
);
1950 if (attr
.GetItalic())
1952 GValue gvalue
= { 0, };
1953 g_value_init( &gvalue
, PANGO_TYPE_STYLE
);
1954 g_value_set_enum( &gvalue
, PANGO_STYLE_ITALIC
);
1955 g_object_set_property( G_OBJECT(renderer
), "style", &gvalue
);
1956 g_value_unset( &gvalue
);
1958 usingDefaultAttrs
= false;
1962 GValue gvalue
= { 0, };
1963 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1964 g_value_set_boolean( &gvalue
, FALSE
);
1965 g_object_set_property( G_OBJECT(renderer
), "style-set", &gvalue
);
1966 g_value_unset( &gvalue
);
1972 GValue gvalue
= { 0, };
1973 g_value_init( &gvalue
, PANGO_TYPE_WEIGHT
);
1974 g_value_set_enum( &gvalue
, PANGO_WEIGHT_BOLD
);
1975 g_object_set_property( G_OBJECT(renderer
), "weight", &gvalue
);
1976 g_value_unset( &gvalue
);
1978 usingDefaultAttrs
= false;
1982 GValue gvalue
= { 0, };
1983 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
1984 g_value_set_boolean( &gvalue
, FALSE
);
1985 g_object_set_property( G_OBJECT(renderer
), "weight-set", &gvalue
);
1986 g_value_unset( &gvalue
);
1990 if (attr
.HasBackgroundColour())
1992 wxColour colour
= attr
.GetBackgroundColour();
1993 const GdkColor
* const gcol
= colour
.GetColor();
1995 GValue gvalue
= { 0, };
1996 g_value_init( &gvalue
, GDK_TYPE_COLOR
);
1997 g_value_set_boxed( &gvalue
, gcol
);
1998 g_object_set_property( G_OBJECT(renderer
), "cell-background_gdk", &gvalue
);
1999 g_value_unset( &gvalue
);
2003 GValue gvalue
= { 0, };
2004 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2005 g_value_set_boolean( &gvalue
, FALSE
);
2006 g_object_set_property( G_OBJECT(renderer
), "cell-background-set", &gvalue
);
2007 g_value_unset( &gvalue
);
2011 return !usingDefaultAttrs
;
2014 } // anonymous namespace
2016 IMPLEMENT_CLASS(wxDataViewTextRenderer
, wxDataViewRenderer
)
2018 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
2020 wxDataViewRenderer( varianttype
, mode
, align
)
2022 GtkWxCellRendererText
*text_renderer
= gtk_wx_cell_renderer_text_new();
2023 text_renderer
->wx_renderer
= this;
2024 m_renderer
= (GtkCellRenderer
*) text_renderer
;
2026 if (mode
& wxDATAVIEW_CELL_EDITABLE
)
2028 GValue gvalue
= { 0, };
2029 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2030 g_value_set_boolean( &gvalue
, true );
2031 g_object_set_property( G_OBJECT(m_renderer
), "editable", &gvalue
);
2032 g_value_unset( &gvalue
);
2034 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
2040 SetAlignment(align
);
2043 bool wxDataViewTextRenderer::SetTextValue(const wxString
& str
)
2045 GValue gvalue
= { 0, };
2046 g_value_init( &gvalue
, G_TYPE_STRING
);
2047 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( str
, GetOwner()->GetOwner()->GetFont() ) );
2048 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2049 g_value_unset( &gvalue
);
2054 bool wxDataViewTextRenderer::GetTextValue(wxString
& str
) const
2056 GValue gvalue
= { 0, };
2057 g_value_init( &gvalue
, G_TYPE_STRING
);
2058 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2059 str
= wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue
), const_cast<wxDataViewTextRenderer
*>(this)->GetOwner()->GetOwner()->GetFont() );
2060 g_value_unset( &gvalue
);
2065 void wxDataViewTextRenderer::SetAlignment( int align
)
2067 wxDataViewRenderer::SetAlignment(align
);
2069 if (gtk_check_version(2,10,0))
2072 // horizontal alignment:
2073 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
2074 if (align
& wxALIGN_RIGHT
)
2075 pangoAlign
= PANGO_ALIGN_RIGHT
;
2076 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
2077 pangoAlign
= PANGO_ALIGN_CENTER
;
2079 GValue gvalue
= { 0, };
2080 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
2081 g_value_set_enum( &gvalue
, pangoAlign
);
2082 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
2083 g_value_unset( &gvalue
);
2086 bool wxDataViewTextRenderer::GtkSetAttr(const wxDataViewItemAttr
& attr
)
2088 return GtkApplyAttr(GtkGetTextRenderer(), attr
);
2091 GtkCellRendererText
*wxDataViewTextRenderer::GtkGetTextRenderer() const
2093 return GTK_CELL_RENDERER_TEXT(m_renderer
);
2096 // ---------------------------------------------------------
2097 // wxDataViewBitmapRenderer
2098 // ---------------------------------------------------------
2103 // set "pixbuf" property on the given renderer
2104 void SetPixbufProp(GtkCellRenderer
*renderer
, GdkPixbuf
*pixbuf
)
2106 GValue gvalue
= { 0, };
2107 g_value_init( &gvalue
, G_TYPE_OBJECT
);
2108 g_value_set_object( &gvalue
, pixbuf
);
2109 g_object_set_property( G_OBJECT(renderer
), "pixbuf", &gvalue
);
2110 g_value_unset( &gvalue
);
2113 } // anonymous namespace
2115 IMPLEMENT_CLASS(wxDataViewBitmapRenderer
, wxDataViewRenderer
)
2117 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString
&varianttype
, wxDataViewCellMode mode
,
2119 wxDataViewRenderer( varianttype
, mode
, align
)
2121 m_renderer
= gtk_cell_renderer_pixbuf_new();
2124 SetAlignment(align
);
2127 bool wxDataViewBitmapRenderer::SetValue( const wxVariant
&value
)
2129 if (value
.GetType() == wxT("wxBitmap"))
2134 // GetPixbuf() may create a Pixbuf representation in the wxBitmap
2135 // object (and it will stay there and remain owned by wxBitmap)
2136 SetPixbufProp(m_renderer
, bitmap
.GetPixbuf());
2138 else if (value
.GetType() == wxT("wxIcon"))
2143 SetPixbufProp(m_renderer
, icon
.GetPixbuf());
2153 bool wxDataViewBitmapRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2158 // ---------------------------------------------------------
2159 // wxDataViewToggleRenderer
2160 // ---------------------------------------------------------
2163 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
2164 gchar
*path
, gpointer user_data
);
2167 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle
*renderer
,
2168 gchar
*path
, gpointer user_data
)
2170 wxDataViewToggleRenderer
*cell
= (wxDataViewToggleRenderer
*) user_data
;
2173 GValue gvalue
= { 0, };
2174 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2175 g_object_get_property( G_OBJECT(renderer
), "active", &gvalue
);
2176 bool tmp
= g_value_get_boolean( &gvalue
);
2177 g_value_unset( &gvalue
);
2181 wxVariant value
= tmp
;
2182 if (!cell
->Validate( value
))
2185 wxDataViewCtrl
* const ctrl
= cell
->GetOwner()->GetOwner();
2186 wxDataViewModel
*model
= ctrl
->GetModel();
2188 wxDataViewItem
item(ctrl
->GTKPathToItem(wxGtkTreePath(path
)));
2190 unsigned int model_col
= cell
->GetOwner()->GetModelColumn();
2192 model
->ChangeValue( value
, item
, model_col
);
2195 IMPLEMENT_CLASS(wxDataViewToggleRenderer
, wxDataViewRenderer
)
2197 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString
&varianttype
,
2198 wxDataViewCellMode mode
, int align
) :
2199 wxDataViewRenderer( varianttype
, mode
, align
)
2201 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_toggle_new();
2203 if (mode
& wxDATAVIEW_CELL_ACTIVATABLE
)
2205 g_signal_connect_after( m_renderer
, "toggled",
2206 G_CALLBACK(wxGtkToggleRendererToggledCallback
), this );
2210 GValue gvalue
= { 0, };
2211 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2212 g_value_set_boolean( &gvalue
, false );
2213 g_object_set_property( G_OBJECT(m_renderer
), "activatable", &gvalue
);
2214 g_value_unset( &gvalue
);
2218 SetAlignment(align
);
2221 bool wxDataViewToggleRenderer::SetValue( const wxVariant
&value
)
2225 GValue gvalue
= { 0, };
2226 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2227 g_value_set_boolean( &gvalue
, tmp
);
2228 g_object_set_property( G_OBJECT(m_renderer
), "active", &gvalue
);
2229 g_value_unset( &gvalue
);
2234 bool wxDataViewToggleRenderer::GetValue( wxVariant
&value
) const
2236 GValue gvalue
= { 0, };
2237 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2238 g_object_get_property( G_OBJECT(m_renderer
), "active", &gvalue
);
2239 bool tmp
= g_value_get_boolean( &gvalue
);
2240 g_value_unset( &gvalue
);
2247 // ---------------------------------------------------------
2248 // wxDataViewCustomRenderer
2249 // ---------------------------------------------------------
2251 class wxDataViewCtrlDCImpl
: public wxWindowDCImpl
2254 wxDataViewCtrlDCImpl( wxDC
*owner
, wxDataViewCtrl
*window
) :
2255 wxWindowDCImpl( owner
)
2257 GtkWidget
*widget
= window
->m_treeview
;
2263 m_context
= window
->GTKGetPangoDefaultContext();
2264 m_layout
= pango_layout_new( m_context
);
2265 m_fontdesc
= pango_font_description_copy( widget
->style
->font_desc
);
2267 m_cmap
= gtk_widget_get_colormap( widget
? widget
: window
->m_widget
);
2269 // Set m_gdkwindow later
2274 class wxDataViewCtrlDC
: public wxWindowDC
2277 wxDataViewCtrlDC( wxDataViewCtrl
*window
) :
2278 wxWindowDC( new wxDataViewCtrlDCImpl( this, window
) )
2283 // ---------------------------------------------------------
2284 // wxDataViewCustomRenderer
2285 // ---------------------------------------------------------
2287 IMPLEMENT_CLASS(wxDataViewCustomRenderer
, wxDataViewRenderer
)
2289 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString
&varianttype
,
2290 wxDataViewCellMode mode
,
2293 : wxDataViewCustomRendererBase( varianttype
, mode
, align
)
2296 m_text_renderer
= NULL
;
2304 GtkCellRendererText
*wxDataViewCustomRenderer::GtkGetTextRenderer() const
2306 if ( !m_text_renderer
)
2308 // we create it on demand so need to do it even from a const function
2309 const_cast<wxDataViewCustomRenderer
*>(this)->
2310 m_text_renderer
= GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
2313 return m_text_renderer
;
2316 void wxDataViewCustomRenderer::RenderText( const wxString
&text
,
2320 int WXUNUSED(state
) )
2323 GtkCellRendererText
* const textRenderer
= GtkGetTextRenderer();
2325 GValue gvalue
= { 0, };
2326 g_value_init( &gvalue
, G_TYPE_STRING
);
2327 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( text
, GetOwner()->GetOwner()->GetFont() ) );
2328 g_object_set_property( G_OBJECT(textRenderer
), "text", &gvalue
);
2329 g_value_unset( &gvalue
);
2331 GtkApplyAttr(textRenderer
, GetAttr());
2333 GdkRectangle cell_area
;
2334 wxRectToGDKRect(cell
, cell_area
);
2335 cell_area
.x
+= xoffset
;
2336 cell_area
.width
-= xoffset
;
2338 gtk_cell_renderer_render( GTK_CELL_RENDERER(textRenderer
),
2339 m_renderParams
.window
,
2340 m_renderParams
.widget
,
2341 m_renderParams
.background_area
,
2343 m_renderParams
.expose_area
,
2344 (GtkCellRendererState
) m_renderParams
.flags
);
2347 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode
, int align
)
2349 GtkWxCellRenderer
*renderer
= (GtkWxCellRenderer
*) gtk_wx_cell_renderer_new();
2350 renderer
->cell
= this;
2352 m_renderer
= (GtkCellRenderer
*) renderer
;
2355 SetAlignment(align
);
2362 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
2367 if (m_text_renderer
)
2368 gtk_object_sink( GTK_OBJECT(m_text_renderer
) );
2371 wxDC
*wxDataViewCustomRenderer::GetDC()
2375 if (GetOwner() == NULL
)
2377 if (GetOwner()->GetOwner() == NULL
)
2379 m_dc
= new wxDataViewCtrlDC( GetOwner()->GetOwner() );
2385 // ---------------------------------------------------------
2386 // wxDataViewProgressRenderer
2387 // ---------------------------------------------------------
2389 IMPLEMENT_CLASS(wxDataViewProgressRenderer
, wxDataViewCustomRenderer
)
2391 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString
&label
,
2392 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
2393 wxDataViewCustomRenderer( varianttype
, mode
, align
, true )
2399 if (!gtk_check_version(2,6,0))
2401 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_progress_new();
2403 GValue gvalue
= { 0, };
2404 g_value_init( &gvalue
, G_TYPE_STRING
);
2406 g_value_set_string( &gvalue
, wxGTK_CONV_FONT( m_label
, GetOwner()->GetOwner()->GetFont() ) );
2407 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2408 g_value_unset( &gvalue
);
2411 SetAlignment(align
);
2416 // Use custom cell code
2417 wxDataViewCustomRenderer::Init(mode
, align
);
2421 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
2425 bool wxDataViewProgressRenderer::SetValue( const wxVariant
&value
)
2428 if (!gtk_check_version(2,6,0))
2430 gint tmp
= (long) value
;
2431 GValue gvalue
= { 0, };
2432 g_value_init( &gvalue
, G_TYPE_INT
);
2433 g_value_set_int( &gvalue
, tmp
);
2434 g_object_set_property( G_OBJECT(m_renderer
), "value", &gvalue
);
2435 g_value_unset( &gvalue
);
2440 m_value
= (long) value
;
2442 if (m_value
< 0) m_value
= 0;
2443 if (m_value
> 100) m_value
= 100;
2449 bool wxDataViewProgressRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2454 bool wxDataViewProgressRenderer::Render( wxRect cell
, wxDC
*dc
, int WXUNUSED(state
) )
2456 double pct
= (double)m_value
/ 100.0;
2458 bar
.width
= (int)(cell
.width
* pct
);
2459 dc
->SetPen( *wxTRANSPARENT_PEN
);
2460 dc
->SetBrush( *wxBLUE_BRUSH
);
2461 dc
->DrawRectangle( bar
);
2463 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
2464 dc
->SetPen( *wxBLACK_PEN
);
2465 dc
->DrawRectangle( cell
);
2470 wxSize
wxDataViewProgressRenderer::GetSize() const
2472 return wxSize(40,12);
2475 // -------------------------------------
2476 // wxDataViewChoiceRenderer
2477 // -------------------------------------
2479 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString
&choices
,
2480 wxDataViewCellMode mode
, int alignment
) :
2481 wxDataViewCustomRenderer( "string", mode
, alignment
, true )
2483 m_choices
= choices
;
2486 if (!gtk_check_version(2,6,0))
2488 m_renderer
= (GtkCellRenderer
*) gtk_cell_renderer_combo_new();
2490 GtkListStore
*store
= gtk_list_store_new( 1, G_TYPE_STRING
);
2491 for (size_t n
= 0; n
< m_choices
.GetCount(); n
++)
2493 gtk_list_store_insert_with_values(
2495 static_cast<const char *>(m_choices
[n
].utf8_str()), -1 );
2498 g_object_set (m_renderer
,
2504 bool editable
= (mode
& wxDATAVIEW_CELL_EDITABLE
);
2505 g_object_set (m_renderer
, "editable", editable
, NULL
);
2507 SetAlignment(alignment
);
2509 g_signal_connect_after( m_renderer
, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback
), this );
2516 // Use custom cell code
2517 wxDataViewCustomRenderer::Init(mode
, alignment
);
2521 bool wxDataViewChoiceRenderer::Render( wxRect rect
, wxDC
*dc
, int state
)
2523 RenderText( m_data
, 0, rect
, dc
, state
);
2527 wxSize
wxDataViewChoiceRenderer::GetSize() const
2529 return wxSize(70,20);
2532 bool wxDataViewChoiceRenderer::SetValue( const wxVariant
&value
)
2536 if (!gtk_check_version(2,6,0))
2538 GValue gvalue
= { 0, };
2539 g_value_init( &gvalue
, G_TYPE_STRING
);
2540 g_value_set_string(&gvalue
,
2541 wxGTK_CONV_FONT(value
.GetString(),
2542 GetOwner()->GetOwner()->GetFont()));
2543 g_object_set_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2544 g_value_unset( &gvalue
);
2548 m_data
= value
.GetString();
2553 bool wxDataViewChoiceRenderer::GetValue( wxVariant
&value
) const
2556 if (!gtk_check_version(2,6,0))
2558 GValue gvalue
= { 0, };
2559 g_value_init( &gvalue
, G_TYPE_STRING
);
2560 g_object_get_property( G_OBJECT(m_renderer
), "text", &gvalue
);
2561 wxString temp
= wxGTK_CONV_BACK_FONT(g_value_get_string(&gvalue
),
2562 GetOwner()->GetOwner()->GetFont());
2563 g_value_unset( &gvalue
);
2566 //wxPrintf( "temp %s\n", temp );
2567 // TODO: remove this code
2576 void wxDataViewChoiceRenderer::SetAlignment( int align
)
2578 wxDataViewCustomRenderer::SetAlignment(align
);
2580 if (gtk_check_version(2,10,0))
2583 // horizontal alignment:
2584 PangoAlignment pangoAlign
= PANGO_ALIGN_LEFT
;
2585 if (align
& wxALIGN_RIGHT
)
2586 pangoAlign
= PANGO_ALIGN_RIGHT
;
2587 else if (align
& wxALIGN_CENTER_HORIZONTAL
)
2588 pangoAlign
= PANGO_ALIGN_CENTER
;
2590 GValue gvalue
= { 0, };
2591 g_value_init( &gvalue
, gtk_cell_renderer_mode_get_type() );
2592 g_value_set_enum( &gvalue
, pangoAlign
);
2593 g_object_set_property( G_OBJECT(m_renderer
), "alignment", &gvalue
);
2594 g_value_unset( &gvalue
);
2597 // ----------------------------------------------------------------------------
2598 // wxDataViewChoiceByIndexRenderer
2599 // ----------------------------------------------------------------------------
2601 wxDataViewChoiceByIndexRenderer::wxDataViewChoiceByIndexRenderer( const wxArrayString
&choices
,
2602 wxDataViewCellMode mode
, int alignment
) :
2603 wxDataViewChoiceRenderer( choices
, mode
, alignment
)
2607 void wxDataViewChoiceByIndexRenderer::GtkOnTextEdited(const gchar
*itempath
, const wxString
& str
)
2609 wxVariant
value( (long) GetChoices().Index( str
) );
2611 if (!Validate( value
))
2615 item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath
)));
2617 GtkOnCellChanged(value
, item
, GetOwner()->GetModelColumn());
2620 bool wxDataViewChoiceByIndexRenderer::SetValue( const wxVariant
&value
)
2622 wxVariant string_value
= GetChoice( value
.GetLong() );
2623 return wxDataViewChoiceRenderer::SetValue( string_value
);
2626 bool wxDataViewChoiceByIndexRenderer::GetValue( wxVariant
&value
) const
2628 wxVariant string_value
;
2629 if (!wxDataViewChoiceRenderer::GetValue( string_value
))
2632 value
= (long) GetChoices().Index( string_value
.GetString() );
2636 // ---------------------------------------------------------
2637 // wxDataViewDateRenderer
2638 // ---------------------------------------------------------
2640 class wxDataViewDateRendererPopupTransient
: public wxPopupTransientWindow
2643 wxDataViewDateRendererPopupTransient( wxWindow
* parent
, wxDateTime
*value
,
2644 wxDataViewModel
*model
, const wxDataViewItem
&item
, unsigned int col
) :
2645 wxPopupTransientWindow( parent
, wxBORDER_SIMPLE
)
2650 m_cal
= new wxCalendarCtrl( this, -1, *value
);
2651 wxBoxSizer
*sizer
= new wxBoxSizer( wxHORIZONTAL
);
2652 sizer
->Add( m_cal
, 1, wxGROW
);
2657 virtual void OnDismiss()
2661 void OnCalendar( wxCalendarEvent
&event
);
2663 wxCalendarCtrl
*m_cal
;
2664 wxDataViewModel
*m_model
;
2665 wxDataViewItem m_item
;
2669 DECLARE_EVENT_TABLE()
2672 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient
,wxPopupTransientWindow
)
2673 EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient::OnCalendar
)
2676 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent
&event
)
2678 m_model
->ChangeValue( event
.GetDate(), m_item
, m_col
);
2682 IMPLEMENT_CLASS(wxDataViewDateRenderer
, wxDataViewCustomRenderer
)
2684 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString
&varianttype
,
2685 wxDataViewCellMode mode
, int align
) :
2686 wxDataViewCustomRenderer( varianttype
, mode
, align
)
2689 SetAlignment(align
);
2692 bool wxDataViewDateRenderer::SetValue( const wxVariant
&value
)
2694 m_date
= value
.GetDateTime();
2699 bool wxDataViewDateRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
2704 bool wxDataViewDateRenderer::Render( wxRect cell
, wxDC
*dc
, int state
)
2706 dc
->SetFont( GetOwner()->GetOwner()->GetFont() );
2707 wxString tmp
= m_date
.FormatDate();
2708 RenderText( tmp
, 0, cell
, dc
, state
);
2712 wxSize
wxDataViewDateRenderer::GetSize() const
2714 wxString tmp
= m_date
.FormatDate();
2716 GetView()->GetTextExtent( tmp
, &x
, &y
, &d
);
2717 return wxSize(x
,y
+d
);
2720 bool wxDataViewDateRenderer::Activate( wxRect
WXUNUSED(cell
), wxDataViewModel
*model
,
2721 const wxDataViewItem
&item
, unsigned int col
)
2724 model
->GetValue( variant
, item
, col
);
2725 wxDateTime value
= variant
.GetDateTime();
2727 wxDataViewDateRendererPopupTransient
*popup
= new wxDataViewDateRendererPopupTransient(
2728 GetOwner()->GetOwner()->GetParent(), &value
, model
, item
, col
);
2729 wxPoint pos
= wxGetMousePosition();
2732 popup
->Popup( popup
->m_cal
);
2738 // ---------------------------------------------------------
2739 // wxDataViewIconTextRenderer
2740 // ---------------------------------------------------------
2742 IMPLEMENT_CLASS(wxDataViewIconTextRenderer
, wxDataViewCustomRenderer
)
2744 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer
2746 const wxString
&varianttype
,
2747 wxDataViewCellMode mode
,
2750 : wxDataViewTextRenderer(varianttype
, mode
, align
)
2752 m_rendererIcon
= gtk_cell_renderer_pixbuf_new();
2755 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
2759 void wxDataViewIconTextRenderer::GtkPackIntoColumn(GtkTreeViewColumn
*column
)
2761 // add the icon renderer first
2762 gtk_tree_view_column_pack_start(column
, m_rendererIcon
, FALSE
/* !expand */);
2764 // add the text renderer too
2765 wxDataViewRenderer::GtkPackIntoColumn(column
);
2768 bool wxDataViewIconTextRenderer::SetValue( const wxVariant
&value
)
2772 SetTextValue(m_value
.GetText());
2773 SetPixbufProp(m_rendererIcon
, m_value
.GetIcon().GetPixbuf());
2778 bool wxDataViewIconTextRenderer::GetValue(wxVariant
& value
) const
2781 if ( !GetTextValue(str
) )
2784 // user doesn't have any way to edit the icon so leave it unchanged
2785 value
<< wxDataViewIconText(str
, m_value
.GetIcon());
2791 wxDataViewIconTextRenderer::GtkOnCellChanged(const wxVariant
& value
,
2792 const wxDataViewItem
& item
,
2795 // we receive just the text part of our value as it's the only one which
2796 // can be edited, but we need the full wxDataViewIconText value for the
2798 wxVariant valueIconText
;
2799 valueIconText
<< wxDataViewIconText(value
.GetString(), m_value
.GetIcon());
2800 wxDataViewTextRenderer::GtkOnCellChanged(valueIconText
, item
, col
);
2803 // ---------------------------------------------------------
2805 // ---------------------------------------------------------
2809 gtk_dataview_header_button_press_callback( GtkWidget
*WXUNUSED(widget
),
2810 GdkEventButton
*gdk_event
,
2811 wxDataViewColumn
*column
)
2813 if (gdk_event
->type
!= GDK_BUTTON_PRESS
)
2816 if (gdk_event
->button
== 1)
2818 gs_lastLeftClickHeader
= column
;
2820 wxDataViewCtrl
*dv
= column
->GetOwner();
2821 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK
, dv
->GetId() );
2822 event
.SetDataViewColumn( column
);
2823 event
.SetModel( dv
->GetModel() );
2824 if (dv
->HandleWindowEvent( event
))
2828 if (gdk_event
->button
== 3)
2830 wxDataViewCtrl
*dv
= column
->GetOwner();
2831 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK
, dv
->GetId() );
2832 event
.SetDataViewColumn( column
);
2833 event
.SetModel( dv
->GetModel() );
2834 if (dv
->HandleWindowEvent( event
))
2844 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn
*WXUNUSED(column
),
2845 GtkCellRenderer
*renderer
,
2846 GtkTreeModel
*model
,
2850 g_return_if_fail (GTK_IS_WX_TREE_MODEL (model
));
2851 GtkWxTreeModel
*tree_model
= (GtkWxTreeModel
*) model
;
2853 wxDataViewRenderer
*cell
= (wxDataViewRenderer
*) data
;
2855 wxDataViewItem
item( (void*) iter
->user_data
);
2857 wxDataViewModel
*wx_model
= tree_model
->internal
->GetDataViewModel();
2859 if (!wx_model
->IsVirtualListModel())
2862 if (wx_model
->IsContainer( item
))
2864 visible
= wx_model
->HasContainerColumns( item
) ||
2865 (cell
->GetOwner()->GetModelColumn() == 0);
2872 GValue gvalue
= { 0, };
2873 g_value_init( &gvalue
, G_TYPE_BOOLEAN
);
2874 g_value_set_boolean( &gvalue
, visible
);
2875 g_object_set_property( G_OBJECT(renderer
), "visible", &gvalue
);
2876 g_value_unset( &gvalue
);
2883 wx_model
->GetValue( value
, item
, cell
->GetOwner()->GetModelColumn() );
2885 if (value
.GetType() != cell
->GetVariantType())
2887 wxLogError( wxT("Wrong type, required: %s but: %s"),
2888 value
.GetType().c_str(),
2889 cell
->GetVariantType().c_str() );
2892 cell
->SetValue( value
);
2895 // deal with attributes: if the renderer doesn't support them at all, we
2896 // don't even need to query the model for them
2897 if ( !cell
->GtkSupportsAttrs() )
2900 // it can support attributes so check if this item has any
2901 wxDataViewItemAttr attr
;
2902 if ( wx_model
->GetAttr( item
, cell
->GetOwner()->GetModelColumn(), attr
)
2903 || !cell
->GtkIsUsingDefaultAttrs() )
2905 bool usingDefaultAttrs
= !cell
->GtkSetAttr(attr
);
2906 cell
->GtkSetUsingDefaultAttrs(usingDefaultAttrs
);
2908 // else: no custom attributes specified and we're already using the default
2909 // ones -- nothing to do
2914 #include <wx/listimpl.cpp>
2915 WX_DEFINE_LIST(wxDataViewColumnList
)
2917 wxDataViewColumn::wxDataViewColumn( const wxString
&title
, wxDataViewRenderer
*cell
,
2918 unsigned int model_column
, int width
,
2919 wxAlignment align
, int flags
)
2920 : wxDataViewColumnBase( cell
, model_column
)
2922 Init( align
, flags
, width
);
2927 wxDataViewColumn::wxDataViewColumn( const wxBitmap
&bitmap
, wxDataViewRenderer
*cell
,
2928 unsigned int model_column
, int width
,
2929 wxAlignment align
, int flags
)
2930 : wxDataViewColumnBase( bitmap
, cell
, model_column
)
2932 Init( align
, flags
, width
);
2934 SetBitmap( bitmap
);
2937 void wxDataViewColumn::Init(wxAlignment align
, int flags
, int width
)
2939 m_isConnected
= false;
2941 GtkTreeViewColumn
*column
= gtk_tree_view_column_new();
2942 m_column
= (GtkWidget
*) column
;
2945 SetAlignment( align
);
2949 // Create container for icon and label
2950 GtkWidget
*box
= gtk_hbox_new( FALSE
, 1 );
2951 gtk_widget_show( box
);
2952 // gtk_container_set_border_width((GtkContainer*)box, 2);
2953 m_image
= gtk_image_new();
2954 gtk_box_pack_start(GTK_BOX(box
), m_image
, FALSE
, FALSE
, 1);
2955 m_label
= gtk_label_new("");
2956 gtk_box_pack_end( GTK_BOX(box
), GTK_WIDGET(m_label
), FALSE
, FALSE
, 1 );
2957 gtk_tree_view_column_set_widget( column
, box
);
2959 wxDataViewRenderer
* const colRenderer
= GetRenderer();
2960 GtkCellRenderer
* const cellRenderer
= colRenderer
->GetGtkHandle();
2962 colRenderer
->GtkPackIntoColumn(column
);
2964 gtk_tree_view_column_set_cell_data_func( column
, cellRenderer
,
2965 wxGtkTreeCellDataFunc
, (gpointer
) colRenderer
, NULL
);
2968 void wxDataViewColumn::OnInternalIdle()
2973 if (GTK_WIDGET_REALIZED(GetOwner()->m_treeview
))
2975 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2978 g_signal_connect(column
->button
, "button_press_event",
2979 G_CALLBACK (gtk_dataview_header_button_press_callback
), this);
2981 // otherwise the event will be blocked by GTK+
2982 gtk_tree_view_column_set_clickable( column
, TRUE
);
2984 m_isConnected
= true;
2989 void wxDataViewColumn::SetOwner( wxDataViewCtrl
*owner
)
2991 wxDataViewColumnBase::SetOwner( owner
);
2993 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
2995 gtk_tree_view_column_set_title( column
, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
2998 void wxDataViewColumn::SetTitle( const wxString
&title
)
3000 wxDataViewCtrl
*ctrl
= GetOwner();
3001 gtk_label_set_text( GTK_LABEL(m_label
), ctrl
? wxGTK_CONV_FONT(title
, ctrl
->GetFont())
3002 : wxGTK_CONV_SYS(title
) );
3004 gtk_widget_hide( m_label
);
3006 gtk_widget_show( m_label
);
3009 wxString
wxDataViewColumn::GetTitle() const
3011 return wxGTK_CONV_BACK_FONT(
3012 gtk_label_get_text( GTK_LABEL(m_label
) ),
3013 GetOwner()->GetFont()
3017 void wxDataViewColumn::SetBitmap( const wxBitmap
&bitmap
)
3019 wxDataViewColumnBase::SetBitmap( bitmap
);
3023 GtkImage
*gtk_image
= GTK_IMAGE(m_image
);
3025 GdkBitmap
*mask
= NULL
;
3026 if (bitmap
.GetMask())
3027 mask
= bitmap
.GetMask()->GetBitmap();
3029 if (bitmap
.HasPixbuf())
3031 gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image
),
3032 bitmap
.GetPixbuf());
3036 gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image
),
3037 bitmap
.GetPixmap(), mask
);
3039 gtk_widget_show( m_image
);
3043 gtk_widget_hide( m_image
);
3047 void wxDataViewColumn::SetHidden( bool hidden
)
3049 gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column
), !hidden
);
3052 void wxDataViewColumn::SetResizeable( bool resizeable
)
3054 gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column
), resizeable
);
3057 void wxDataViewColumn::SetAlignment( wxAlignment align
)
3059 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3061 gfloat xalign
= 0.0;
3062 if (align
== wxALIGN_RIGHT
)
3064 if (align
== wxALIGN_CENTER_HORIZONTAL
||
3065 align
== wxALIGN_CENTER
)
3068 gtk_tree_view_column_set_alignment( column
, xalign
);
3070 if (m_renderer
&& m_renderer
->GetAlignment() == -1)
3071 m_renderer
->GtkUpdateAlignment();
3074 wxAlignment
wxDataViewColumn::GetAlignment() const
3076 gfloat xalign
= gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column
) );
3079 return wxALIGN_RIGHT
;
3081 return wxALIGN_CENTER_HORIZONTAL
;
3083 return wxALIGN_LEFT
;
3086 void wxDataViewColumn::SetSortable( bool sortable
)
3088 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3092 gtk_tree_view_column_set_sort_column_id( column
, GetModelColumn() );
3096 gtk_tree_view_column_set_sort_column_id( column
, -1 );
3097 gtk_tree_view_column_set_sort_indicator( column
, FALSE
);
3098 gtk_tree_view_column_set_clickable( column
, FALSE
);
3102 bool wxDataViewColumn::IsSortable() const
3104 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3105 return gtk_tree_view_column_get_clickable( column
);
3108 void wxDataViewColumn::SetAsSortKey( bool WXUNUSED(sort
) )
3110 // it might not make sense to have this function in wxHeaderColumn at
3111 // all in fact, changing of the sort order should only be done using the
3112 // associated control API
3113 wxFAIL_MSG( "not implemented" );
3116 bool wxDataViewColumn::IsSortKey() const
3118 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3119 return gtk_tree_view_column_get_sort_indicator( column
);
3122 bool wxDataViewColumn::IsResizeable() const
3124 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3125 return gtk_tree_view_column_get_resizable( column
);
3128 bool wxDataViewColumn::IsHidden() const
3130 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3131 return !gtk_tree_view_column_get_visible( column
);
3134 void wxDataViewColumn::SetSortOrder( bool ascending
)
3136 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3139 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_ASCENDING
);
3141 gtk_tree_view_column_set_sort_order( column
, GTK_SORT_DESCENDING
);
3143 gtk_tree_view_column_set_sort_indicator( column
, TRUE
);
3146 bool wxDataViewColumn::IsSortOrderAscending() const
3148 GtkTreeViewColumn
*column
= GTK_TREE_VIEW_COLUMN(m_column
);
3150 return (gtk_tree_view_column_get_sort_order( column
) != GTK_SORT_DESCENDING
);
3153 void wxDataViewColumn::SetMinWidth( int width
)
3155 gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
3158 int wxDataViewColumn::GetMinWidth() const
3160 return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column
) );
3163 int wxDataViewColumn::GetWidth() const
3165 return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column
) );
3168 void wxDataViewColumn::SetWidth( int width
)
3173 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
3175 // TODO find a better calculation
3176 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), wxDVC_DEFAULT_WIDTH
);
3178 // this is unpractical for large numbers of items and disables
3179 // user resizing, which is totally unexpected
3180 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_AUTOSIZE
);
3185 gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column
), GTK_TREE_VIEW_COLUMN_FIXED
);
3187 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column
), width
);
3191 void wxDataViewColumn::SetReorderable( bool reorderable
)
3193 gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column
), reorderable
);
3196 bool wxDataViewColumn::IsReorderable() const
3198 return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column
) );
3201 //-----------------------------------------------------------------------------
3202 // wxGtkTreeModelNode
3203 //-----------------------------------------------------------------------------
3206 class wxGtkTreeModelChildWithPos
3214 int wxGtkTreeModelChildWithPosCmp( const void* data1
, const void* data2
, const void* user_data
)
3216 const wxGtkTreeModelChildWithPos
* child1
= (const wxGtkTreeModelChildWithPos
*) data1
;
3217 const wxGtkTreeModelChildWithPos
* child2
= (const wxGtkTreeModelChildWithPos
*) data2
;
3218 const wxDataViewCtrlInternal
*internal
= (const wxDataViewCtrlInternal
*) user_data
;
3219 int ret
= internal
->GetDataViewModel()->Compare( child1
->id
, child2
->id
,
3220 internal
->GetSortColumn(), (internal
->GetSortOrder() == GTK_SORT_DESCENDING
) );
3226 int LINKAGEMODE
wxGtkTreeModelChildPtrCmp( void*** data1
, void*** data2
)
3228 return gs_internal
->GetDataViewModel()->Compare( **data1
, **data2
,
3229 gs_internal
->GetSortColumn(), (gs_internal
->GetSortOrder() == GTK_SORT_ASCENDING
) );
3232 WX_DEFINE_ARRAY_PTR( void**, wxGtkTreeModelChildrenPtr
);
3235 void wxGtkTreeModelNode::Resort()
3237 size_t child_count
= GetChildCount();
3238 if (child_count
== 0)
3241 size_t node_count
= GetNodesCount();
3243 if (child_count
== 1)
3245 if (node_count
== 1)
3247 wxGtkTreeModelNode
*node
= m_nodes
.Item( 0 );
3253 gint
*new_order
= new gint
[child_count
];
3256 // m_children has the original *void
3257 // ptrs points to these
3258 wxGtkTreeModelChildrenPtr ptrs
;
3260 for (i
= 0; i
< child_count
; i
++)
3261 ptrs
.Add( &(m_children
[i
]) );
3263 gs_internal
= m_internal
;
3264 ptrs
.Sort( &wxGtkTreeModelChildPtrCmp
);
3266 wxGtkTreeModelChildren temp
;
3267 void** base_ptr
= &(m_children
[0]);
3268 // Transfer positions to new_order array and
3270 for (i
= 0; i
< child_count
; i
++)
3272 new_order
[i
] = ptrs
[i
] - base_ptr
;
3273 temp
.Add( *ptrs
[i
] );
3276 // Transfer IDs back to m_children
3278 WX_APPEND_ARRAY( temp
, m_children
);
3283 // Build up array with IDs and original positions
3284 wxGtkTreeModelChildWithPos
* temp
= new wxGtkTreeModelChildWithPos
[child_count
];
3286 for (i
= 0; i
< child_count
; i
++)
3289 temp
[i
].id
= m_children
[i
];
3291 // Sort array keeping original positions
3292 wxQsort( temp
, child_count
, sizeof(wxGtkTreeModelChildWithPos
),
3293 &wxGtkTreeModelChildWithPosCmp
, m_internal
);
3294 // Transfer positions to new_order array and
3295 // IDs to m_children
3297 for (i
= 0; i
< child_count
; i
++)
3299 new_order
[i
] = temp
[i
].pos
;
3300 m_children
.Add( temp
[i
].id
);
3309 wxGtkTreeModelChildren temp
;
3310 WX_APPEND_ARRAY( temp
, m_children
);
3312 gs_internal
= m_internal
;
3313 m_children
.Sort( &wxGtkTreeModelChildCmp
);
3316 for (pos
= 0; pos
< child_count
; pos
++)
3318 void *id
= m_children
.Item( pos
);
3319 int old_pos
= temp
.Index( id
);
3320 new_order
[pos
] = old_pos
;
3324 GtkTreeModel
*gtk_tree_model
= GTK_TREE_MODEL( m_internal
->GetGtkModel() );
3327 iter
.user_data
= GetItem().GetID();
3328 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
3330 gtk_tree_model_rows_reordered( gtk_tree_model
,
3331 wxGtkTreePath(m_internal
->get_path(&iter
)), &iter
, new_order
);
3333 delete [] new_order
;
3336 for (pos
= 0; pos
< node_count
; pos
++)
3338 wxGtkTreeModelNode
*node
= m_nodes
.Item( pos
);
3343 //-----------------------------------------------------------------------------
3344 // wxDataViewCtrlInternal
3345 //-----------------------------------------------------------------------------
3347 wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl
*owner
,
3348 wxDataViewModel
*wx_model
, GtkWxTreeModel
*gtk_model
)
3351 m_wx_model
= wx_model
;
3352 m_gtk_model
= gtk_model
;
3354 m_sort_order
= GTK_SORT_ASCENDING
;
3356 m_dataview_sort_column
= NULL
;
3358 m_dragDataObject
= NULL
;
3359 m_dropDataObject
= NULL
;
3361 if (!m_wx_model
->IsVirtualListModel())
3365 wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
3367 g_object_unref( m_gtk_model
);
3369 delete m_dragDataObject
;
3370 delete m_dropDataObject
;
3373 void wxDataViewCtrlInternal::InitTree()
3375 wxDataViewItem item
;
3376 m_root
= new wxGtkTreeModelNode( NULL
, item
, this );
3378 BuildBranch( m_root
);
3381 void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode
*node
)
3383 if (node
->GetChildCount() == 0)
3385 wxDataViewItemArray children
;
3386 unsigned int count
= m_wx_model
->GetChildren( node
->GetItem(), children
);
3389 for (pos
= 0; pos
< count
; pos
++)
3391 wxDataViewItem child
= children
[pos
];
3393 if (m_wx_model
->IsContainer( child
))
3394 node
->AddNode( new wxGtkTreeModelNode( node
, child
, this ) );
3396 node
->AddLeave( child
.GetID() );
3398 // Don't send any events here
3405 bool wxDataViewCtrlInternal::EnableDragSource( const wxDataFormat
&format
)
3407 wxGtkString
atom_str( gdk_atom_name( format
) );
3408 m_dragSourceTargetEntryTarget
= wxCharBuffer( atom_str
);
3410 m_dragSourceTargetEntry
.target
= m_dragSourceTargetEntryTarget
.data();
3411 m_dragSourceTargetEntry
.flags
= 0;
3412 m_dragSourceTargetEntry
.info
= static_cast<guint
>(-1);
3414 gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
3415 GDK_BUTTON1_MASK
, &m_dragSourceTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
3420 bool wxDataViewCtrlInternal::EnableDropTarget( const wxDataFormat
&format
)
3422 wxGtkString
atom_str( gdk_atom_name( format
) );
3423 m_dropTargetTargetEntryTarget
= wxCharBuffer( atom_str
);
3425 m_dropTargetTargetEntry
.target
= m_dropTargetTargetEntryTarget
.data();
3426 m_dropTargetTargetEntry
.flags
= 0;
3427 m_dropTargetTargetEntry
.info
= static_cast<guint
>(-1);
3429 gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner
->GtkGetTreeView() ),
3430 &m_dropTargetTargetEntry
, 1, (GdkDragAction
) GDK_ACTION_COPY
);
3435 gboolean
wxDataViewCtrlInternal::row_draggable( GtkTreeDragSource
*WXUNUSED(drag_source
),
3438 delete m_dragDataObject
;
3440 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3444 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG
, m_owner
->GetId() );
3445 event
.SetEventObject( m_owner
);
3446 event
.SetItem( item
);
3447 event
.SetModel( m_wx_model
);
3448 if (!m_owner
->HandleWindowEvent( event
))
3451 if (!event
.IsAllowed())
3454 wxDataObject
*obj
= event
.GetDataObject();
3458 m_dragDataObject
= obj
;
3464 wxDataViewCtrlInternal::drag_data_delete(GtkTreeDragSource
*WXUNUSED(drag_source
),
3465 GtkTreePath
*WXUNUSED(path
))
3470 gboolean
wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource
*WXUNUSED(drag_source
),
3471 GtkTreePath
*path
, GtkSelectionData
*selection_data
)
3473 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3477 if (!m_dragDataObject
->IsSupported( selection_data
->target
))
3480 size_t size
= m_dragDataObject
->GetDataSize( selection_data
->target
);
3484 void *buf
= malloc( size
);
3486 gboolean res
= FALSE
;
3487 if (m_dragDataObject
->GetDataHere( selection_data
->target
, buf
))
3491 gtk_selection_data_set( selection_data
, selection_data
->target
,
3492 8, (const guchar
*) buf
, size
);
3501 wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3503 GtkSelectionData
*selection_data
)
3505 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3509 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP
, m_owner
->GetId() );
3510 event
.SetEventObject( m_owner
);
3511 event
.SetItem( item
);
3512 event
.SetModel( m_wx_model
);
3513 event
.SetDataFormat( selection_data
->target
);
3514 event
.SetDataSize( selection_data
->length
);
3515 event
.SetDataBuffer( selection_data
->data
);
3516 if (!m_owner
->HandleWindowEvent( event
))
3519 if (!event
.IsAllowed())
3526 wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest
*WXUNUSED(drag_dest
),
3528 GtkSelectionData
*selection_data
)
3530 wxDataViewItem
item(GetOwner()->GTKPathToItem(path
));
3534 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE
, m_owner
->GetId() );
3535 event
.SetEventObject( m_owner
);
3536 event
.SetItem( item
);
3537 event
.SetModel( m_wx_model
);
3538 event
.SetDataFormat( selection_data
->target
);
3539 if (!m_owner
->HandleWindowEvent( event
))
3542 if (!event
.IsAllowed())
3548 // notifications from wxDataViewModel
3550 bool wxDataViewCtrlInternal::Cleared()
3563 void wxDataViewCtrlInternal::Resort()
3565 if (!m_wx_model
->IsVirtualListModel())
3569 bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3571 if (!m_wx_model
->IsVirtualListModel())
3573 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3574 wxASSERT_MSG(parent_node
,
3575 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3577 if (m_wx_model
->IsContainer( item
))
3578 parent_node
->AddNode( new wxGtkTreeModelNode( parent_node
, item
, this ) );
3580 parent_node
->AddLeave( item
.GetID() );
3586 bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3588 if (!m_wx_model
->IsVirtualListModel())
3590 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3591 wxASSERT_MSG(parent_node
,
3592 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3594 parent_node
->DeleteChild( item
.GetID() );
3600 bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem
&item
)
3602 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3603 event
.SetEventObject( m_owner
);
3604 event
.SetModel( m_owner
->GetModel() );
3605 event
.SetItem( item
);
3606 m_owner
->HandleWindowEvent( event
);
3611 bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem
&item
, unsigned int col
)
3613 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, m_owner
->GetId() );
3614 event
.SetEventObject( m_owner
);
3615 event
.SetModel( m_owner
->GetModel() );
3616 event
.SetColumn( col
);
3617 event
.SetDataViewColumn( GetOwner()->GetColumn(col
) );
3618 event
.SetItem( item
);
3619 m_owner
->HandleWindowEvent( event
);
3626 GtkTreeModelFlags
wxDataViewCtrlInternal::get_flags()
3630 if ( m_wx_model
->IsListModel() )
3631 flags
|= GTK_TREE_MODEL_LIST_ONLY
;
3633 if ( !m_wx_model
->IsVirtualListModel() )
3634 flags
|= GTK_TREE_MODEL_ITERS_PERSIST
;
3636 return GtkTreeModelFlags(flags
);
3639 gboolean
wxDataViewCtrlInternal::get_iter( GtkTreeIter
*iter
, GtkTreePath
*path
)
3642 if (m_wx_model
->IsVirtualListModel())
3644 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3646 unsigned int i
= (unsigned int)gtk_tree_path_get_indices (path
)[0];
3648 if (i
>= wx_model
->GetCount())
3651 iter
->stamp
= m_gtk_model
->stamp
;
3652 // user_data is just the index +1
3653 iter
->user_data
= (gpointer
) (i
+1);
3659 int depth
= gtk_tree_path_get_depth( path
);
3661 wxGtkTreeModelNode
*node
= m_root
;
3664 for (i
= 0; i
< depth
; i
++)
3666 BuildBranch( node
);
3668 gint pos
= gtk_tree_path_get_indices (path
)[i
];
3669 if (pos
< 0) return FALSE
;
3670 if ((size_t)pos
>= node
->GetChildCount()) return FALSE
;
3672 void* id
= node
->GetChildren().Item( (size_t) pos
);
3676 iter
->stamp
= m_gtk_model
->stamp
;
3677 iter
->user_data
= id
;
3681 size_t count
= node
->GetNodes().GetCount();
3683 for (pos2
= 0; pos2
< count
; pos2
++)
3685 wxGtkTreeModelNode
*child_node
= node
->GetNodes().Item( pos2
);
3686 if (child_node
->GetItem().GetID() == id
)
3698 GtkTreePath
*wxDataViewCtrlInternal::get_path( GtkTreeIter
*iter
)
3700 // When this is called from ItemDeleted(), the item is already
3701 // deleted in the model.
3703 GtkTreePath
*retval
= gtk_tree_path_new ();
3705 if (m_wx_model
->IsVirtualListModel())
3707 // iter is root, add nothing
3708 if (!iter
->user_data
)
3711 // user_data is just the index +1
3712 int i
= ( (wxUIntPtr
) iter
->user_data
) -1;
3713 gtk_tree_path_append_index (retval
, i
);
3717 void *id
= iter
->user_data
;
3719 wxGtkTreeModelNode
*node
= FindParentNode( iter
);
3722 int pos
= node
->GetChildren().Index( id
);
3724 gtk_tree_path_prepend_index( retval
, pos
);
3726 id
= node
->GetItem().GetID();
3727 node
= node
->GetParent();
3734 gboolean
wxDataViewCtrlInternal::iter_next( GtkTreeIter
*iter
)
3736 if (m_wx_model
->IsVirtualListModel())
3738 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3740 // user_data is just the index +1
3741 int n
= ( (wxUIntPtr
) iter
->user_data
) -1;
3745 iter
->user_data
= NULL
;
3749 if (n
>= (int) wx_model
->GetCount()-1)
3751 iter
->user_data
= NULL
;
3755 // user_data is just the index +1 (+2 because we need the next)
3756 iter
->user_data
= (gpointer
) (n
+2);
3760 wxGtkTreeModelNode
*parent
= FindParentNode( iter
);
3761 if( parent
== NULL
)
3763 iter
->user_data
= NULL
;
3767 int pos
= parent
->GetChildren().Index( iter
->user_data
);
3769 if (pos
== (int) parent
->GetChildCount()-1)
3771 iter
->user_data
= NULL
;
3775 iter
->user_data
= parent
->GetChildren().Item( pos
+1 );
3781 gboolean
wxDataViewCtrlInternal::iter_children( GtkTreeIter
*iter
, GtkTreeIter
*parent
)
3783 if (m_wx_model
->IsVirtualListModel())
3785 // this is a list, nodes have no children
3789 iter
->stamp
= m_gtk_model
->stamp
;
3790 iter
->user_data
= (gpointer
) 1;
3798 if (m_root
->GetChildCount() == 0) return FALSE
;
3799 iter
->stamp
= m_gtk_model
->stamp
;
3800 iter
->user_data
= (gpointer
) m_root
->GetChildren().Item( 0 );
3805 wxDataViewItem item
;
3807 item
= wxDataViewItem( (void*) parent
->user_data
);
3809 if (!m_wx_model
->IsContainer( item
))
3812 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3813 wxASSERT_MSG(parent_node
,
3814 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3816 BuildBranch( parent_node
);
3818 if (parent_node
->GetChildCount() == 0)
3821 iter
->stamp
= m_gtk_model
->stamp
;
3822 iter
->user_data
= (gpointer
) parent_node
->GetChildren().Item( 0 );
3828 gboolean
wxDataViewCtrlInternal::iter_has_child( GtkTreeIter
*iter
)
3830 if (m_wx_model
->IsVirtualListModel())
3832 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3835 return (wx_model
->GetCount() > 0);
3837 // this is a list, nodes have no children
3843 return (m_root
->GetChildCount() > 0);
3845 wxDataViewItem
item( (void*) iter
->user_data
);
3847 bool is_container
= m_wx_model
->IsContainer( item
);
3852 wxGtkTreeModelNode
*node
= FindNode( iter
);
3854 "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
3856 BuildBranch( node
);
3858 return (node
->GetChildCount() > 0);
3862 gint
wxDataViewCtrlInternal::iter_n_children( GtkTreeIter
*iter
)
3864 if (m_wx_model
->IsVirtualListModel())
3866 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3869 return (gint
) wx_model
->GetCount();
3876 return m_root
->GetChildCount();
3878 wxDataViewItem
item( (void*) iter
->user_data
);
3880 if (!m_wx_model
->IsContainer( item
))
3883 wxGtkTreeModelNode
*parent_node
= FindNode( iter
);
3884 wxASSERT_MSG(parent_node
,
3885 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3887 BuildBranch( parent_node
);
3889 return parent_node
->GetChildCount();
3893 gboolean
wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter
*iter
, GtkTreeIter
*parent
, gint n
)
3895 if (m_wx_model
->IsVirtualListModel())
3897 wxDataViewVirtualListModel
*wx_model
= (wxDataViewVirtualListModel
*) m_wx_model
;
3905 if (n
>= (gint
) wx_model
->GetCount())
3908 iter
->stamp
= m_gtk_model
->stamp
;
3909 // user_data is just the index +1
3910 iter
->user_data
= (gpointer
) (n
+1);
3917 if (parent
) id
= (void*) parent
->user_data
;
3918 wxDataViewItem
item( id
);
3920 if (!m_wx_model
->IsContainer( item
))
3923 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3924 wxASSERT_MSG(parent_node
,
3925 "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3927 BuildBranch( parent_node
);
3929 iter
->stamp
= m_gtk_model
->stamp
;
3930 iter
->user_data
= parent_node
->GetChildren().Item( n
);
3936 gboolean
wxDataViewCtrlInternal::iter_parent( GtkTreeIter
*iter
, GtkTreeIter
*child
)
3938 if (m_wx_model
->IsVirtualListModel())
3944 wxGtkTreeModelNode
*node
= FindParentNode( child
);
3948 iter
->stamp
= m_gtk_model
->stamp
;
3949 iter
->user_data
= (gpointer
) node
->GetItem().GetID();
3955 // item can be deleted already in the model
3956 int wxDataViewCtrlInternal::GetIndexOf( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
3958 if (m_wx_model
->IsVirtualListModel())
3960 return wxPtrToUInt(item
.GetID()) - 1;
3964 wxGtkTreeModelNode
*parent_node
= FindNode( parent
);
3965 wxGtkTreeModelChildren
&children
= parent_node
->GetChildren();
3967 for (j
= 0; j
< children
.GetCount(); j
++)
3969 if (children
[j
] == item
.GetID())
3977 static wxGtkTreeModelNode
*
3978 wxDataViewCtrlInternal_FindNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
3984 list
.DeleteContents( true );
3985 wxDataViewItem
it( item
);
3989 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
3990 list
.Insert( pItem
);
3991 it
= model
->GetParent( it
);
3994 wxGtkTreeModelNode
* node
= treeNode
;
3995 for( ItemList::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
3997 if( node
&& node
->GetNodes().GetCount() != 0 )
3999 int len
= node
->GetNodes().GetCount();
4000 wxGtkTreeModelNodes
&nodes
= node
->GetNodes();
4002 for( ; j
< len
; j
++)
4004 if( nodes
[j
]->GetItem() == *(n
->GetData()))
4023 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindNode( GtkTreeIter
*iter
)
4028 wxDataViewItem
item( (void*) iter
->user_data
);
4032 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
4037 wxLogDebug( "Not found %p", iter->user_data );
4041 // TODO: remove this code
4047 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindNode( const wxDataViewItem
&item
)
4052 wxGtkTreeModelNode
*result
= wxDataViewCtrlInternal_FindNode( m_wx_model
, m_root
, item
);
4057 wxLogDebug( "Not found %p", item.GetID() );
4061 // TODO: remove this code
4067 static wxGtkTreeModelNode
*
4068 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel
* model
, wxGtkTreeModelNode
*treeNode
, const wxDataViewItem
&item
)
4074 list
.DeleteContents( true );
4078 wxDataViewItem
it( model
->GetParent( item
) );
4081 wxDataViewItem
* pItem
= new wxDataViewItem( it
);
4082 list
.Insert( pItem
);
4083 it
= model
->GetParent( it
);
4086 wxGtkTreeModelNode
* node
= treeNode
;
4087 for( ItemList::compatibility_iterator n
= list
.GetFirst(); n
; n
= n
->GetNext() )
4089 if( node
&& node
->GetNodes().GetCount() != 0 )
4091 int len
= node
->GetNodes().GetCount();
4092 wxGtkTreeModelNodes nodes
= node
->GetNodes();
4094 for( ; j
< len
; j
++)
4096 if( nodes
[j
]->GetItem() == *(n
->GetData()))
4111 //Examine whether the node is item's parent node
4112 int len
= node
->GetChildCount();
4113 for( int i
= 0; i
< len
; i
++ )
4115 if( node
->GetChildren().Item( i
) == item
.GetID() )
4121 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindParentNode( GtkTreeIter
*iter
)
4126 wxDataViewItem
item( (void*) iter
->user_data
);
4130 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
4133 wxGtkTreeModelNode
*wxDataViewCtrlInternal::FindParentNode( const wxDataViewItem
&item
)
4138 return wxDataViewCtrlInternal_FindParentNode( m_wx_model
, m_root
, item
);
4141 //-----------------------------------------------------------------------------
4142 // wxDataViewCtrl signal callbacks
4143 //-----------------------------------------------------------------------------
4146 wxdataview_selection_changed_callback( GtkTreeSelection
* WXUNUSED(selection
), wxDataViewCtrl
*dv
)
4148 if (!GTK_WIDGET_REALIZED(dv
->m_widget
))
4151 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED
, dv
->GetId() );
4152 event
.SetItem( dv
->GetSelection() );
4153 event
.SetModel( dv
->GetModel() );
4154 dv
->HandleWindowEvent( event
);
4158 wxdataview_row_activated_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreePath
*path
,
4159 GtkTreeViewColumn
*WXUNUSED(column
), wxDataViewCtrl
*dv
)
4161 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED
, dv
->GetId() );
4163 wxDataViewItem
item(dv
->GTKPathToItem(path
));
4164 event
.SetItem( item
);
4165 event
.SetModel( dv
->GetModel() );
4166 dv
->HandleWindowEvent( event
);
4170 wxdataview_test_expand_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4171 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4173 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING
, dv
->GetId() );
4175 wxDataViewItem
item( (void*) iter
->user_data
);;
4176 event
.SetItem( item
);
4177 event
.SetModel( dv
->GetModel() );
4178 dv
->HandleWindowEvent( event
);
4180 return !event
.IsAllowed();
4184 wxdataview_row_expanded_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4185 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4187 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED
, dv
->GetId() );
4189 wxDataViewItem
item( (void*) iter
->user_data
);;
4190 event
.SetItem( item
);
4191 event
.SetModel( dv
->GetModel() );
4192 dv
->HandleWindowEvent( event
);
4196 wxdataview_test_collapse_row_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4197 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4199 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING
, dv
->GetId() );
4201 wxDataViewItem
item( (void*) iter
->user_data
);;
4202 event
.SetItem( item
);
4203 event
.SetModel( dv
->GetModel() );
4204 dv
->HandleWindowEvent( event
);
4206 return !event
.IsAllowed();
4210 wxdataview_row_collapsed_callback( GtkTreeView
* WXUNUSED(treeview
), GtkTreeIter
* iter
,
4211 GtkTreePath
*WXUNUSED(path
), wxDataViewCtrl
*dv
)
4213 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED
, dv
->GetId() );
4215 wxDataViewItem
item( (void*) iter
->user_data
);;
4216 event
.SetItem( item
);
4217 event
.SetModel( dv
->GetModel() );
4218 dv
->HandleWindowEvent( event
);
4221 //-----------------------------------------------------------------------------
4223 //-----------------------------------------------------------------------------
4225 void wxDataViewCtrl::AddChildGTK(wxWindowGTK
* child
)
4227 GtkWidget
* treeview
= GtkGetTreeView();
4229 // Insert widget in GtkTreeView
4230 if (GTK_WIDGET_REALIZED(treeview
))
4231 gtk_widget_set_parent_window( child
->m_widget
,
4232 gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview
) ) );
4233 gtk_widget_set_parent( child
->m_widget
, treeview
);
4237 void gtk_dataviewctrl_size_callback( GtkWidget
*WXUNUSED(widget
),
4238 GtkAllocation
*WXUNUSED(gtk_alloc
),
4239 wxDataViewCtrl
*win
)
4241 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
4244 wxWindow
*child
= node
->GetData();
4247 gtk_widget_size_request( child
->m_widget
, &req
);
4249 GtkAllocation alloc
;
4250 alloc
.x
= child
->m_x
;
4251 alloc
.y
= child
->m_y
;
4252 alloc
.width
= child
->m_width
;
4253 alloc
.height
= child
->m_height
;
4254 gtk_widget_size_allocate( child
->m_widget
, &alloc
);
4256 node
= node
->GetNext();
4261 //-----------------------------------------------------------------------------
4262 // "motion_notify_event"
4263 //-----------------------------------------------------------------------------
4266 gtk_dataview_motion_notify_callback( GtkWidget
*WXUNUSED(widget
),
4267 GdkEventMotion
*gdk_event
,
4268 wxDataViewCtrl
*dv
)
4270 if (gdk_event
->is_hint
)
4274 GdkModifierType state
;
4275 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
4281 GtkTreeViewColumn
*column
= NULL
;
4284 if (gtk_tree_view_get_path_at_pos(
4285 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
4286 (int) gdk_event
->x
, (int) gdk_event
->y
,
4295 dv
->GtkGetInternal()->get_iter( &iter
, path
);
4303 //-----------------------------------------------------------------------------
4304 // "button_press_event"
4305 //-----------------------------------------------------------------------------
4308 gtk_dataview_button_press_callback( GtkWidget
*WXUNUSED(widget
),
4309 GdkEventButton
*gdk_event
,
4310 wxDataViewCtrl
*dv
)
4312 if ((gdk_event
->button
== 3) && (gdk_event
->type
== GDK_BUTTON_PRESS
))
4315 GtkTreeViewColumn
*column
= NULL
;
4318 if (gtk_tree_view_get_path_at_pos(
4319 GTK_TREE_VIEW(dv
->GtkGetTreeView()),
4320 (int) gdk_event
->x
, (int) gdk_event
->y
,
4328 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU
, dv
->GetId() );
4329 event
.SetItem(dv
->GTKPathToItem(path
));
4330 event
.SetModel( dv
->GetModel() );
4331 return dv
->HandleWindowEvent( event
);
4339 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl
, wxDataViewCtrlBase
)
4341 wxDataViewCtrl::~wxDataViewCtrl()
4344 GetModel()->RemoveNotifier( m_notifier
);
4348 // remove the model from the GtkTreeView before it gets destroyed by the
4349 // wxDataViewCtrlBase's dtor
4350 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview
), NULL
);
4355 void wxDataViewCtrl::Init()
4360 m_cols
.DeleteContents( true );
4363 bool wxDataViewCtrl::Create(wxWindow
*parent
,
4368 const wxValidator
& validator
,
4369 const wxString
& name
)
4371 if (!PreCreation( parent
, pos
, size
) ||
4372 !CreateBase( parent
, id
, pos
, size
, style
, validator
, name
))
4374 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
4378 m_widget
= gtk_scrolled_window_new (NULL
, NULL
);
4379 g_object_ref(m_widget
);
4381 GTKScrolledWindowSetBorder(m_widget
, style
);
4383 m_treeview
= gtk_tree_view_new();
4384 gtk_container_add (GTK_CONTAINER (m_widget
), m_treeview
);
4386 g_signal_connect (m_treeview
, "size_allocate",
4387 G_CALLBACK (gtk_dataviewctrl_size_callback
), this);
4390 if (!gtk_check_version(2,6,0))
4392 bool fixed
= (style
& wxDV_VARIABLE_LINE_HEIGHT
) == 0;
4393 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
4397 if (style
& wxDV_MULTIPLE
)
4399 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4400 gtk_tree_selection_set_mode( selection
, GTK_SELECTION_MULTIPLE
);
4403 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_NO_HEADER
) == 0 );
4406 if (!gtk_check_version(2,10,0))
4408 GtkTreeViewGridLines grid
= GTK_TREE_VIEW_GRID_LINES_NONE
;
4410 if ((style
& wxDV_HORIZ_RULES
) != 0 &&
4411 (style
& wxDV_VERT_RULES
) != 0)
4412 grid
= GTK_TREE_VIEW_GRID_LINES_BOTH
;
4413 else if (style
& wxDV_VERT_RULES
)
4414 grid
= GTK_TREE_VIEW_GRID_LINES_VERTICAL
;
4415 else if (style
& wxDV_HORIZ_RULES
)
4416 grid
= GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
;
4418 if (grid
!= GTK_TREE_VIEW_GRID_LINES_NONE
)
4419 gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview
), grid
);
4423 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview
), (style
& wxDV_ROW_LINES
) != 0 );
4425 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget
),
4426 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
4427 gtk_widget_show (m_treeview
);
4429 m_parent
->DoAddChild( this );
4433 GtkEnableSelectionEvents();
4435 g_signal_connect_after (m_treeview
, "row-activated",
4436 G_CALLBACK (wxdataview_row_activated_callback
), this);
4438 g_signal_connect (m_treeview
, "test-collapse-row",
4439 G_CALLBACK (wxdataview_test_collapse_row_callback
), this);
4441 g_signal_connect_after (m_treeview
, "row-collapsed",
4442 G_CALLBACK (wxdataview_row_collapsed_callback
), this);
4444 g_signal_connect (m_treeview
, "test-expand-row",
4445 G_CALLBACK (wxdataview_test_expand_row_callback
), this);
4447 g_signal_connect_after (m_treeview
, "row-expanded",
4448 G_CALLBACK (wxdataview_row_expanded_callback
), this);
4450 g_signal_connect (m_treeview
, "motion_notify_event",
4451 G_CALLBACK (gtk_dataview_motion_notify_callback
), this);
4453 g_signal_connect (m_treeview
, "button_press_event",
4454 G_CALLBACK (gtk_dataview_button_press_callback
), this);
4459 wxDataViewItem
wxDataViewCtrl::GTKPathToItem(GtkTreePath
*path
) const
4462 return wxDataViewItem(path
&& m_internal
->get_iter(&iter
, path
)
4467 void wxDataViewCtrl::OnInternalIdle()
4469 wxWindow::OnInternalIdle();
4471 unsigned int cols
= GetColumnCount();
4473 for (i
= 0; i
< cols
; i
++)
4475 wxDataViewColumn
*col
= GetColumn( i
);
4476 col
->OnInternalIdle();
4480 bool wxDataViewCtrl::AssociateModel( wxDataViewModel
*model
)
4482 wxDELETE(m_internal
);
4484 if (!wxDataViewCtrlBase::AssociateModel( model
))
4488 if (!gtk_check_version(2,6,0))
4490 bool fixed
= (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT
) == 0) || (model
->IsVirtualListModel()));
4491 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), fixed
);
4495 GtkWxTreeModel
*gtk_model
= wxgtk_tree_model_new();
4496 m_internal
= new wxDataViewCtrlInternal( this, model
, gtk_model
);
4497 gtk_model
->internal
= m_internal
;
4499 m_notifier
= new wxGtkDataViewModelNotifier( gtk_model
, model
, this );
4501 model
->AddNotifier( m_notifier
);
4503 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview
), GTK_TREE_MODEL(gtk_model
) );
4505 // unref in wxDataViewCtrlInternal
4506 // g_object_unref( gtk_model );
4511 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat
&format
)
4513 return m_internal
->EnableDragSource( format
);
4516 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat
&format
)
4518 return m_internal
->EnableDropTarget( format
);
4521 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn
*col
)
4523 if (!wxDataViewCtrlBase::AppendColumn(col
))
4526 m_cols
.Append( col
);
4529 if (!gtk_check_version(2,6,0))
4531 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4532 GTK_TREE_VIEW_COLUMN_FIXED
)
4533 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4537 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview
),
4538 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4543 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn
*col
)
4545 if (!wxDataViewCtrlBase::PrependColumn(col
))
4548 m_cols
.Insert( col
);
4551 if (!gtk_check_version(2,6,0))
4553 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4554 GTK_TREE_VIEW_COLUMN_FIXED
)
4555 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4559 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4560 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), 0 );
4565 bool wxDataViewCtrl::InsertColumn( unsigned int pos
, wxDataViewColumn
*col
)
4567 if (!wxDataViewCtrlBase::InsertColumn(pos
,col
))
4570 m_cols
.Insert( pos
, col
);
4573 if (!gtk_check_version(2,6,0))
4575 if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) ) !=
4576 GTK_TREE_VIEW_COLUMN_FIXED
)
4577 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview
), FALSE
);
4581 gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview
),
4582 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()), pos
);
4587 unsigned int wxDataViewCtrl::GetColumnCount() const
4589 return m_cols
.GetCount();
4592 wxDataViewColumn
* wxDataViewCtrl::GetColumn( unsigned int pos
) const
4594 GtkTreeViewColumn
*gtk_col
= gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview
), pos
);
4598 wxDataViewColumnList::const_iterator iter
;
4599 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4601 wxDataViewColumn
*col
= *iter
;
4602 if (GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) == gtk_col
)
4611 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn
*column
)
4613 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4614 GTK_TREE_VIEW_COLUMN(column
->GetGtkHandle()) );
4616 m_cols
.DeleteObject( column
);
4621 bool wxDataViewCtrl::ClearColumns()
4623 wxDataViewColumnList::iterator iter
;
4624 for (iter
= m_cols
.begin(); iter
!= m_cols
.end(); ++iter
)
4626 wxDataViewColumn
*col
= *iter
;
4627 gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview
),
4628 GTK_TREE_VIEW_COLUMN(col
->GetGtkHandle()) );
4636 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn
*column
) const
4638 GtkTreeViewColumn
*gtk_column
= GTK_TREE_VIEW_COLUMN(column
->GetConstGtkHandle());
4640 GList
*list
= gtk_tree_view_get_columns( GTK_TREE_VIEW(m_treeview
) );
4642 gint pos
= g_list_index( list
, (gconstpointer
) gtk_column
);
4644 g_list_free( list
);
4649 wxDataViewColumn
*wxDataViewCtrl::GetSortingColumn() const
4651 return m_internal
->GetDataViewSortColumn();
4654 void wxDataViewCtrl::Expand( const wxDataViewItem
& item
)
4657 iter
.user_data
= item
.GetID();
4658 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4659 gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview
), path
, false );
4662 void wxDataViewCtrl::Collapse( const wxDataViewItem
& item
)
4665 iter
.user_data
= item
.GetID();
4666 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4667 gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview
), path
);
4670 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem
& item
) const
4673 iter
.user_data
= item
.GetID();
4674 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4675 return gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview
), path
);
4678 wxDataViewItem
wxDataViewCtrl::DoGetCurrentItem() const
4680 // The tree doesn't have any current item if it hadn't been created yet but
4681 // it's arguably not an error to call this function in this case so just
4682 // return an invalid item without asserting.
4684 return wxDataViewItem();
4687 gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview
), path
.ByRef(), NULL
);
4689 return GTKPathToItem(path
);
4692 void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem
& item
)
4694 wxCHECK_RET( m_treeview
,
4695 "Current item can't be set before creating the control." );
4697 // We need to make sure the model knows about this item or the path would
4698 // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4699 ExpandAncestors(item
);
4701 // We also need to preserve the existing selection from changing.
4702 // Unfortunately the only way to do it seems to use our own selection
4703 // function and forbid any selection changes during set cursor call.
4704 wxGtkTreeSelectionLock
4705 lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview
)));
4707 // Do move the cursor now.
4709 iter
.user_data
= item
.GetID();
4710 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4712 gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview
), path
, NULL
, FALSE
);
4715 wxDataViewItem
wxDataViewCtrl::GetSelection() const
4717 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4719 if (m_windowStyle
& wxDV_MULTIPLE
)
4721 // Report the first one
4722 GtkTreeModel
*model
;
4723 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4727 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4728 wxDataViewItem
item(GTKPathToItem(path
));
4731 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4732 g_list_free( list
);
4740 if (gtk_tree_selection_get_selected( selection
, NULL
, &iter
))
4742 wxDataViewItem
item( iter
.user_data
);
4747 return wxDataViewItem(0);
4750 int wxDataViewCtrl::GetSelections( wxDataViewItemArray
& sel
) const
4754 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4755 if (HasFlag(wxDV_MULTIPLE
))
4757 GtkTreeModel
*model
;
4758 GList
*list
= gtk_tree_selection_get_selected_rows( selection
, &model
);
4763 GtkTreePath
*path
= (GtkTreePath
*) list
->data
;
4765 sel
.Add(GTKPathToItem(path
));
4767 list
= g_list_next( list
);
4772 g_list_foreach( list
, (GFunc
) gtk_tree_path_free
, NULL
);
4773 g_list_free( list
);
4779 GtkTreeModel
*model
;
4781 gboolean has_selection
= gtk_tree_selection_get_selected( selection
, &model
, &iter
);
4784 sel
.Add( wxDataViewItem( (void*) iter
.user_data
) );
4792 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray
& sel
)
4794 GtkDisableSelectionEvents();
4796 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4798 gtk_tree_selection_unselect_all( selection
);
4800 wxDataViewItem last_parent
;
4803 for (i
= 0; i
< sel
.GetCount(); i
++)
4805 wxDataViewItem item
= sel
[i
];
4806 wxDataViewItem parent
= GetModel()->GetParent( item
);
4809 if (parent
!= last_parent
)
4810 ExpandAncestors(item
);
4812 last_parent
= parent
;
4815 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4816 iter
.user_data
= (gpointer
) item
.GetID();
4817 gtk_tree_selection_select_iter( selection
, &iter
);
4820 GtkEnableSelectionEvents();
4823 void wxDataViewCtrl::Select( const wxDataViewItem
& item
)
4825 ExpandAncestors(item
);
4827 GtkDisableSelectionEvents();
4829 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4832 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4833 iter
.user_data
= (gpointer
) item
.GetID();
4834 gtk_tree_selection_select_iter( selection
, &iter
);
4836 GtkEnableSelectionEvents();
4839 void wxDataViewCtrl::Unselect( const wxDataViewItem
& item
)
4841 GtkDisableSelectionEvents();
4843 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4846 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4847 iter
.user_data
= (gpointer
) item
.GetID();
4848 gtk_tree_selection_unselect_iter( selection
, &iter
);
4850 GtkEnableSelectionEvents();
4853 bool wxDataViewCtrl::IsSelected( const wxDataViewItem
& item
) const
4855 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4858 iter
.stamp
= m_internal
->GetGtkModel()->stamp
;
4859 iter
.user_data
= (gpointer
) item
.GetID();
4861 return gtk_tree_selection_iter_is_selected( selection
, &iter
);
4864 void wxDataViewCtrl::SelectAll()
4866 GtkDisableSelectionEvents();
4868 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4870 gtk_tree_selection_select_all( selection
);
4872 GtkEnableSelectionEvents();
4875 void wxDataViewCtrl::UnselectAll()
4877 GtkDisableSelectionEvents();
4879 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4881 gtk_tree_selection_unselect_all( selection
);
4883 GtkEnableSelectionEvents();
4886 void wxDataViewCtrl::EnsureVisible(const wxDataViewItem
& item
,
4887 const wxDataViewColumn
*WXUNUSED(column
))
4889 ExpandAncestors(item
);
4892 iter
.user_data
= (gpointer
) item
.GetID();
4893 wxGtkTreePath
path(m_internal
->get_path( &iter
));
4894 gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview
), path
, NULL
, false, 0.0, 0.0 );
4897 void wxDataViewCtrl::HitTest(const wxPoint
& WXUNUSED(point
),
4898 wxDataViewItem
& item
,
4899 wxDataViewColumn
*& column
) const
4901 item
= wxDataViewItem(0);
4906 wxDataViewCtrl::GetItemRect(const wxDataViewItem
& WXUNUSED(item
),
4907 const wxDataViewColumn
*WXUNUSED(column
)) const
4912 void wxDataViewCtrl::DoSetExpanderColumn()
4914 gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview
),
4915 GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
4918 void wxDataViewCtrl::DoSetIndent()
4922 void wxDataViewCtrl::GtkDisableSelectionEvents()
4924 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4925 g_signal_handlers_disconnect_by_func( selection
,
4926 (gpointer
) (wxdataview_selection_changed_callback
), this);
4929 void wxDataViewCtrl::GtkEnableSelectionEvents()
4931 GtkTreeSelection
*selection
= gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview
) );
4932 g_signal_connect_after (selection
, "changed",
4933 G_CALLBACK (wxdataview_selection_changed_callback
), this);
4936 // ----------------------------------------------------------------------------
4937 // visual attributes stuff
4938 // ----------------------------------------------------------------------------
4942 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
4944 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new
);
4947 void wxDataViewCtrl::DoApplyWidgetStyle(GtkRcStyle
*style
)
4949 wxDataViewCtrlBase::DoApplyWidgetStyle(style
);
4950 gtk_widget_modify_style(m_treeview
, style
);
4953 #endif // !wxUSE_GENERICDATAVIEWCTRL
4955 #endif // wxUSE_DATAVIEWCTRL