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