]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/dataview.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
speed up reading wxFileConfig from wxInputStream by factors of 3.5, 20 and 7 for...
[wxWidgets.git] / src / gtk / dataview.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/gtk/dataview.cpp
3// Purpose: wxDataViewCtrl GTK+2 implementation
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
13#if wxUSE_DATAVIEWCTRL
14
15#include "wx/dataview.h"
16
17#ifndef wxUSE_GENERICDATAVIEWCTRL
18
19#ifndef WX_PRECOMP
20 #include "wx/log.h"
21 #include "wx/dcclient.h"
22 #include "wx/sizer.h"
23#endif
24
25#include "wx/stockitem.h"
26#include "wx/calctrl.h"
27#include "wx/popupwin.h"
28#include "wx/icon.h"
29
30
31#include "wx/gtk/private.h"
32#include "wx/gtk/win_gtk.h"
33
34#include <gobject/gvaluecollector.h>
35#include <gtk/gtktreemodel.h>
36#include <gtk/gtktreesortable.h>
37#include <gtk/gtktreednd.h>
38
39#include <gdk/gdkkeysyms.h>
40
41//-----------------------------------------------------------------------------
42// classes
43//-----------------------------------------------------------------------------
44
45//-----------------------------------------------------------------------------
46// wxGtkTreeModelNode
47//-----------------------------------------------------------------------------
48
49class wxGtkTreeModelNode;
50
51extern "C" {
52typedef struct _GtkWxTreeModel GtkWxTreeModel;
53}
54
55int LINKAGEMODE wxGtkTreeModelNodeCmp( wxGtkTreeModelNode* node1, wxGtkTreeModelNode* node2 );
56
57WX_DEFINE_SORTED_ARRAY( wxGtkTreeModelNode*, wxGtkTreeModelNodes );
58
59class wxGtkTreeModelNode
60{
61public:
62 wxGtkTreeModelNode( wxGtkTreeModelNode* parent, const wxDataViewItem &item,
63 wxDataViewCtrlInternal *internal )
64 {
65 m_parent = parent;
66 m_item = item;
67 m_internal = internal;
68 m_children = new wxGtkTreeModelNodes( wxGtkTreeModelNodeCmp );
69 }
70
71 ~wxGtkTreeModelNode()
72 {
73 size_t count = m_children->GetCount();
74 size_t i;
75 for (i = 0; i < count; i++)
76 {
77 wxGtkTreeModelNode *child = m_children->Item( i );
78 delete child;
79 }
80 delete m_children;
81 }
82
83 wxGtkTreeModelNode* GetParent()
84 { return m_parent; }
85 wxGtkTreeModelNodes &GetChildren()
86 { return *m_children; }
87 wxGtkTreeModelNode* GetNthChild( unsigned int n )
88 { return m_children->Item( n ); }
89 unsigned int Add( wxGtkTreeModelNode* child )
90 { return m_children->Add( child ); }
91
92 unsigned int GetChildCount() { return m_children->GetCount(); }
93
94 wxDataViewItem &GetItem() { return m_item; }
95 wxDataViewCtrlInternal *GetInternal() { return m_internal; }
96
97 bool HasChildren() { return m_hasChildren; }
98 void SetHasChildren( bool has ) { m_hasChildren = has; }
99
100 void Resort();
101
102private:
103 wxGtkTreeModelNode *m_parent;
104 wxGtkTreeModelNodes *m_children;
105 wxDataViewItem m_item;
106 bool m_hasChildren;
107 wxDataViewCtrlInternal *m_internal;
108};
109
110
111
112class wxDataViewCtrlInternal
113{
114public:
115 wxDataViewCtrlInternal( wxDataViewCtrl *owner, wxDataViewModel *wx_model, GtkWxTreeModel *owner );
116 ~wxDataViewCtrlInternal();
117
118 gboolean get_iter( GtkTreeIter *iter, GtkTreePath *path );
119 GtkTreePath *get_path( GtkTreeIter *iter);
120 GtkTreePath *get_path_safe( GtkTreeIter *iter);
121 gboolean iter_next( GtkTreeIter *iter );
122 gboolean iter_children( GtkTreeIter *iter, GtkTreeIter *parent);
123 gboolean iter_has_child( GtkTreeIter *iter );
124 gint iter_n_children( GtkTreeIter *iter );
125 gboolean iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n );
126 gboolean iter_parent( GtkTreeIter *iter, GtkTreeIter *child );
127
128 wxDataViewModel* GetDataViewModel() { return m_wx_model; }
129 wxDataViewCtrl* GetOwner() { return m_owner; }
130 GtkWxTreeModel* GetGtkModel() { return m_gtk_model; }
131
132 bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
133 bool ItemDeleted( const wxDataViewItem &item );
134
135 void Resort();
136
137protected:
138 void InitTree();
139 wxGtkTreeModelNode *FindNode( const wxDataViewItem &item );
140 wxGtkTreeModelNode *FindNode( GtkTreeIter *iter );
141 void BuildBranch( wxGtkTreeModelNode *branch );
142
143private:
144 wxGtkTreeModelNode *m_root;
145 wxDataViewModel *m_wx_model;
146 GtkWxTreeModel *m_gtk_model;
147 wxDataViewCtrl *m_owner;
148};
149
150
151int LINKAGEMODE wxGtkTreeModelNodeCmp( wxGtkTreeModelNode* node1, wxGtkTreeModelNode* node2 )
152{
153 return node1->GetInternal()->GetDataViewModel()->Compare( node1->GetItem(), node2->GetItem() );
154}
155
156//-----------------------------------------------------------------------------
157// data
158//-----------------------------------------------------------------------------
159
160extern bool g_blockEventsOnDrag;
161
162//-----------------------------------------------------------------------------
163// define new GTK+ class wxGtkTreeModel
164//-----------------------------------------------------------------------------
165
166extern "C" {
167
168#define GTK_TYPE_WX_TREE_MODEL (gtk_wx_tree_model_get_type ())
169#define GTK_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
170#define GTK_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
171#define GTK_IS_WX_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
172#define GTK_IS_WX_TREE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
173#define GTK_WX_TREE_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
174
175GType gtk_wx_tree_model_get_type (void);
176
177typedef struct _GtkWxTreeModelClass GtkWxTreeModelClass;
178
179struct _GtkWxTreeModel
180{
181 GObject parent;
182
183 /*< private >*/
184 gint stamp;
185 wxDataViewCtrlInternal *internal;
186};
187
188struct _GtkWxTreeModelClass
189{
190 GObjectClass list_parent_class;
191};
192
193static GtkWxTreeModel *wxgtk_tree_model_new (void);
194static void wxgtk_tree_model_init (GtkWxTreeModel *tree_model);
195static void wxgtk_tree_model_class_init (GtkWxTreeModelClass *klass);
196static void wxgtk_tree_model_tree_model_init (GtkTreeModelIface *iface);
197static void wxgtk_tree_model_sortable_init (GtkTreeSortableIface *iface);
198static void wxgtk_tree_model_finalize (GObject *object);
199static GtkTreeModelFlags wxgtk_tree_model_get_flags (GtkTreeModel *tree_model);
200static gint wxgtk_tree_model_get_n_columns (GtkTreeModel *tree_model);
201static GType wxgtk_tree_model_get_column_type (GtkTreeModel *tree_model,
202 gint index);
203static gboolean wxgtk_tree_model_get_iter (GtkTreeModel *tree_model,
204 GtkTreeIter *iter,
205 GtkTreePath *path);
206static GtkTreePath *wxgtk_tree_model_get_path (GtkTreeModel *tree_model,
207 GtkTreeIter *iter);
208static GtkTreePath *wxgtk_tree_model_get_path_safe (GtkTreeModel *tree_model,
209 GtkTreeIter *iter);
210static void wxgtk_tree_model_get_value (GtkTreeModel *tree_model,
211 GtkTreeIter *iter,
212 gint column,
213 GValue *value);
214static gboolean wxgtk_tree_model_iter_next (GtkTreeModel *tree_model,
215 GtkTreeIter *iter);
216static gboolean wxgtk_tree_model_iter_children (GtkTreeModel *tree_model,
217 GtkTreeIter *iter,
218 GtkTreeIter *parent);
219static gboolean wxgtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
220 GtkTreeIter *iter);
221static gint wxgtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
222 GtkTreeIter *iter);
223static gboolean wxgtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
224 GtkTreeIter *iter,
225 GtkTreeIter *parent,
226 gint n);
227static gboolean wxgtk_tree_model_iter_parent (GtkTreeModel *tree_model,
228 GtkTreeIter *iter,
229 GtkTreeIter *child);
230
231/* sortable */
232static gboolean wxgtk_tree_model_get_sort_column_id (GtkTreeSortable *sortable,
233 gint *sort_column_id,
234 GtkSortType *order);
235static void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable *sortable,
236 gint sort_column_id,
237 GtkSortType order);
238static void wxgtk_tree_model_set_sort_func (GtkTreeSortable *sortable,
239 gint sort_column_id,
240 GtkTreeIterCompareFunc func,
241 gpointer data,
242 GtkDestroyNotify destroy);
243static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable,
244 GtkTreeIterCompareFunc func,
245 gpointer data,
246 GtkDestroyNotify destroy);
247static gboolean wxgtk_tree_model_has_default_sort_func (GtkTreeSortable *sortable);
248
249
250
251static GObjectClass *list_parent_class = NULL;
252
253GType
254gtk_wx_tree_model_get_type (void)
255{
256 static GType tree_model_type = 0;
257
258 if (!tree_model_type)
259 {
260 const GTypeInfo tree_model_info =
261 {
262 sizeof (GtkWxTreeModelClass),
263 NULL, /* base_init */
264 NULL, /* base_finalize */
265 (GClassInitFunc) wxgtk_tree_model_class_init,
266 NULL, /* class_finalize */
267 NULL, /* class_data */
268 sizeof (GtkWxTreeModel),
269 0,
270 (GInstanceInitFunc) wxgtk_tree_model_init,
271 };
272
273 static const GInterfaceInfo tree_model_iface_info =
274 {
275 (GInterfaceInitFunc) wxgtk_tree_model_tree_model_init,
276 NULL,
277 NULL
278 };
279
280 static const GInterfaceInfo sortable_iface_info =
281 {
282 (GInterfaceInitFunc) wxgtk_tree_model_sortable_init,
283 NULL,
284 NULL
285 };
286
287 tree_model_type = g_type_register_static (G_TYPE_OBJECT, "GtkWxTreeModel",
288 &tree_model_info, (GTypeFlags)0 );
289
290 g_type_add_interface_static (tree_model_type,
291 GTK_TYPE_TREE_MODEL,
292 &tree_model_iface_info);
293 g_type_add_interface_static (tree_model_type,
294 GTK_TYPE_TREE_SORTABLE,
295 &sortable_iface_info);
296 }
297
298 return tree_model_type;
299}
300
301static GtkWxTreeModel *
302wxgtk_tree_model_new(void)
303{
304 GtkWxTreeModel *retval = (GtkWxTreeModel *) g_object_new (GTK_TYPE_WX_TREE_MODEL, NULL);
305 return retval;
306}
307
308static void
309wxgtk_tree_model_class_init (GtkWxTreeModelClass *klass)
310{
311 list_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
312 GObjectClass *object_class = (GObjectClass*) klass;
313 object_class->finalize = wxgtk_tree_model_finalize;
314}
315
316static void
317wxgtk_tree_model_tree_model_init (GtkTreeModelIface *iface)
318{
319 iface->get_flags = wxgtk_tree_model_get_flags;
320 iface->get_n_columns = wxgtk_tree_model_get_n_columns;
321 iface->get_column_type = wxgtk_tree_model_get_column_type;
322 iface->get_iter = wxgtk_tree_model_get_iter;
323 iface->get_path = wxgtk_tree_model_get_path;
324 iface->get_value = wxgtk_tree_model_get_value;
325 iface->iter_next = wxgtk_tree_model_iter_next;
326 iface->iter_children = wxgtk_tree_model_iter_children;
327 iface->iter_has_child = wxgtk_tree_model_iter_has_child;
328 iface->iter_n_children = wxgtk_tree_model_iter_n_children;
329 iface->iter_nth_child = wxgtk_tree_model_iter_nth_child;
330 iface->iter_parent = wxgtk_tree_model_iter_parent;
331}
332
333static void
334wxgtk_tree_model_sortable_init (GtkTreeSortableIface *iface)
335{
336 iface->get_sort_column_id = wxgtk_tree_model_get_sort_column_id;
337 iface->set_sort_column_id = wxgtk_tree_model_set_sort_column_id;
338 iface->set_sort_func = wxgtk_tree_model_set_sort_func;
339 iface->set_default_sort_func = wxgtk_tree_model_set_default_sort_func;
340 iface->has_default_sort_func = wxgtk_tree_model_has_default_sort_func;
341}
342
343static void
344wxgtk_tree_model_init (GtkWxTreeModel *tree_model)
345{
346 tree_model->internal = NULL;
347 tree_model->stamp = g_random_int();
348}
349
350static void
351wxgtk_tree_model_finalize (GObject *object)
352{
353 /* must chain up */
354 (* list_parent_class->finalize) (object);
355}
356
357} // extern "C"
358
359//-----------------------------------------------------------------------------
360// implement callbacks from wxGtkTreeModel class by letting
361// them call the methods of wxWidgets' wxDataViewModel
362//-----------------------------------------------------------------------------
363
364static GtkTreeModelFlags
365wxgtk_tree_model_get_flags (GtkTreeModel *tree_model)
366{
367 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (tree_model), (GtkTreeModelFlags)0 );
368
369 return GTK_TREE_MODEL_ITERS_PERSIST;
370}
371
372static gint
373wxgtk_tree_model_get_n_columns (GtkTreeModel *tree_model)
374{
375 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
376 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), 0);
377
378 return wxtree_model->internal->GetDataViewModel()->GetColumnCount();
379}
380
381static GType
382wxgtk_tree_model_get_column_type (GtkTreeModel *tree_model,
383 gint index)
384{
385 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
386 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), G_TYPE_INVALID);
387
388 GType gtype = G_TYPE_INVALID;
389
390 wxString wxtype = wxtree_model->internal->GetDataViewModel()->GetColumnType( (unsigned int) index );
391
392 if (wxtype == wxT("string"))
393 gtype = G_TYPE_STRING;
394 else
395 {
396 wxFAIL_MSG( _T("non-string columns not supported yet") );
397 }
398
399 return gtype;
400}
401
402static gboolean
403wxgtk_tree_model_get_iter (GtkTreeModel *tree_model,
404 GtkTreeIter *iter,
405 GtkTreePath *path)
406{
407 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
408 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
409 g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
410
411 return wxtree_model->internal->get_iter( iter, path );
412}
413
414static GtkTreePath *
415wxgtk_tree_model_get_path (GtkTreeModel *tree_model,
416 GtkTreeIter *iter)
417{
418 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
419 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), NULL);
420 g_return_val_if_fail (iter->stamp == GTK_WX_TREE_MODEL (wxtree_model)->stamp, NULL);
421
422 return wxtree_model->internal->get_path( iter );
423}
424
425static GtkTreePath *
426wxgtk_tree_model_get_path_safe (GtkTreeModel *tree_model,
427 GtkTreeIter *iter)
428{
429 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
430 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), NULL);
431 g_return_val_if_fail (iter->stamp == GTK_WX_TREE_MODEL (wxtree_model)->stamp, NULL);
432
433 return wxtree_model->internal->get_path_safe( iter );
434}
435
436static void
437wxgtk_tree_model_get_value (GtkTreeModel *tree_model,
438 GtkTreeIter *iter,
439 gint column,
440 GValue *value)
441{
442 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
443 g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model) );
444
445 wxDataViewModel *model = wxtree_model->internal->GetDataViewModel();
446 wxString mtype = model->GetColumnType( (unsigned int) column );
447 if (mtype == wxT("string"))
448 {
449 wxVariant variant;
450 g_value_init( value, G_TYPE_STRING );
451 wxDataViewItem item( (void*) iter->user_data );
452 model->GetValue( variant, item, (unsigned int) column );
453
454 g_value_set_string( value, variant.GetString().utf8_str() );
455 }
456 else
457 {
458 wxFAIL_MSG( _T("non-string columns not supported yet") );
459 }
460}
461
462static gboolean
463wxgtk_tree_model_iter_next (GtkTreeModel *tree_model,
464 GtkTreeIter *iter)
465{
466 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
467 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
468 g_return_val_if_fail (wxtree_model->stamp == iter->stamp, FALSE);
469
470 return wxtree_model->internal->iter_next( iter );
471}
472
473static gboolean
474wxgtk_tree_model_iter_children (GtkTreeModel *tree_model,
475 GtkTreeIter *iter,
476 GtkTreeIter *parent)
477{
478 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
479 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
480 g_return_val_if_fail (wxtree_model->stamp == parent->stamp, FALSE);
481
482 return wxtree_model->internal->iter_children( iter, parent );
483}
484
485static gboolean
486wxgtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
487 GtkTreeIter *iter)
488{
489 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
490 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
491 g_return_val_if_fail (wxtree_model->stamp == iter->stamp, FALSE);
492
493 return wxtree_model->internal->iter_has_child( iter );
494}
495
496static gint
497wxgtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
498 GtkTreeIter *iter)
499{
500 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
501 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
502 g_return_val_if_fail (wxtree_model->stamp == iter->stamp, 0);
503
504 return wxtree_model->internal->iter_n_children( iter );
505}
506
507static gboolean
508wxgtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
509 GtkTreeIter *iter,
510 GtkTreeIter *parent,
511 gint n)
512{
513 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
514 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
515
516 return wxtree_model->internal->iter_nth_child( iter, parent, n );
517}
518
519static gboolean
520wxgtk_tree_model_iter_parent (GtkTreeModel *tree_model,
521 GtkTreeIter *iter,
522 GtkTreeIter *child)
523{
524 GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
525 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
526 g_return_val_if_fail (wxtree_model->stamp == child->stamp, FALSE);
527
528 return wxtree_model->internal->iter_parent( iter, child );
529}
530
531/* sortable */
532gboolean wxgtk_tree_model_get_sort_column_id (GtkTreeSortable *sortable,
533 gint *sort_column_id,
534 GtkSortType *order)
535{
536 GtkWxTreeModel *tree_model = (GtkWxTreeModel *) sortable;
537
538 g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable), FALSE);
539
540 if (sort_column_id)
541 *sort_column_id = tree_model->internal->GetDataViewModel()->GetSortingColumn();
542
543 if (order)
544 {
545 bool ascending = tree_model->internal->GetDataViewModel()->GetSortOrderAscending();
546 if (ascending)
547 *order = GTK_SORT_ASCENDING;
548 else
549 *order = GTK_SORT_DESCENDING;
550 }
551
552 return TRUE;
553}
554
555void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable *sortable,
556 gint sort_column_id,
557 GtkSortType order)
558{
559 GtkWxTreeModel *tree_model = (GtkWxTreeModel *) sortable;
560 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
561
562 bool ascending = TRUE;
563 if (order != GTK_SORT_ASCENDING)
564 ascending = FALSE;
565
566 if ((sort_column_id == tree_model->internal->GetDataViewModel()->GetSortingColumn()) &&
567 (ascending == tree_model->internal->GetDataViewModel()->GetSortOrderAscending()))
568 return;
569
570 tree_model->internal->GetDataViewModel()->SetSortingColumn( sort_column_id );
571
572 tree_model->internal->GetDataViewModel()->SetSortOrderAscending( ascending );
573
574 gtk_tree_sortable_sort_column_changed (sortable);
575
576 tree_model->internal->GetDataViewModel()->Resort();
577}
578
579void wxgtk_tree_model_set_sort_func (GtkTreeSortable *sortable,
580 gint sort_column_id,
581 GtkTreeIterCompareFunc func,
582 gpointer data,
583 GtkDestroyNotify destroy)
584{
585 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
586 g_return_if_fail (func != NULL);
587}
588
589void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable,
590 GtkTreeIterCompareFunc func,
591 gpointer data,
592 GtkDestroyNotify destroy)
593{
594 g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
595 g_return_if_fail (func != NULL);
596
597 wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
598}
599
600gboolean wxgtk_tree_model_has_default_sort_func (GtkTreeSortable *sortable)
601{
602 return FALSE;
603}
604
605//-----------------------------------------------------------------------------
606// define new GTK+ class wxGtkRendererRenderer
607//-----------------------------------------------------------------------------
608
609extern "C" {
610
611#define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
612#define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
613#define GTK_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
614#define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
615#define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
616#define GTK_WX_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
617
618GType gtk_wx_cell_renderer_get_type (void);
619
620typedef struct _GtkWxCellRenderer GtkWxCellRenderer;
621typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass;
622
623struct _GtkWxCellRenderer
624{
625 GtkCellRenderer parent;
626
627 /*< private >*/
628 wxDataViewCustomRenderer *cell;
629 guint32 last_click;
630};
631
632struct _GtkWxCellRendererClass
633{
634 GtkCellRendererClass cell_parent_class;
635};
636
637
638static GtkCellRenderer *gtk_wx_cell_renderer_new (void);
639static void gtk_wx_cell_renderer_init (
640 GtkWxCellRenderer *cell );
641static void gtk_wx_cell_renderer_class_init(
642 GtkWxCellRendererClass *klass );
643static void gtk_wx_cell_renderer_finalize (
644 GObject *object );
645static void gtk_wx_cell_renderer_get_size (
646 GtkCellRenderer *cell,
647 GtkWidget *widget,
648 GdkRectangle *rectangle,
649 gint *x_offset,
650 gint *y_offset,
651 gint *width,
652 gint *height );
653static void gtk_wx_cell_renderer_render (
654 GtkCellRenderer *cell,
655 GdkWindow *window,
656 GtkWidget *widget,
657 GdkRectangle *background_area,
658 GdkRectangle *cell_area,
659 GdkRectangle *expose_area,
660 GtkCellRendererState flags );
661static gboolean gtk_wx_cell_renderer_activate(
662 GtkCellRenderer *cell,
663 GdkEvent *event,
664 GtkWidget *widget,
665 const gchar *path,
666 GdkRectangle *background_area,
667 GdkRectangle *cell_area,
668 GtkCellRendererState flags );
669static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
670 GtkCellRenderer *cell,
671 GdkEvent *event,
672 GtkWidget *widget,
673 const gchar *path,
674 GdkRectangle *background_area,
675 GdkRectangle *cell_area,
676 GtkCellRendererState flags );
677
678
679static GObjectClass *cell_parent_class = NULL;
680
681} // extern "C"
682
683GType
684gtk_wx_cell_renderer_get_type (void)
685{
686 static GType cell_wx_type = 0;
687
688 if (!cell_wx_type)
689 {
690 const GTypeInfo cell_wx_info =
691 {
692 sizeof (GtkWxCellRendererClass),
693 NULL, /* base_init */
694 NULL, /* base_finalize */
695 (GClassInitFunc) gtk_wx_cell_renderer_class_init,
696 NULL, /* class_finalize */
697 NULL, /* class_data */
698 sizeof (GtkWxCellRenderer),
699 0, /* n_preallocs */
700 (GInstanceInitFunc) gtk_wx_cell_renderer_init,
701 };
702
703 cell_wx_type = g_type_register_static( GTK_TYPE_CELL_RENDERER,
704 "GtkWxCellRenderer", &cell_wx_info, (GTypeFlags)0 );
705 }
706
707 return cell_wx_type;
708}
709
710static void
711gtk_wx_cell_renderer_init (GtkWxCellRenderer *cell)
712{
713 cell->cell = NULL;
714 cell->last_click = 0;
715}
716
717static void
718gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass *klass)
719{
720 GObjectClass *object_class = G_OBJECT_CLASS (klass);
721 GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
722
723 cell_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
724
725 object_class->finalize = gtk_wx_cell_renderer_finalize;
726
727 cell_class->get_size = gtk_wx_cell_renderer_get_size;
728 cell_class->render = gtk_wx_cell_renderer_render;
729 cell_class->activate = gtk_wx_cell_renderer_activate;
730 cell_class->start_editing = gtk_wx_cell_renderer_start_editing;
731}
732
733static void
734gtk_wx_cell_renderer_finalize (GObject *object)
735{
736 /* must chain up */
737 (* G_OBJECT_CLASS (cell_parent_class)->finalize) (object);
738}
739
740GtkCellRenderer*
741gtk_wx_cell_renderer_new (void)
742{
743 return (GtkCellRenderer*) g_object_new (GTK_TYPE_WX_CELL_RENDERER, NULL);
744}
745
746
747
748static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
749 GtkCellRenderer *renderer,
750 GdkEvent *event,
751 GtkWidget *widget,
752 const gchar *path,
753 GdkRectangle *background_area,
754 GdkRectangle *cell_area,
755 GtkCellRendererState flags )
756{
757 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
758 wxDataViewCustomRenderer *cell = wxrenderer->cell;
759 if (!cell->HasEditorCtrl())
760 return NULL;
761
762 GdkRectangle rect;
763 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
764 &rect.x,
765 &rect.y,
766 &rect.width,
767 &rect.height);
768
769 rect.x += cell_area->x;
770 rect.y += cell_area->y;
771// rect.width -= renderer->xpad * 2;
772// rect.height -= renderer->ypad * 2;
773
774// wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
775 wxRect renderrect( cell_area->x, cell_area->y, cell_area->width, cell_area->height );
776
777 GtkTreePath *treepath = gtk_tree_path_new_from_string( path );
778 GtkTreeIter iter;
779 cell->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter, treepath );
780 wxDataViewItem item( (void*) iter.user_data );
781 gtk_tree_path_free( treepath );
782
783 cell->StartEditing( item, renderrect );
784
785 return NULL;
786}
787
788static void
789gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
790 GtkWidget *widget,
791 GdkRectangle *cell_area,
792 gint *x_offset,
793 gint *y_offset,
794 gint *width,
795 gint *height)
796{
797 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
798 wxDataViewCustomRenderer *cell = wxrenderer->cell;
799
800 wxSize size = cell->GetSize();
801
802 gint calc_width = (gint) renderer->xpad * 2 + size.x;
803 gint calc_height = (gint) renderer->ypad * 2 + size.y;
804
805 if (x_offset)
806 *x_offset = 0;
807 if (y_offset)
808 *y_offset = 0;
809
810 if (cell_area && size.x > 0 && size.y > 0)
811 {
812 if (x_offset)
813 {
814 *x_offset = (gint)((renderer->xalign *
815 (cell_area->width - calc_width - 2 * renderer->xpad)));
816 *x_offset = MAX (*x_offset, 0) + renderer->xpad;
817 }
818 if (y_offset)
819 {
820 *y_offset = (gint)((renderer->yalign *
821 (cell_area->height - calc_height - 2 * renderer->ypad)));
822 *y_offset = MAX (*y_offset, 0) + renderer->ypad;
823 }
824 }
825
826 if (width)
827 *width = calc_width;
828
829 if (height)
830 *height = calc_height;
831}
832
833static void
834gtk_wx_cell_renderer_render (GtkCellRenderer *renderer,
835 GdkWindow *window,
836 GtkWidget *widget,
837 GdkRectangle *background_area,
838 GdkRectangle *cell_area,
839 GdkRectangle *expose_area,
840 GtkCellRendererState flags)
841
842{
843 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
844 wxDataViewCustomRenderer *cell = wxrenderer->cell;
845
846 GdkRectangle rect;
847 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
848 &rect.x,
849 &rect.y,
850 &rect.width,
851 &rect.height);
852
853 rect.x += cell_area->x;
854 rect.y += cell_area->y;
855 rect.width -= renderer->xpad * 2;
856 rect.height -= renderer->ypad * 2;
857
858 GdkRectangle dummy;
859 if (gdk_rectangle_intersect (expose_area, &rect, &dummy))
860 {
861 wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
862 wxWindowDC* dc = (wxWindowDC*) cell->GetDC();
863 if (dc->m_window == NULL)
864 {
865 dc->m_window = window;
866 dc->SetUpDC();
867 }
868
869 int state = 0;
870 if (flags & GTK_CELL_RENDERER_SELECTED)
871 state |= wxDATAVIEW_CELL_SELECTED;
872 if (flags & GTK_CELL_RENDERER_PRELIT)
873 state |= wxDATAVIEW_CELL_PRELIT;
874 if (flags & GTK_CELL_RENDERER_INSENSITIVE)
875 state |= wxDATAVIEW_CELL_INSENSITIVE;
876 if (flags & GTK_CELL_RENDERER_INSENSITIVE)
877 state |= wxDATAVIEW_CELL_INSENSITIVE;
878 if (flags & GTK_CELL_RENDERER_FOCUSED)
879 state |= wxDATAVIEW_CELL_FOCUSED;
880 cell->Render( renderrect, dc, state );
881 }
882}
883
884static gboolean
885gtk_wx_cell_renderer_activate(
886 GtkCellRenderer *renderer,
887 GdkEvent *event,
888 GtkWidget *widget,
889 const gchar *path,
890 GdkRectangle *background_area,
891 GdkRectangle *cell_area,
892 GtkCellRendererState flags )
893{
894 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
895 wxDataViewCustomRenderer *cell = wxrenderer->cell;
896
897 GdkRectangle rect;
898 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
899 &rect.x,
900 &rect.y,
901 &rect.width,
902 &rect.height);
903
904 rect.x += cell_area->x;
905 rect.y += cell_area->y;
906 rect.width -= renderer->xpad * 2;
907 rect.height -= renderer->ypad * 2;
908
909 wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
910
911 wxDataViewModel *model = cell->GetOwner()->GetOwner()->GetModel();
912
913 GtkTreePath *treepath = gtk_tree_path_new_from_string( path );
914 // TODO
915 wxDataViewItem item;
916 gtk_tree_path_free( treepath );
917
918 unsigned int model_col = cell->GetOwner()->GetModelColumn();
919
920 if (!event)
921 {
922 bool ret = false;
923
924 // activated by <ENTER>
925 if (cell->Activate( renderrect, model, item, model_col ))
926 ret = true;
927
928 return ret;
929 }
930 else if (event->type == GDK_BUTTON_PRESS)
931 {
932 GdkEventButton *button_event = (GdkEventButton*) event;
933 wxPoint pt( ((int) button_event->x) - renderrect.x,
934 ((int) button_event->y) - renderrect.y );
935
936 bool ret = false;
937 if (button_event->button == 1)
938 {
939 if (cell->LeftClick( pt, renderrect, model, item, model_col ))
940 ret = true;
941 // TODO: query system double-click time
942 if (button_event->time - wxrenderer->last_click < 400)
943 if (cell->Activate( renderrect, model, item, model_col ))
944 ret = true;
945 }
946 if (button_event->button == 3)
947 {
948 if (cell->RightClick( pt, renderrect, model, item, model_col ))
949 ret = true;
950 }
951
952 wxrenderer->last_click = button_event->time;
953
954 return ret;
955 }
956
957 return false;
958}
959
960// ---------------------------------------------------------
961// wxGtkDataViewModelNotifier
962// ---------------------------------------------------------
963
964class wxGtkDataViewModelNotifier: public wxDataViewModelNotifier
965{
966public:
967 wxGtkDataViewModelNotifier( GtkWxTreeModel *wxgtk_model,
968 wxDataViewModel *wx_model,
969 wxDataViewCtrl *ctrl );
970 ~wxGtkDataViewModelNotifier();
971
972 virtual bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
973 virtual bool ItemDeleted( const wxDataViewItem &item );
974 virtual bool ItemChanged( const wxDataViewItem &item );
975 virtual bool ValueChanged( const wxDataViewItem &item, unsigned int col );
976 virtual bool Cleared();
977 virtual void Resort();
978
979 GtkWxTreeModel *m_wxgtk_model;
980 wxDataViewModel *m_wx_model;
981 wxDataViewCtrl *m_owner;
982};
983
984// ---------------------------------------------------------
985// wxGtkDataViewListModelNotifier
986// ---------------------------------------------------------
987
988wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
989 GtkWxTreeModel* wxgtk_model, wxDataViewModel *wx_model,
990 wxDataViewCtrl *ctrl )
991{
992 m_wxgtk_model = wxgtk_model;
993 m_wx_model = wx_model;
994 m_owner = ctrl;
995}
996
997wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
998{
999 m_wx_model = NULL;
1000 m_wxgtk_model = NULL;
1001}
1002
1003bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
1004{
1005 m_owner->GtkGetInternal()->ItemAdded( parent, item );
1006
1007 GtkTreeIter iter;
1008 iter.stamp = m_wxgtk_model->stamp;
1009 iter.user_data = (gpointer) item.GetID();
1010
1011 GtkTreePath *path = wxgtk_tree_model_get_path(
1012 GTK_TREE_MODEL(m_wxgtk_model), &iter );
1013 gtk_tree_model_row_inserted(
1014 GTK_TREE_MODEL(m_wxgtk_model), path, &iter);
1015 gtk_tree_path_free (path);
1016
1017 return true;
1018}
1019
1020bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem &item )
1021{
1022 GtkTreeIter iter;
1023 iter.stamp = m_wxgtk_model->stamp;
1024 iter.user_data = (gpointer) item.GetID();
1025
1026 GtkTreePath *path = wxgtk_tree_model_get_path_safe(
1027 GTK_TREE_MODEL(m_wxgtk_model), &iter );
1028 gtk_tree_model_row_deleted(
1029 GTK_TREE_MODEL(m_wxgtk_model), path );
1030 gtk_tree_path_free (path);
1031
1032 m_owner->GtkGetInternal()->ItemDeleted( item );
1033
1034 return true;
1035}
1036
1037void wxGtkDataViewModelNotifier::Resort()
1038{
1039 m_owner->GtkGetInternal()->Resort();
1040}
1041
1042bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem &item )
1043{
1044 GtkTreeIter iter;
1045 iter.stamp = m_wxgtk_model->stamp;
1046 iter.user_data = (gpointer) item.GetID();
1047
1048 GtkTreePath *path = wxgtk_tree_model_get_path(
1049 GTK_TREE_MODEL(m_wxgtk_model), &iter );
1050 gtk_tree_model_row_changed(
1051 GTK_TREE_MODEL(m_wxgtk_model), path, &iter );
1052 gtk_tree_path_free (path);
1053
1054 return true;
1055}
1056
1057bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem &item, unsigned int model_col )
1058{
1059 // This adds GTK+'s missing MVC logic for ValueChanged
1060 unsigned int index;
1061 for (index = 0; index < m_owner->GetColumnCount(); index++)
1062 {
1063 wxDataViewColumn *column = m_owner->GetColumn( index );
1064 if (column->GetModelColumn() == model_col)
1065 {
1066 GtkTreeView *widget = GTK_TREE_VIEW(m_owner->m_treeview);
1067 GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
1068
1069 // Get cell area
1070 GtkTreeIter iter;
1071 iter.stamp = m_wxgtk_model->stamp;
1072 iter.user_data = (gpointer) item.GetID();
1073 GtkTreePath *path = wxgtk_tree_model_get_path(
1074 GTK_TREE_MODEL(m_wxgtk_model), &iter );
1075 GdkRectangle cell_area;
1076 gtk_tree_view_get_cell_area( widget, path, gcolumn, &cell_area );
1077 gtk_tree_path_free( path );
1078
1079 GtkAdjustment* hadjust = gtk_tree_view_get_hadjustment( widget );
1080 double d = gtk_adjustment_get_value( hadjust );
1081 int xdiff = (int) d;
1082
1083 int ydiff = gcolumn->button->allocation.height;
1084 // Redraw
1085 gtk_widget_queue_draw_area( GTK_WIDGET(widget),
1086 cell_area.x - xdiff, ydiff + cell_area.y, cell_area.width, cell_area.height );
1087 }
1088 }
1089
1090 return true;
1091}
1092
1093bool wxGtkDataViewModelNotifier::Cleared()
1094{
1095 return false;
1096}
1097
1098// ---------------------------------------------------------
1099// wxDataViewRenderer
1100// ---------------------------------------------------------
1101
1102IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
1103
1104wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1105 int align ) :
1106 wxDataViewRendererBase( varianttype, mode, align )
1107{
1108 m_renderer = NULL;
1109
1110 // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1111 // after the m_renderer pointer has been initialized
1112}
1113
1114void wxDataViewRenderer::SetMode( wxDataViewCellMode mode )
1115{
1116 GtkCellRendererMode gtkMode;
1117 switch (mode)
1118 {
1119 case wxDATAVIEW_CELL_INERT:
1120 gtkMode = GTK_CELL_RENDERER_MODE_INERT;
1121 break;
1122 case wxDATAVIEW_CELL_ACTIVATABLE:
1123 gtkMode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
1124 break;
1125 case wxDATAVIEW_CELL_EDITABLE:
1126 gtkMode = GTK_CELL_RENDERER_MODE_EDITABLE;
1127 break;
1128 }
1129
1130 GValue gvalue = { 0, };
1131 g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1132 g_value_set_enum( &gvalue, gtkMode );
1133 g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue );
1134 g_value_unset( &gvalue );
1135}
1136
1137wxDataViewCellMode wxDataViewRenderer::GetMode() const
1138{
1139 wxDataViewCellMode ret;
1140
1141 GValue gvalue;
1142 g_object_get( G_OBJECT(m_renderer), "mode", &gvalue, NULL);
1143
1144 switch (g_value_get_enum(&gvalue))
1145 {
1146 case GTK_CELL_RENDERER_MODE_INERT:
1147 ret = wxDATAVIEW_CELL_INERT;
1148 break;
1149 case GTK_CELL_RENDERER_MODE_ACTIVATABLE:
1150 ret = wxDATAVIEW_CELL_ACTIVATABLE;
1151 break;
1152 case GTK_CELL_RENDERER_MODE_EDITABLE:
1153 ret = wxDATAVIEW_CELL_EDITABLE;
1154 break;
1155 }
1156
1157 g_value_unset( &gvalue );
1158
1159 return ret;
1160}
1161
1162void wxDataViewRenderer::SetAlignment( int align )
1163{
1164 // horizontal alignment:
1165
1166 gfloat xalign = 0.0;
1167 if (align & wxALIGN_RIGHT)
1168 xalign = 1.0;
1169 else if (align & wxALIGN_CENTER_HORIZONTAL)
1170 xalign = 0.5;
1171
1172 GValue gvalue = { 0, };
1173 g_value_init( &gvalue, G_TYPE_FLOAT );
1174 g_value_set_float( &gvalue, xalign );
1175 g_object_set_property( G_OBJECT(m_renderer), "xalign", &gvalue );
1176 g_value_unset( &gvalue );
1177
1178 // vertical alignment:
1179
1180 gfloat yalign = 0.0;
1181 if (align & wxALIGN_BOTTOM)
1182 yalign = 1.0;
1183 else if (align & wxALIGN_CENTER_VERTICAL)
1184 yalign = 0.5;
1185
1186 GValue gvalue2 = { 0, };
1187 g_value_init( &gvalue2, G_TYPE_FLOAT );
1188 g_value_set_float( &gvalue2, yalign );
1189 g_object_set_property( G_OBJECT(m_renderer), "yalign", &gvalue2 );
1190 g_value_unset( &gvalue2 );
1191}
1192
1193int wxDataViewRenderer::GetAlignment() const
1194{
1195 int ret = 0;
1196 GValue gvalue;
1197
1198 // horizontal alignment:
1199
1200 g_object_get( G_OBJECT(m_renderer), "xalign", &gvalue, NULL );
1201 float xalign = g_value_get_float( &gvalue );
1202 if (xalign < 0.5)
1203 ret |= wxALIGN_LEFT;
1204 else if (xalign == 0.5)
1205 ret |= wxALIGN_CENTER_HORIZONTAL;
1206 else
1207 ret |= wxALIGN_RIGHT;
1208 g_value_unset( &gvalue );
1209
1210
1211 // vertical alignment:
1212
1213 g_object_get( G_OBJECT(m_renderer), "yalign", &gvalue, NULL );
1214 float yalign = g_value_get_float( &gvalue );
1215 if (yalign < 0.5)
1216 ret |= wxALIGN_TOP;
1217 else if (yalign == 0.5)
1218 ret |= wxALIGN_CENTER_VERTICAL;
1219 else
1220 ret |= wxALIGN_BOTTOM;
1221 g_value_unset( &gvalue );
1222
1223 return ret;
1224}
1225
1226
1227
1228// ---------------------------------------------------------
1229// wxDataViewTextRenderer
1230// ---------------------------------------------------------
1231
1232extern "C" {
1233static void wxGtkTextRendererEditedCallback( GtkCellRendererText *renderer,
1234 gchar *arg1, gchar *arg2, gpointer user_data );
1235}
1236
1237static void wxGtkTextRendererEditedCallback( GtkCellRendererText *renderer,
1238 gchar *arg1, gchar *arg2, gpointer user_data )
1239{
1240 wxDataViewTextRenderer *cell = (wxDataViewTextRenderer*) user_data;
1241
1242 wxString tmp = wxGTK_CONV_BACK_FONT(arg2, cell->GetOwner()->GetOwner()->GetFont());
1243 wxVariant value = tmp;
1244 if (!cell->Validate( value ))
1245 return;
1246
1247 wxDataViewModel *model = cell->GetOwner()->GetOwner()->GetModel();
1248
1249 GtkTreePath *path = gtk_tree_path_new_from_string( arg1 );
1250 GtkTreeIter iter;
1251 cell->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter, path );
1252 wxDataViewItem item( (void*) iter.user_data );;
1253 gtk_tree_path_free( path );
1254
1255 unsigned int model_col = cell->GetOwner()->GetModelColumn();
1256
1257 model->SetValue( value, item, model_col );
1258 model->ValueChanged( item, model_col );
1259}
1260
1261IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer)
1262
1263wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1264 int align ) :
1265 wxDataViewRenderer( varianttype, mode, align )
1266{
1267 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new();
1268
1269 if (mode & wxDATAVIEW_CELL_EDITABLE)
1270 {
1271 GValue gvalue = { 0, };
1272 g_value_init( &gvalue, G_TYPE_BOOLEAN );
1273 g_value_set_boolean( &gvalue, true );
1274 g_object_set_property( G_OBJECT(m_renderer), "editable", &gvalue );
1275 g_value_unset( &gvalue );
1276
1277 g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
1278 }
1279
1280 SetMode(mode);
1281 SetAlignment(align);
1282}
1283
1284bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
1285{
1286 wxString tmp = value;
1287
1288 GValue gvalue = { 0, };
1289 g_value_init( &gvalue, G_TYPE_STRING );
1290 g_value_set_string( &gvalue, wxGTK_CONV_FONT( tmp, GetOwner()->GetOwner()->GetFont() ) );
1291 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
1292 g_value_unset( &gvalue );
1293
1294 return true;
1295}
1296
1297bool wxDataViewTextRenderer::GetValue( wxVariant &value ) const
1298{
1299 GValue gvalue = { 0, };
1300 g_value_init( &gvalue, G_TYPE_STRING );
1301 g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
1302 wxString tmp = wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue ),
1303 wx_const_cast(wxDataViewTextRenderer*, this)->GetOwner()->GetOwner()->GetFont() );
1304 g_value_unset( &gvalue );
1305
1306 value = tmp;
1307
1308 return true;
1309}
1310
1311void wxDataViewTextRenderer::SetAlignment( int align )
1312{
1313 wxDataViewRenderer::SetAlignment(align);
1314
1315 if (gtk_check_version(2,10,0))
1316 return;
1317
1318 // horizontal alignment:
1319 PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
1320 if (align & wxALIGN_RIGHT)
1321 pangoAlign = PANGO_ALIGN_RIGHT;
1322 else if (align & wxALIGN_CENTER_HORIZONTAL)
1323 pangoAlign = PANGO_ALIGN_CENTER;
1324
1325 GValue gvalue = { 0, };
1326 g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1327 g_value_set_enum( &gvalue, pangoAlign );
1328 g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
1329 g_value_unset( &gvalue );
1330}
1331
1332// ---------------------------------------------------------
1333// wxDataViewBitmapRenderer
1334// ---------------------------------------------------------
1335
1336IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer)
1337
1338wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1339 int align ) :
1340 wxDataViewRenderer( varianttype, mode, align )
1341{
1342 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_pixbuf_new();
1343
1344 SetMode(mode);
1345 SetAlignment(align);
1346}
1347
1348bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
1349{
1350 if (value.GetType() == wxT("wxBitmap"))
1351 {
1352 wxBitmap bitmap;
1353 bitmap << value;
1354
1355 // This may create a Pixbuf representation in the
1356 // wxBitmap object (and it will stay there)
1357 GdkPixbuf *pixbuf = bitmap.GetPixbuf();
1358
1359 GValue gvalue = { 0, };
1360 g_value_init( &gvalue, G_TYPE_OBJECT );
1361 g_value_set_object( &gvalue, pixbuf );
1362 g_object_set_property( G_OBJECT(m_renderer), "pixbuf", &gvalue );
1363 g_value_unset( &gvalue );
1364
1365 return true;
1366 }
1367
1368 if (value.GetType() == wxT("wxIcon"))
1369 {
1370 wxIcon bitmap;
1371 bitmap << value;
1372
1373 // This may create a Pixbuf representation in the
1374 // wxBitmap object (and it will stay there)
1375 GdkPixbuf *pixbuf = bitmap.GetPixbuf();
1376
1377 GValue gvalue = { 0, };
1378 g_value_init( &gvalue, G_TYPE_OBJECT );
1379 g_value_set_object( &gvalue, pixbuf );
1380 g_object_set_property( G_OBJECT(m_renderer), "pixbuf", &gvalue );
1381 g_value_unset( &gvalue );
1382
1383 return true;
1384 }
1385
1386 return false;
1387}
1388
1389bool wxDataViewBitmapRenderer::GetValue( wxVariant &value ) const
1390{
1391 return false;
1392}
1393
1394// ---------------------------------------------------------
1395// wxDataViewToggleRenderer
1396// ---------------------------------------------------------
1397
1398extern "C" {
1399static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
1400 gchar *path, gpointer user_data );
1401}
1402
1403static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
1404 gchar *path, gpointer user_data )
1405{
1406 wxDataViewToggleRenderer *cell = (wxDataViewToggleRenderer*) user_data;
1407
1408 // get old value
1409 GValue gvalue = { 0, };
1410 g_value_init( &gvalue, G_TYPE_BOOLEAN );
1411 g_object_get_property( G_OBJECT(renderer), "active", &gvalue );
1412 bool tmp = g_value_get_boolean( &gvalue );
1413 g_value_unset( &gvalue );
1414 // invert it
1415 tmp = !tmp;
1416
1417 wxVariant value = tmp;
1418 if (!cell->Validate( value ))
1419 return;
1420
1421 wxDataViewModel *model = cell->GetOwner()->GetOwner()->GetModel();
1422
1423 GtkTreePath *gtk_path = gtk_tree_path_new_from_string( path );
1424 GtkTreeIter iter;
1425 cell->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter, gtk_path );
1426 wxDataViewItem item( (void*) iter.user_data );;
1427 gtk_tree_path_free( gtk_path );
1428
1429 unsigned int model_col = cell->GetOwner()->GetModelColumn();
1430
1431 model->SetValue( value, item, model_col );
1432 model->ValueChanged( item, model_col );
1433}
1434
1435IMPLEMENT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer)
1436
1437wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
1438 wxDataViewCellMode mode, int align ) :
1439 wxDataViewRenderer( varianttype, mode, align )
1440{
1441 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_toggle_new();
1442
1443 if (mode & wxDATAVIEW_CELL_ACTIVATABLE)
1444 {
1445 g_signal_connect_after( m_renderer, "toggled",
1446 G_CALLBACK(wxGtkToggleRendererToggledCallback), this );
1447 }
1448 else
1449 {
1450 GValue gvalue = { 0, };
1451 g_value_init( &gvalue, G_TYPE_BOOLEAN );
1452 g_value_set_boolean( &gvalue, false );
1453 g_object_set_property( G_OBJECT(m_renderer), "activatable", &gvalue );
1454 g_value_unset( &gvalue );
1455 }
1456
1457 SetMode(mode);
1458 SetAlignment(align);
1459}
1460
1461bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
1462{
1463 bool tmp = value;
1464
1465 GValue gvalue = { 0, };
1466 g_value_init( &gvalue, G_TYPE_BOOLEAN );
1467 g_value_set_boolean( &gvalue, tmp );
1468 g_object_set_property( G_OBJECT(m_renderer), "active", &gvalue );
1469 g_value_unset( &gvalue );
1470
1471 return true;
1472}
1473
1474bool wxDataViewToggleRenderer::GetValue( wxVariant &value ) const
1475{
1476 GValue gvalue = { 0, };
1477 g_value_init( &gvalue, G_TYPE_BOOLEAN );
1478 g_object_get_property( G_OBJECT(m_renderer), "active", &gvalue );
1479 bool tmp = g_value_get_boolean( &gvalue );
1480 g_value_unset( &gvalue );
1481
1482 value = tmp;
1483
1484 return true;
1485}
1486
1487// ---------------------------------------------------------
1488// wxDataViewCustomRenderer
1489// ---------------------------------------------------------
1490
1491class wxDataViewCtrlDC: public wxWindowDC
1492{
1493public:
1494 wxDataViewCtrlDC( wxDataViewCtrl *window )
1495 {
1496 GtkWidget *widget = window->m_treeview;
1497 // Set later
1498 m_window = NULL;
1499
1500 m_context = window->GtkGetPangoDefaultContext();
1501 m_layout = pango_layout_new( m_context );
1502 m_fontdesc = pango_font_description_copy( widget->style->font_desc );
1503
1504 m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
1505
1506 // Set m_window later
1507 // SetUpDC();
1508 // m_owner = window;
1509 }
1510};
1511
1512// ---------------------------------------------------------
1513// wxDataViewCustomRenderer
1514// ---------------------------------------------------------
1515
1516IMPLEMENT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
1517
1518wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
1519 wxDataViewCellMode mode, int align,
1520 bool no_init ) :
1521 wxDataViewRenderer( varianttype, mode, align )
1522{
1523 m_dc = NULL;
1524
1525 if (no_init)
1526 m_renderer = NULL;
1527 else
1528 Init(mode, align);
1529}
1530
1531bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode, int align)
1532{
1533 GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
1534 renderer->cell = this;
1535
1536 m_renderer = (GtkCellRenderer*) renderer;
1537
1538 SetMode(mode);
1539 SetAlignment(align);
1540
1541 return true;
1542}
1543
1544wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
1545{
1546 if (m_dc)
1547 delete m_dc;
1548}
1549
1550wxDC *wxDataViewCustomRenderer::GetDC()
1551{
1552 if (m_dc == NULL)
1553 {
1554 if (GetOwner() == NULL)
1555 return NULL;
1556 if (GetOwner()->GetOwner() == NULL)
1557 return NULL;
1558 m_dc = new wxDataViewCtrlDC( GetOwner()->GetOwner() );
1559 }
1560
1561 return m_dc;
1562}
1563
1564// ---------------------------------------------------------
1565// wxDataViewProgressRenderer
1566// ---------------------------------------------------------
1567
1568IMPLEMENT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
1569
1570wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
1571 const wxString &varianttype, wxDataViewCellMode mode, int align ) :
1572 wxDataViewCustomRenderer( varianttype, mode, align, true )
1573{
1574 m_label = label;
1575 m_value = 0;
1576
1577#ifdef __WXGTK26__
1578 if (!gtk_check_version(2,6,0))
1579 {
1580 m_renderer = (GtkCellRenderer*) gtk_cell_renderer_progress_new();
1581
1582 GValue gvalue = { 0, };
1583 g_value_init( &gvalue, G_TYPE_STRING );
1584
1585 // FIXME: font encoding support
1586 g_value_set_string( &gvalue, wxGTK_CONV_SYS(m_label) );
1587 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
1588 g_value_unset( &gvalue );
1589
1590 SetMode(mode);
1591 SetAlignment(align);
1592 }
1593 else
1594#endif
1595 {
1596 // Use custom cell code
1597 wxDataViewCustomRenderer::Init(mode, align);
1598 }
1599}
1600
1601wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
1602{
1603}
1604
1605bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
1606{
1607#ifdef __WXGTK26__
1608 if (!gtk_check_version(2,6,0))
1609 {
1610 gint tmp = (long) value;
1611 GValue gvalue = { 0, };
1612 g_value_init( &gvalue, G_TYPE_INT );
1613 g_value_set_int( &gvalue, tmp );
1614 g_object_set_property( G_OBJECT(m_renderer), "value", &gvalue );
1615 g_value_unset( &gvalue );
1616 }
1617 else
1618#endif
1619 {
1620 m_value = (long) value;
1621
1622 if (m_value < 0) m_value = 0;
1623 if (m_value > 100) m_value = 100;
1624 }
1625
1626 return true;
1627}
1628
1629bool wxDataViewProgressRenderer::GetValue( wxVariant &value ) const
1630{
1631 return false;
1632}
1633
1634bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int state )
1635{
1636 double pct = (double)m_value / 100.0;
1637 wxRect bar = cell;
1638 bar.width = (int)(cell.width * pct);
1639 dc->SetPen( *wxTRANSPARENT_PEN );
1640 dc->SetBrush( *wxBLUE_BRUSH );
1641 dc->DrawRectangle( bar );
1642
1643 dc->SetBrush( *wxTRANSPARENT_BRUSH );
1644 dc->SetPen( *wxBLACK_PEN );
1645 dc->DrawRectangle( cell );
1646
1647 return true;
1648}
1649
1650wxSize wxDataViewProgressRenderer::GetSize() const
1651{
1652 return wxSize(40,12);
1653}
1654
1655// ---------------------------------------------------------
1656// wxDataViewDateRenderer
1657// ---------------------------------------------------------
1658
1659class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
1660{
1661public:
1662 wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
1663 wxDataViewModel *model, const wxDataViewItem &item, unsigned int col ) :
1664 wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
1665 {
1666 m_model = model;
1667 m_item = item;
1668 m_col = col;
1669 m_cal = new wxCalendarCtrl( this, -1, *value );
1670 wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
1671 sizer->Add( m_cal, 1, wxGROW );
1672 SetSizer( sizer );
1673 sizer->Fit( this );
1674 }
1675
1676 virtual void OnDismiss()
1677 {
1678 }
1679
1680 void OnCalendar( wxCalendarEvent &event );
1681
1682 wxCalendarCtrl *m_cal;
1683 wxDataViewModel *m_model;
1684 wxDataViewItem m_item;
1685 unsigned int m_col;
1686
1687private:
1688 DECLARE_EVENT_TABLE()
1689};
1690
1691BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
1692 EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient::OnCalendar )
1693END_EVENT_TABLE()
1694
1695void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
1696{
1697 wxDateTime date = event.GetDate();
1698 wxVariant value = date;
1699 m_model->SetValue( value, m_item, m_col );
1700 m_model->ValueChanged( m_item, m_col );
1701 DismissAndNotify();
1702}
1703
1704IMPLEMENT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
1705
1706wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
1707 wxDataViewCellMode mode, int align ) :
1708 wxDataViewCustomRenderer( varianttype, mode, align )
1709{
1710 SetMode(mode);
1711 SetAlignment(align);
1712}
1713
1714bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
1715{
1716 m_date = value.GetDateTime();
1717
1718 return true;
1719}
1720
1721bool wxDataViewDateRenderer::GetValue( wxVariant &value ) const
1722{
1723 return false;
1724}
1725
1726bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int state )
1727{
1728 dc->SetFont( GetOwner()->GetOwner()->GetFont() );
1729 wxString tmp = m_date.FormatDate();
1730 dc->DrawText( tmp, cell.x, cell.y );
1731
1732 return true;
1733}
1734
1735wxSize wxDataViewDateRenderer::GetSize() const
1736{
1737 wxString tmp = m_date.FormatDate();
1738 wxCoord x,y,d;
1739 GetView()->GetTextExtent( tmp, &x, &y, &d );
1740 return wxSize(x,y+d);
1741}
1742
1743bool wxDataViewDateRenderer::Activate( wxRect cell, wxDataViewModel *model,
1744 const wxDataViewItem &item, unsigned int col )
1745{
1746 wxVariant variant;
1747 model->GetValue( variant, item, col );
1748 wxDateTime value = variant.GetDateTime();
1749
1750 wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
1751 GetOwner()->GetOwner()->GetParent(), &value, model, item, col );
1752 wxPoint pos = wxGetMousePosition();
1753 popup->Move( pos );
1754 popup->Layout();
1755 popup->Popup( popup->m_cal );
1756
1757 return true;
1758}
1759
1760// ---------------------------------------------------------
1761// wxDataViewColumn
1762// ---------------------------------------------------------
1763
1764
1765static gboolean
1766gtk_dataview_header_button_press_callback( GtkWidget *widget,
1767 GdkEventButton *gdk_event,
1768 wxDataViewColumn *column )
1769{
1770 if (gdk_event->type != GDK_BUTTON_PRESS)
1771 return FALSE;
1772
1773 if (gdk_event->button == 1)
1774 {
1775 wxDataViewCtrl *dv = column->GetOwner();
1776 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
1777 event.SetDataViewColumn( column );
1778 event.SetModel( dv->GetModel() );
1779 if (dv->GetEventHandler()->ProcessEvent( event ))
1780 return TRUE;
1781 }
1782
1783 return FALSE;
1784}
1785
1786extern "C" {
1787static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *column,
1788 GtkCellRenderer *cell,
1789 GtkTreeModel *model,
1790 GtkTreeIter *iter,
1791 gpointer data );
1792}
1793
1794
1795static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *column,
1796 GtkCellRenderer *renderer,
1797 GtkTreeModel *model,
1798 GtkTreeIter *iter,
1799 gpointer data )
1800{
1801 g_return_if_fail (GTK_IS_WX_TREE_MODEL (model));
1802 GtkWxTreeModel *tree_model = (GtkWxTreeModel *) model;
1803
1804 wxDataViewRenderer *cell = (wxDataViewRenderer*) data;
1805
1806 wxDataViewItem item( (void*) iter->user_data );
1807
1808 wxVariant value;
1809 tree_model->internal->GetDataViewModel()->GetValue( value, item, cell->GetOwner()->GetModelColumn() );
1810
1811 if (value.GetType() != cell->GetVariantType())
1812 wxLogError( wxT("Wrong type, required: %s but: %s"),
1813 value.GetType().c_str(),
1814 cell->GetVariantType().c_str() );
1815
1816 cell->SetValue( value );
1817
1818#if 0
1819 wxListItemAttr attr;
1820 tree_model->model->GetAttr( attr, cell->GetOwner()->GetModelColumn(), model_row );
1821
1822 if (attr.HasBackgroundColour())
1823 {
1824 wxColour colour = attr.GetBackgroundColour();
1825 const GdkColor * const gcol = colour.GetColor();
1826
1827 GValue gvalue = { 0, };
1828 g_value_init( &gvalue, GDK_TYPE_COLOR );
1829 g_value_set_boxed( &gvalue, gcol );
1830 g_object_set_property( G_OBJECT(renderer), "cell-background_gdk", &gvalue );
1831 g_value_unset( &gvalue );
1832 }
1833 else
1834 {
1835 GValue gvalue = { 0, };
1836 g_value_init( &gvalue, G_TYPE_BOOLEAN );
1837 g_value_set_boolean( &gvalue, FALSE );
1838 g_object_set_property( G_OBJECT(renderer), "cell-background-set", &gvalue );
1839 g_value_unset( &gvalue );
1840 }
1841#endif
1842
1843}
1844
1845IMPLEMENT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
1846
1847wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell,
1848 unsigned int model_column, int width,
1849 wxAlignment align, int flags ) :
1850 wxDataViewColumnBase( title, cell, model_column, width, align, flags )
1851{
1852 Init( align, flags, width );
1853
1854 gtk_tree_view_column_set_clickable( GTK_TREE_VIEW_COLUMN(m_column), TRUE );
1855 SetTitle( title );
1856}
1857
1858wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell,
1859 unsigned int model_column, int width,
1860 wxAlignment align, int flags ) :
1861 wxDataViewColumnBase( bitmap, cell, model_column, width, align, flags )
1862{
1863 Init( align, flags, width );
1864
1865 SetBitmap( bitmap );
1866}
1867
1868void wxDataViewColumn::Init(wxAlignment align, int flags, int width)
1869{
1870 m_isConnected = false;
1871
1872 GtkCellRenderer *renderer = (GtkCellRenderer *) GetRenderer()->GetGtkHandle();
1873 GtkTreeViewColumn *column = gtk_tree_view_column_new();
1874 m_column = (GtkWidget*) column;
1875
1876 SetFlags( flags );
1877 SetAlignment( align );
1878
1879 // NOTE: we prefer not to call SetMinWidth(wxDVC_DEFAULT_MINWIDTH);
1880 // as GTK+ is smart and unless explicitely told, will set the minimal
1881 // width to the title's lenght, which is a better default
1882
1883 // the GTK_TREE_VIEW_COLUMN_FIXED is required by the "fixed height" mode
1884 // that we use for the wxDataViewCtrl
1885 gtk_tree_view_column_set_fixed_width( column, width < 0 ? wxDVC_DEFAULT_WIDTH : width );
1886 gtk_tree_view_column_set_sizing( column, GTK_TREE_VIEW_COLUMN_FIXED );
1887
1888 gtk_tree_view_column_pack_end( column, renderer, TRUE );
1889
1890 gtk_tree_view_column_set_cell_data_func( column, renderer,
1891 wxGtkTreeCellDataFunc, (gpointer) GetRenderer(), NULL );
1892}
1893
1894wxDataViewColumn::~wxDataViewColumn()
1895{
1896}
1897
1898void wxDataViewColumn::OnInternalIdle()
1899{
1900 if (m_isConnected)
1901 return;
1902
1903 if (GTK_WIDGET_REALIZED(GetOwner()->m_treeview))
1904 {
1905 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1906 if (column->button)
1907 {
1908 g_signal_connect(column->button, "button_press_event",
1909 G_CALLBACK (gtk_dataview_header_button_press_callback), this);
1910
1911 m_isConnected = true;
1912 }
1913 }
1914}
1915
1916void wxDataViewColumn::SetOwner( wxDataViewCtrl *owner )
1917{
1918 wxDataViewColumnBase::SetOwner( owner );
1919
1920 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1921
1922 gtk_tree_view_column_set_title( column, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
1923}
1924
1925void wxDataViewColumn::SetTitle( const wxString &title )
1926{
1927 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1928
1929 if (m_isConnected)
1930 {
1931 // disconnect before column->button gets recreated
1932 g_signal_handlers_disconnect_by_func( column->button,
1933 (GtkWidget*) gtk_dataview_header_button_press_callback, this);
1934
1935 m_isConnected = false;
1936 }
1937
1938 // FIXME: can it really happen that we don't have the owner here??
1939 wxDataViewCtrl *ctrl = GetOwner();
1940 gtk_tree_view_column_set_title( column, ctrl ? wxGTK_CONV_FONT(title, ctrl->GetFont())
1941 : wxGTK_CONV_SYS(title) );
1942
1943 gtk_tree_view_column_set_widget( column, NULL );
1944}
1945
1946wxString wxDataViewColumn::GetTitle() const
1947{
1948 const gchar *str = gtk_tree_view_column_get_title( GTK_TREE_VIEW_COLUMN(m_column) );
1949 return wxConvFileName->cMB2WX(str);
1950}
1951
1952void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
1953{
1954 wxDataViewColumnBase::SetBitmap( bitmap );
1955
1956 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1957 if (bitmap.Ok())
1958 {
1959 GtkImage *gtk_image = GTK_IMAGE( gtk_image_new() );
1960
1961 GdkBitmap *mask = (GdkBitmap *) NULL;
1962 if (bitmap.GetMask())
1963 mask = bitmap.GetMask()->GetBitmap();
1964
1965 if (bitmap.HasPixbuf())
1966 {
1967 gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image),
1968 bitmap.GetPixbuf());
1969 }
1970 else
1971 {
1972 gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image),
1973 bitmap.GetPixmap(), mask);
1974 }
1975 gtk_widget_show( GTK_WIDGET(gtk_image) );
1976
1977 gtk_tree_view_column_set_widget( column, GTK_WIDGET(gtk_image) );
1978 }
1979 else
1980 {
1981 gtk_tree_view_column_set_widget( column, NULL );
1982 }
1983}
1984
1985void wxDataViewColumn::SetHidden( bool hidden )
1986{
1987 gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column), !hidden );
1988}
1989
1990void wxDataViewColumn::SetResizeable( bool resizeable )
1991{
1992 gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizeable );
1993}
1994
1995void wxDataViewColumn::SetAlignment( wxAlignment align )
1996{
1997 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1998
1999 gfloat xalign = 0.0;
2000 if (align == wxALIGN_RIGHT)
2001 xalign = 1.0;
2002 if (align == wxALIGN_CENTER_HORIZONTAL ||
2003 align == wxALIGN_CENTER)
2004 xalign = 0.5;
2005
2006 gtk_tree_view_column_set_alignment( column, xalign );
2007}
2008
2009wxAlignment wxDataViewColumn::GetAlignment() const
2010{
2011 gfloat xalign = gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column) );
2012
2013 if (xalign == 1.0)
2014 return wxALIGN_RIGHT;
2015 if (xalign == 0.5)
2016 return wxALIGN_CENTER_HORIZONTAL;
2017
2018 return wxALIGN_LEFT;
2019}
2020
2021void wxDataViewColumn::SetSortable( bool sortable )
2022{
2023 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2024
2025 if (sortable)
2026 gtk_tree_view_column_set_sort_column_id( column, GetModelColumn() );
2027 else
2028 gtk_tree_view_column_set_sort_column_id( column, -1 );
2029}
2030
2031bool wxDataViewColumn::IsSortable() const
2032{
2033 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2034 return (gtk_tree_view_column_get_sort_column_id( column ) != -1);
2035}
2036
2037bool wxDataViewColumn::IsResizeable() const
2038{
2039 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2040 return gtk_tree_view_column_get_resizable( column );
2041}
2042
2043bool wxDataViewColumn::IsHidden() const
2044{
2045 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2046 return !gtk_tree_view_column_get_visible( column );
2047}
2048
2049void wxDataViewColumn::SetSortOrder( bool ascending )
2050{
2051 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2052
2053 if (ascending)
2054 gtk_tree_view_column_set_sort_order( column, GTK_SORT_ASCENDING );
2055 else
2056 gtk_tree_view_column_set_sort_order( column, GTK_SORT_DESCENDING );
2057}
2058
2059bool wxDataViewColumn::IsSortOrderAscending() const
2060{
2061 GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2062
2063 return (gtk_tree_view_column_get_sort_order( column ) != GTK_SORT_DESCENDING);
2064}
2065
2066void wxDataViewColumn::SetMinWidth( int width )
2067{
2068 gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column), width );
2069}
2070
2071int wxDataViewColumn::GetMinWidth() const
2072{
2073 return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column) );
2074}
2075
2076int wxDataViewColumn::GetWidth() const
2077{
2078 return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column) );
2079}
2080
2081void wxDataViewColumn::SetWidth( int width )
2082{
2083 gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column), width );
2084}
2085
2086
2087//-----------------------------------------------------------------------------
2088// wxGtkTreeModelNode
2089//-----------------------------------------------------------------------------
2090
2091void wxGtkTreeModelNode::Resort()
2092{
2093 size_t count = m_children->GetCount();
2094 if (count == 0)
2095 return;
2096
2097 if (count == 1)
2098 {
2099 wxGtkTreeModelNode *node = m_children->Item( 0 );
2100 node->Resort();
2101 return;
2102 }
2103
2104 wxGtkTreeModelNodes *new_array = new wxGtkTreeModelNodes( wxGtkTreeModelNodeCmp );
2105
2106 size_t pos;
2107
2108 for (pos = 0; pos < count; pos++)
2109 new_array->Add( m_children->Item( pos ) );
2110
2111
2112 gint *new_order = new gint[count];
2113
2114 for (pos = 0; pos < count; pos++)
2115 {
2116 wxGtkTreeModelNode *node = new_array->Item( pos );
2117 size_t old_pos;
2118 for (old_pos = 0; old_pos < count; old_pos++)
2119 {
2120 if (node == m_children->Item(old_pos))
2121 {
2122 new_order[pos] = old_pos;
2123 break;
2124 }
2125 }
2126 }
2127
2128// for (pos = 0; pos < count; pos++)
2129// m_children->Clear();
2130 delete m_children;
2131
2132 m_children = new_array;
2133
2134 GtkTreeModel *gtk_tree_model = GTK_TREE_MODEL( m_internal->GetGtkModel() );
2135
2136 GtkTreeIter iter;
2137 iter.user_data = (gpointer) GetItem().GetID();
2138 iter.stamp = m_internal->GetGtkModel()->stamp;
2139 GtkTreePath *path = wxgtk_tree_model_get_path( gtk_tree_model, &iter );
2140
2141 gtk_tree_model_rows_reordered( gtk_tree_model, path, &iter, new_order );
2142
2143 gtk_tree_path_free (path);
2144
2145 delete [] new_order;
2146
2147 for (pos = 0; pos < count; pos++)
2148 {
2149 wxGtkTreeModelNode *node = m_children->Item( pos );
2150 node->Resort();
2151 }
2152}
2153
2154//-----------------------------------------------------------------------------
2155// wxDataViewCtrlInternal
2156//-----------------------------------------------------------------------------
2157
2158wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl *owner,
2159 wxDataViewModel *wx_model, GtkWxTreeModel *gtk_model )
2160{
2161 m_owner = owner;
2162 m_wx_model = wx_model;
2163 m_gtk_model = gtk_model;
2164 m_root = NULL;
2165 InitTree();
2166}
2167
2168wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
2169{
2170 g_object_unref( m_gtk_model );
2171}
2172
2173void wxDataViewCtrlInternal::InitTree()
2174{
2175 wxDataViewItem item;
2176 m_root = new wxGtkTreeModelNode( NULL, item, this );
2177
2178 BuildBranch( m_root );
2179}
2180
2181void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode *node )
2182{
2183 if (node->GetChildCount() == 0)
2184 {
2185 wxDataViewItem child = m_wx_model->GetFirstChild( node->GetItem() );
2186 while (child.IsOk())
2187 {
2188 node->Add( new wxGtkTreeModelNode( node, child, this ) );
2189 child = m_wx_model->GetNextSibling( child );
2190 }
2191 }
2192}
2193
2194void wxDataViewCtrlInternal::Resort()
2195{
2196 m_root->Resort();
2197}
2198
2199bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
2200{
2201 wxGtkTreeModelNode *parent_node = FindNode( parent );
2202 parent_node->Add( new wxGtkTreeModelNode( parent_node, item, this ) );
2203 return true;
2204}
2205
2206bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem &item )
2207{
2208 wxGtkTreeModelNode *node = FindNode( item );
2209 wxGtkTreeModelNode *parent = node->GetParent();
2210 size_t pos;
2211 for (pos = 0; pos < parent->GetChildren().GetCount(); pos++)
2212 {
2213 if (node == parent->GetChildren().Item( pos ))
2214 {
2215 parent->GetChildren().RemoveAt( pos );
2216 continue;
2217 }
2218 }
2219
2220 return true;
2221}
2222
2223gboolean wxDataViewCtrlInternal::get_iter( GtkTreeIter *iter, GtkTreePath *path )
2224{
2225 int depth = gtk_tree_path_get_depth( path );
2226
2227 wxGtkTreeModelNode *node = m_root;
2228
2229 int i;
2230 for (i = 0; i < depth; i++)
2231 {
2232 BuildBranch( node );
2233
2234 gint pos = gtk_tree_path_get_indices (path)[i];
2235 if (pos < 0) return FALSE;
2236 if ((size_t)pos >= node->GetChildCount()) return FALSE;
2237
2238 node = node->GetChildren().Item( (size_t) pos );
2239 }
2240
2241 iter->stamp = m_gtk_model->stamp;
2242 iter->user_data = (gpointer) node->GetItem().GetID();
2243
2244 return TRUE;
2245}
2246
2247GtkTreePath *wxDataViewCtrlInternal::get_path( GtkTreeIter *iter )
2248{
2249 GtkTreePath *retval = gtk_tree_path_new ();
2250
2251 wxGtkTreeModelNode *node = FindNode( iter );
2252 while (node->GetParent())
2253 {
2254 wxGtkTreeModelNode *parent = node->GetParent();
2255 int pos = parent->GetChildren().Index( node );
2256
2257 gtk_tree_path_prepend_index( retval, pos );
2258
2259 node = parent;
2260 }
2261
2262 return retval;
2263}
2264
2265GtkTreePath *wxDataViewCtrlInternal::get_path_safe( GtkTreeIter *iter )
2266{
2267 GtkTreePath *retval = gtk_tree_path_new ();
2268
2269 wxGtkTreeModelNode *node = FindNode( iter );
2270 while (node->GetParent())
2271 {
2272 wxGtkTreeModelNode *parent = node->GetParent();
2273 size_t pos;
2274 for (pos = 0; pos < parent->GetChildren().GetCount(); pos++)
2275 {
2276 if (node == parent->GetChildren().Item( pos ))
2277 {
2278 gtk_tree_path_prepend_index( retval, (int) pos );
2279 continue;
2280 }
2281 }
2282
2283 node = parent;
2284 }
2285
2286 return retval;
2287}
2288
2289gboolean wxDataViewCtrlInternal::iter_next( GtkTreeIter *iter )
2290{
2291 wxGtkTreeModelNode *node = FindNode( iter );
2292 wxGtkTreeModelNode *parent = node->GetParent();
2293 unsigned int pos = parent->GetChildren().Index( node );
2294
2295 if (pos == parent->GetChildren().GetCount()-1)
2296 return FALSE;
2297
2298 node = parent->GetChildren().Item( pos+1 );
2299
2300 iter->stamp = m_gtk_model->stamp;
2301 iter->user_data = (gpointer) node->GetItem().GetID();
2302
2303 return TRUE;
2304}
2305
2306gboolean wxDataViewCtrlInternal::iter_children( GtkTreeIter *iter, GtkTreeIter *parent )
2307{
2308 wxDataViewItem item( (void*) parent->user_data );
2309
2310 if (!m_wx_model->HasChildren( item ))
2311 return FALSE;
2312
2313 wxGtkTreeModelNode *parent_node = FindNode( parent );
2314 BuildBranch( parent_node );
2315
2316 wxGtkTreeModelNode *first_child_node = parent_node->GetChildren().Item( 0 );
2317
2318 iter->stamp = m_gtk_model->stamp;
2319 iter->user_data = (gpointer) first_child_node->GetItem().GetID();
2320
2321 return TRUE;
2322}
2323
2324gboolean wxDataViewCtrlInternal::iter_has_child( GtkTreeIter *iter )
2325{
2326 wxDataViewItem item( (void*) iter->user_data );
2327
2328 return m_wx_model->HasChildren( item );
2329}
2330
2331gint wxDataViewCtrlInternal::iter_n_children( GtkTreeIter *iter )
2332{
2333 wxDataViewItem item( (void*) iter->user_data );
2334
2335 if (!m_wx_model->HasChildren( item ))
2336 return 0;
2337
2338 wxGtkTreeModelNode *parent_node = FindNode( iter );
2339 BuildBranch( parent_node );
2340
2341 // wxPrintf( "iter_n_children %d\n", parent_node->GetChildCount() );
2342
2343 return parent_node->GetChildCount();
2344}
2345
2346gboolean wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n )
2347{
2348 void* id = NULL;
2349 if (parent) id = (void*) parent->user_data;
2350 wxDataViewItem item( id );
2351
2352 if (!m_wx_model->HasChildren( item ))
2353 return FALSE;
2354
2355 wxGtkTreeModelNode *parent_node = FindNode( parent );
2356 BuildBranch( parent_node );
2357
2358 wxGtkTreeModelNode *child_node = parent_node->GetChildren().Item( (size_t) n );
2359 if (!child_node)
2360 return FALSE;
2361
2362 // wxPrintf( "iter_nth_child %d\n", n );
2363
2364 iter->stamp = m_gtk_model->stamp;
2365 iter->user_data = (gpointer) child_node->GetItem().GetID();
2366
2367 return TRUE;
2368}
2369
2370gboolean wxDataViewCtrlInternal::iter_parent( GtkTreeIter *iter, GtkTreeIter *child )
2371{
2372 wxDataViewItem item( (void*) child->user_data );
2373
2374 wxGtkTreeModelNode *node = FindNode( child );
2375 node = node->GetParent();
2376 if (!node)
2377 return FALSE;
2378
2379 iter->stamp = m_gtk_model->stamp;
2380 iter->user_data = (gpointer) node->GetItem().GetID();
2381
2382 return TRUE;
2383}
2384
2385static wxGtkTreeModelNode*
2386wxDataViewCtrlInternal_FindNode( wxGtkTreeModelNode *node, const wxDataViewItem &item )
2387{
2388 if (!node) return NULL;
2389
2390 size_t count = node->GetChildCount();
2391 size_t i;
2392 for (i = 0; i < count; i++)
2393 {
2394 wxGtkTreeModelNode *child = node->GetChildren().Item( i );
2395 if (child->GetItem().GetID() == item.GetID())
2396 {
2397 // wxPrintf( "leave findnode at %d\n", i );
2398 return child;
2399 }
2400
2401 wxGtkTreeModelNode *node2 = wxDataViewCtrlInternal_FindNode( child, item );
2402 if (node2)
2403 {
2404 // wxPrintf( "branch findnode at %d\n", i );
2405 return node2;
2406 }
2407 }
2408
2409 return NULL;
2410}
2411
2412wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( GtkTreeIter *iter )
2413{
2414 if (!iter)
2415 return m_root;
2416
2417 wxDataViewItem item( (void*) iter->user_data );
2418 if (!item.IsOk())
2419 return m_root;
2420
2421 wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_root, item );
2422
2423 if (!result)
2424 {
2425 wxPrintf( "Not found %d\n", (int) iter->user_data );
2426 char *crash = NULL;
2427 *crash = 0;
2428 }
2429
2430 return result;
2431}
2432
2433wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( const wxDataViewItem &item )
2434{
2435 if (!item.IsOk())
2436 return m_root;
2437
2438 wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_root, item );
2439
2440 if (!result)
2441 {
2442 wxPrintf( "Not found %d\n", (int) item.GetID() );
2443 char *crash = NULL;
2444 *crash = 0;
2445 }
2446
2447 return result;
2448}
2449
2450//-----------------------------------------------------------------------------
2451// wxDataViewCtrl signal callbacks
2452//-----------------------------------------------------------------------------
2453
2454static void
2455wxdataview_selection_changed_callback( GtkTreeSelection* selection, wxDataViewCtrl *dv )
2456{
2457 if (!GTK_WIDGET_REALIZED(dv->m_widget))
2458 return;
2459
2460 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_SELECTED, dv->GetId() );
2461 // TODO: item
2462 event.SetModel( dv->GetModel() );
2463 dv->GetEventHandler()->ProcessEvent( event );
2464}
2465
2466static void
2467wxdataview_row_activated_callback( GtkTreeView* treeview, GtkTreePath *path,
2468 GtkTreeViewColumn *column, wxDataViewCtrl *dv )
2469{
2470 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, dv->GetId() );
2471
2472 GtkTreeIter iter;
2473 dv->GtkGetInternal()->get_iter( &iter, path );
2474 wxDataViewItem item( (void*) iter.user_data );;
2475 event.SetItem( item );
2476 event.SetModel( dv->GetModel() );
2477 dv->GetEventHandler()->ProcessEvent( event );
2478}
2479
2480//-----------------------------------------------------------------------------
2481// wxDataViewCtrl
2482//-----------------------------------------------------------------------------
2483
2484//-----------------------------------------------------------------------------
2485// InsertChild for wxDataViewCtrl
2486//-----------------------------------------------------------------------------
2487
2488static void wxInsertChildInDataViewCtrl( wxWindowGTK* parent, wxWindowGTK* child )
2489{
2490 wxDataViewCtrl * dvc = (wxDataViewCtrl*) parent;
2491 GtkWidget *treeview = dvc->GtkGetTreeView();
2492
2493 // Insert widget in GtkTreeView
2494 if (GTK_WIDGET_REALIZED(treeview))
2495 gtk_widget_set_parent_window( child->m_widget,
2496 gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview) ) );
2497 gtk_widget_set_parent( child->m_widget, treeview );
2498}
2499
2500static
2501void gtk_dataviewctrl_size_callback( GtkWidget *WXUNUSED(widget),
2502 GtkAllocation *alloc,
2503 wxDataViewCtrl *win )
2504{
2505
2506 wxWindowList::Node *node = win->GetChildren().GetFirst();
2507 while (node)
2508 {
2509 wxWindow *child = node->GetData();
2510
2511 GtkRequisition req;
2512 gtk_widget_size_request( child->m_widget, &req );
2513
2514 GtkAllocation alloc;
2515 alloc.x = child->m_x;
2516 alloc.y = child->m_y;
2517 alloc.width = child->m_width;
2518 alloc.height = child->m_height;
2519 gtk_widget_size_allocate( child->m_widget, &alloc );
2520
2521 node = node->GetNext();
2522 }
2523}
2524
2525
2526
2527IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
2528
2529wxDataViewCtrl::~wxDataViewCtrl()
2530{
2531 if (m_notifier)
2532 GetModel()->RemoveNotifier( m_notifier );
2533
2534 // remove the model from the GtkTreeView before it gets destroyed by the
2535 // wxDataViewCtrlBase's dtor
2536 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview), NULL );
2537
2538 delete m_internal;
2539}
2540
2541void wxDataViewCtrl::Init()
2542{
2543 m_notifier = NULL;
2544}
2545
2546bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
2547 const wxPoint& pos, const wxSize& size,
2548 long style, const wxValidator& validator )
2549{
2550 Init();
2551
2552 if (!PreCreation( parent, pos, size ) ||
2553 !CreateBase( parent, id, pos, size, style, validator ))
2554 {
2555 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
2556 return false;
2557 }
2558
2559 m_insertCallback = wxInsertChildInDataViewCtrl;
2560
2561 m_widget = gtk_scrolled_window_new (NULL, NULL);
2562
2563 GtkScrolledWindowSetBorder(m_widget, style);
2564
2565 m_treeview = gtk_tree_view_new();
2566 gtk_container_add (GTK_CONTAINER (m_widget), m_treeview);
2567
2568 g_signal_connect (m_treeview, "size_allocate",
2569 G_CALLBACK (gtk_dataviewctrl_size_callback), this);
2570
2571#ifdef __WXGTK26__
2572 if (!gtk_check_version(2,6,0))
2573 gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), TRUE );
2574#endif
2575
2576 if (style & wxDV_MULTIPLE)
2577 {
2578 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2579 gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
2580 }
2581
2582 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview), (style & wxDV_NO_HEADER) == 0 );
2583
2584#ifdef __WXGTK210__
2585 if (!gtk_check_version(2,10,0))
2586 {
2587 GtkTreeViewGridLines grid = GTK_TREE_VIEW_GRID_LINES_NONE;
2588
2589 if ((style & wxDV_HORIZ_RULES) != 0 &&
2590 (style & wxDV_VERT_RULES) != 0)
2591 grid = GTK_TREE_VIEW_GRID_LINES_BOTH;
2592 else if (style & wxDV_VERT_RULES)
2593 grid = GTK_TREE_VIEW_GRID_LINES_VERTICAL;
2594 else if (style & wxDV_HORIZ_RULES)
2595 grid = GTK_TREE_VIEW_GRID_LINES_HORIZONTAL;
2596
2597 gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview), grid );
2598 }
2599 else
2600#endif
2601 {
2602 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview), (style & wxDV_HORIZ_RULES) != 0 );
2603 }
2604
2605 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget),
2606 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
2607 gtk_widget_show (m_treeview);
2608
2609 m_parent->DoAddChild( this );
2610
2611 PostCreation(size);
2612
2613 GtkEnableSelectionEvents();
2614
2615 g_signal_connect_after (m_treeview, "row_activated",
2616 G_CALLBACK (wxdataview_row_activated_callback), this);
2617
2618 return true;
2619}
2620
2621void wxDataViewCtrl::OnInternalIdle()
2622{
2623 wxWindow::OnInternalIdle();
2624
2625 unsigned int cols = GetColumnCount();
2626 unsigned int i;
2627 for (i = 0; i < cols; i++)
2628 {
2629 wxDataViewColumn *col = GetColumn( i );
2630 col->OnInternalIdle();
2631 }
2632}
2633
2634bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
2635{
2636 if (!wxDataViewCtrlBase::AssociateModel( model ))
2637 return false;
2638
2639 GtkWxTreeModel *gtk_model = wxgtk_tree_model_new();
2640 m_internal = new wxDataViewCtrlInternal( this, model, gtk_model );
2641 gtk_model->internal = m_internal;
2642
2643 m_notifier = new wxGtkDataViewModelNotifier( gtk_model, model, this );
2644
2645 model->AddNotifier( m_notifier );
2646
2647 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview), GTK_TREE_MODEL(gtk_model) );
2648
2649 // unref in wxDataViewCtrlInternal
2650 // g_object_unref( gtk_model );
2651
2652 return true;
2653}
2654
2655bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
2656{
2657 if (!wxDataViewCtrlBase::AppendColumn(col))
2658 return false;
2659
2660 GtkTreeViewColumn *column = (GtkTreeViewColumn *)col->GetGtkHandle();
2661
2662 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview), column );
2663
2664 return true;
2665}
2666
2667wxDataViewItem wxDataViewCtrl::GetSelection()
2668{
2669 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2670
2671 if (m_windowStyle & wxDV_MULTIPLE)
2672 {
2673 }
2674 else
2675 {
2676 GtkTreeIter iter;
2677 if (gtk_tree_selection_get_selected( selection, NULL, &iter ))
2678 {
2679 wxDataViewItem item( (void*) iter.user_data );
2680 return item;
2681 }
2682 }
2683
2684 return wxDataViewItem(0);
2685}
2686
2687void wxDataViewCtrl::DoSetExpanderColumn()
2688{
2689}
2690
2691void wxDataViewCtrl::DoSetIndent()
2692{
2693}
2694
2695void wxDataViewCtrl::GtkDisableSelectionEvents()
2696{
2697 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2698 g_signal_connect_after (selection, "changed",
2699 G_CALLBACK (wxdataview_selection_changed_callback), this);
2700}
2701
2702void wxDataViewCtrl::GtkEnableSelectionEvents()
2703{
2704 GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2705 g_signal_handlers_disconnect_by_func( selection,
2706 (gpointer) (wxdataview_selection_changed_callback), this);
2707}
2708
2709// static
2710wxVisualAttributes
2711wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
2712{
2713 return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new);
2714}
2715
2716
2717#endif
2718 // !wxUSE_GENERICDATAVIEWCTRL
2719
2720#endif
2721 // wxUSE_DATAVIEWCTRL
wxWidgets (Impactor)