]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/dataview.cpp
projects / wxWidgets.git / blob
? search:


f55b65de94d3f96de1234a61b5eb63a365e5dfdf
[wxWidgets.git] / src / gtk / dataview.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 #include "wx/defs.h"
14
15 #if wxUSE_DATAVIEWCTRL
16
17 #include "wx/dataview.h"
18 #include "wx/stockitem.h"
19 #include "wx/dcclient.h"
20
21 #include "wx/gtk/private.h"
22 #include "wx/gtk/win_gtk.h"
23
24 #include <gobject/gvaluecollector.h>
25 #include <gtk/gtktreemodel.h>
26 #include <gtk/gtktreednd.h>
27
28 #include <gdk/gdkkeysyms.h>
29
30 //-----------------------------------------------------------------------------
31 // classes
32 //-----------------------------------------------------------------------------
33
34 class wxDataViewCtrl;
35
36 //-----------------------------------------------------------------------------
37 // idle system
38 //-----------------------------------------------------------------------------
39
40 extern void wxapp_install_idle_handler();
41 extern bool g_isIdle;
42
43 //-----------------------------------------------------------------------------
44 // data
45 //-----------------------------------------------------------------------------
46
47 extern bool g_blockEventsOnDrag;
48
49 //-----------------------------------------------------------------------------
50 // define new GTK+ class wxGtkListStore
51 //-----------------------------------------------------------------------------
52
53 extern "C" {
54
55 #define GTK_TYPE_WX_LIST_STORE (gtk_wx_list_store_get_type ())
56 #define GTK_WX_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_LIST_STORE, GtkWxListStore))
57 #define GTK_WX_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_LIST_STORE, GtkWxListStoreClass))
58 #define GTK_IS_WX_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_LIST_STORE))
59 #define GTK_IS_WX_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_LIST_STORE))
60 #define GTK_WX_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_LIST_STORE, GtkWxListStoreClass))
61
62 GType gtk_wx_list_store_get_type (void);
63
64 typedef struct _GtkWxListStore GtkWxListStore;
65 typedef struct _GtkWxListStoreClass GtkWxListStoreClass;
66
67 struct _GtkWxListStore
68 {
69 GObject parent;
70
71 /*< private >*/
72 gint stamp;
73 wxDataViewListModel *model;
74 };
75
76 struct _GtkWxListStoreClass
77 {
78 GObjectClass list_parent_class;
79
80 };
81
82 static GtkWxListStore *wxgtk_list_store_new (void);
83 static void wxgtk_list_store_init (GtkWxListStore *list_store);
84 static void wxgtk_list_store_class_init (GtkWxListStoreClass *klass);
85 static void wxgtk_list_store_tree_model_init (GtkTreeModelIface *iface);
86 static void wxgtk_list_store_finalize (GObject *object);
87 static GtkTreeModelFlags wxgtk_list_store_get_flags (GtkTreeModel *tree_model);
88 static gint wxgtk_list_store_get_n_columns (GtkTreeModel *tree_model);
89 static GType wxgtk_list_store_get_column_type (GtkTreeModel *tree_model,
90 gint index);
91 static gboolean wxgtk_list_store_get_iter (GtkTreeModel *tree_model,
92 GtkTreeIter *iter,
93 GtkTreePath *path);
94 static GtkTreePath *wxgtk_list_store_get_path (GtkTreeModel *tree_model,
95 GtkTreeIter *iter);
96 static void wxgtk_list_store_get_value (GtkTreeModel *tree_model,
97 GtkTreeIter *iter,
98 gint column,
99 GValue *value);
100 static gboolean wxgtk_list_store_iter_next (GtkTreeModel *tree_model,
101 GtkTreeIter *iter);
102 static gboolean wxgtk_list_store_iter_children (GtkTreeModel *tree_model,
103 GtkTreeIter *iter,
104 GtkTreeIter *parent);
105 static gboolean wxgtk_list_store_iter_has_child (GtkTreeModel *tree_model,
106 GtkTreeIter *iter);
107 static gint wxgtk_list_store_iter_n_children (GtkTreeModel *tree_model,
108 GtkTreeIter *iter);
109 static gboolean wxgtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
110 GtkTreeIter *iter,
111 GtkTreeIter *parent,
112 gint n);
113 static gboolean wxgtk_list_store_iter_parent (GtkTreeModel *tree_model,
114 GtkTreeIter *iter,
115 GtkTreeIter *child);
116
117 static GObjectClass *list_parent_class = NULL;
118
119 GType
120 gtk_wx_list_store_get_type (void)
121 {
122 static GType list_store_type = 0;
123
124 if (!list_store_type)
125 {
126 static const GTypeInfo list_store_info =
127 {
128 sizeof (GtkWxListStoreClass),
129 NULL, /* base_init */
130 NULL, /* base_finalize */
131 (GClassInitFunc) wxgtk_list_store_class_init,
132 NULL, /* class_finalize */
133 NULL, /* class_data */
134 sizeof (GtkWxListStore),
135 0,
136 (GInstanceInitFunc) wxgtk_list_store_init,
137 };
138
139 static const GInterfaceInfo tree_model_info =
140 {
141 (GInterfaceInitFunc) wxgtk_list_store_tree_model_init,
142 NULL,
143 NULL
144 };
145
146 list_store_type = g_type_register_static (G_TYPE_OBJECT, "GtkWxListStore",
147 &list_store_info, (GTypeFlags)0 );
148
149 g_type_add_interface_static (list_store_type,
150 GTK_TYPE_TREE_MODEL,
151 &tree_model_info);
152 }
153
154 return list_store_type;
155 }
156
157 static GtkWxListStore *
158 wxgtk_list_store_new(void)
159 {
160 GtkWxListStore *retval = (GtkWxListStore *) g_object_new (GTK_TYPE_WX_LIST_STORE, NULL);
161 return retval;
162 }
163
164 static void
165 wxgtk_list_store_class_init (GtkWxListStoreClass *klass)
166 {
167 list_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
168 GObjectClass *object_class = (GObjectClass*) klass;
169 object_class->finalize = wxgtk_list_store_finalize;
170 }
171
172 static void
173 wxgtk_list_store_tree_model_init (GtkTreeModelIface *iface)
174 {
175 iface->get_flags = wxgtk_list_store_get_flags;
176 iface->get_n_columns = wxgtk_list_store_get_n_columns;
177 iface->get_column_type = wxgtk_list_store_get_column_type;
178 iface->get_iter = wxgtk_list_store_get_iter;
179 iface->get_path = wxgtk_list_store_get_path;
180 iface->get_value = wxgtk_list_store_get_value;
181 iface->iter_next = wxgtk_list_store_iter_next;
182 iface->iter_children = wxgtk_list_store_iter_children;
183 iface->iter_has_child = wxgtk_list_store_iter_has_child;
184 iface->iter_n_children = wxgtk_list_store_iter_n_children;
185 iface->iter_nth_child = wxgtk_list_store_iter_nth_child;
186 iface->iter_parent = wxgtk_list_store_iter_parent;
187 }
188
189 static void
190 wxgtk_list_store_init (GtkWxListStore *list_store)
191 {
192 list_store->model = NULL;
193 list_store->stamp = g_random_int();
194 }
195
196 static void
197 wxgtk_list_store_finalize (GObject *object)
198 {
199 /* GtkWxListStore *list_store = GTK_WX_LIST_STORE (object); */
200
201 /* we need to sort out, which class deletes what */
202 /* delete list_store->model; */
203
204 /* must chain up */
205 (* list_parent_class->finalize) (object);
206 }
207
208 } // extern "C"
209
210 //-----------------------------------------------------------------------------
211 // implement callbacks from wxGtkListStore class by letting
212 // them call the methods of wxWidgets' wxDataViewListModel
213 //-----------------------------------------------------------------------------
214
215 static GtkTreeModelFlags
216 wxgtk_list_store_get_flags (GtkTreeModel *tree_model)
217 {
218 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), (GtkTreeModelFlags)0 );
219
220 // GTK+ list store uses a linked list for storing the
221 // items and a pointer to a child is used as the member
222 // field of a GtkTreeIter. This means that the iter is
223 // valid in the GtkListStore as long as the child exists.
224 // We use the index of the row and since the index of a
225 // specific row will change if a row above is deleted,
226 // the iter does not persist
227 return /* GTK_TREE_MODEL_ITERS_PERSIST | */ GTK_TREE_MODEL_LIST_ONLY;
228 }
229
230 static gint
231 wxgtk_list_store_get_n_columns (GtkTreeModel *tree_model)
232 {
233 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
234 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), 0);
235
236 return list_store->model->GetNumberOfCols();
237 }
238
239 static GType
240 wxgtk_list_store_get_column_type (GtkTreeModel *tree_model,
241 gint index)
242 {
243 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
244 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), G_TYPE_INVALID);
245
246 GType gtype = G_TYPE_INVALID;
247
248 wxString wxtype = list_store->model->GetColType( (size_t) index );
249
250 if (wxtype == wxT("string"))
251 gtype = G_TYPE_STRING;
252
253 return gtype;
254 }
255
256 static gboolean
257 wxgtk_list_store_get_iter (GtkTreeModel *tree_model,
258 GtkTreeIter *iter,
259 GtkTreePath *path)
260 {
261 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
262 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
263 g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
264
265 size_t i = (size_t)gtk_tree_path_get_indices (path)[0];
266
267 if (i >= list_store->model->GetNumberOfRows())
268 return FALSE;
269
270 iter->stamp = list_store->stamp;
271 // user_data is just the index
272 iter->user_data = (gpointer) i;
273
274 return TRUE;
275 }
276
277 static GtkTreePath *
278 wxgtk_list_store_get_path (GtkTreeModel *tree_model,
279 GtkTreeIter *iter)
280 {
281 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), NULL);
282 g_return_val_if_fail (iter->stamp == GTK_WX_LIST_STORE (tree_model)->stamp, NULL);
283
284 GtkTreePath *retval = gtk_tree_path_new ();
285 // user_data is just the index
286 int i = (int) iter->user_data;
287 gtk_tree_path_append_index (retval, i);
288 return retval;
289 }
290
291 static void
292 wxgtk_list_store_get_value (GtkTreeModel *tree_model,
293 GtkTreeIter *iter,
294 gint column,
295 GValue *value)
296 {
297 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
298 g_return_if_fail (GTK_IS_WX_LIST_STORE (tree_model) );
299
300 wxDataViewListModel *model = list_store->model;
301 wxString mtype = model->GetColType( (size_t) column );
302 if (mtype == wxT("string"))
303 {
304 g_value_init( value, G_TYPE_STRING );
305 wxVariant variant = model->GetValue( (size_t) column, (size_t) iter->user_data );
306 g_value_set_string( value, wxGTK_CONV(variant.GetString()) );
307 }
308 else
309 {
310 }
311
312 #if 0
313 GtkTreeDataList *list;
314 gint tmp_column = column;
315
316 g_return_if_fail (column < GTK_LIST_STORE (tree_model)->n_columns);
317 g_return_if_fail (GTK_LIST_STORE (tree_model)->stamp == iter->stamp);
318
319 list = G_SLIST (iter->user_data)->data;
320
321 while (tmp_column-- > 0 && list)
322 list = list->next;
323
324 if (list == NULL)
325 g_value_init (value, GTK_LIST_STORE (tree_model)->column_headers[column]);
326 else
327 _gtk_tree_data_list_node_to_value (list,
328 GTK_LIST_STORE (tree_model)->column_headers[column],
329 value);
330 #endif
331
332 }
333
334 static gboolean
335 wxgtk_list_store_iter_next (GtkTreeModel *tree_model,
336 GtkTreeIter *iter)
337 {
338 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
339 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
340
341 g_return_val_if_fail (list_store->stamp == iter->stamp, FALSE);
342
343 int n = (int) iter->user_data;
344
345 if (n == -1)
346 return FALSE;
347
348 if (n >= (int) list_store->model->GetNumberOfRows()-1)
349 return FALSE;
350
351 iter->user_data = (gpointer) ++n;
352
353 return TRUE;
354 }
355
356 static gboolean
357 wxgtk_list_store_iter_children (GtkTreeModel *tree_model,
358 GtkTreeIter *iter,
359 GtkTreeIter *parent)
360 {
361 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
362 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
363
364 // this is a list, nodes have no children
365 if (parent)
366 return FALSE;
367
368 iter->stamp = list_store->stamp;
369 iter->user_data = (gpointer) -1;
370
371 return TRUE;
372 }
373
374 static gboolean
375 wxgtk_list_store_iter_has_child (GtkTreeModel *tree_model,
376 GtkTreeIter *iter)
377 {
378 return FALSE;
379 }
380
381 static gint
382 wxgtk_list_store_iter_n_children (GtkTreeModel *tree_model,
383 GtkTreeIter *iter)
384 {
385 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), -1);
386 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
387
388 if (iter == NULL)
389 return (gint) list_store->model->GetNumberOfRows();
390
391 g_return_val_if_fail (list_store->stamp == iter->stamp, -1);
392
393 return 0;
394 }
395
396 static gboolean
397 wxgtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
398 GtkTreeIter *iter,
399 GtkTreeIter *parent,
400 gint n)
401 {
402 g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
403 GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
404
405 if (parent)
406 return FALSE;
407
408 if (n < 0)
409 return FALSE;
410
411 if (n >= (gint) list_store->model->GetNumberOfRows())
412 return FALSE;
413
414 iter->stamp = list_store->stamp;
415 iter->user_data = (gpointer) n;
416
417 return TRUE;
418 }
419
420 static gboolean
421 wxgtk_list_store_iter_parent (GtkTreeModel *tree_model,
422 GtkTreeIter *iter,
423 GtkTreeIter *child)
424 {
425 return FALSE;
426 }
427
428 //-----------------------------------------------------------------------------
429 // define new GTK+ class wxGtkCellRenderer
430 //-----------------------------------------------------------------------------
431
432 extern "C" {
433
434 #define GTK_TYPE_WX_CELL_RENDERER (gtk_wx_cell_renderer_get_type ())
435 #define GTK_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
436 #define GTK_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
437 #define GTK_IS_WX_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
438 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
439 #define GTK_WX_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
440
441 GType gtk_wx_cell_renderer_get_type (void);
442
443 typedef struct _GtkWxCellRenderer GtkWxCellRenderer;
444 typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass;
445
446 struct _GtkWxCellRenderer
447 {
448 GtkCellRenderer parent;
449
450 /*< private >*/
451 wxDataViewCustomCell *cell;
452 guint32 last_click;
453 };
454
455 struct _GtkWxCellRendererClass
456 {
457 GtkCellRendererClass cell_parent_class;
458 };
459
460
461 static GtkCellRenderer *gtk_wx_cell_renderer_new (void);
462 static void gtk_wx_cell_renderer_init (
463 GtkWxCellRenderer *cell );
464 static void gtk_wx_cell_renderer_class_init(
465 GtkWxCellRendererClass *klass );
466 static void gtk_wx_cell_renderer_finalize (
467 GObject *object );
468 static void gtk_wx_cell_renderer_get_size (
469 GtkCellRenderer *cell,
470 GtkWidget *widget,
471 GdkRectangle *rectangle,
472 gint *x_offset,
473 gint *y_offset,
474 gint *width,
475 gint *height );
476 static void gtk_wx_cell_renderer_render (
477 GtkCellRenderer *cell,
478 GdkWindow *window,
479 GtkWidget *widget,
480 GdkRectangle *background_area,
481 GdkRectangle *cell_area,
482 GdkRectangle *expose_area,
483 GtkCellRendererState flags );
484 static gboolean gtk_wx_cell_renderer_activate(
485 GtkCellRenderer *cell,
486 GdkEvent *event,
487 GtkWidget *widget,
488 const gchar *path,
489 GdkRectangle *background_area,
490 GdkRectangle *cell_area,
491 GtkCellRendererState flags );
492
493 static GObjectClass *cell_parent_class = NULL;
494
495 } // extern "C"
496
497 GType
498 gtk_wx_cell_renderer_get_type (void)
499 {
500 static GType cell_wx_type = 0;
501
502 if (!cell_wx_type)
503 {
504 static const GTypeInfo cell_wx_info =
505 {
506 sizeof (GtkWxCellRendererClass),
507 NULL, /* base_init */
508 NULL, /* base_finalize */
509 (GClassInitFunc) gtk_wx_cell_renderer_class_init,
510 NULL, /* class_finalize */
511 NULL, /* class_data */
512 sizeof (GtkWxCellRenderer),
513 0, /* n_preallocs */
514 (GInstanceInitFunc) gtk_wx_cell_renderer_init,
515 };
516
517 cell_wx_type = g_type_register_static( GTK_TYPE_CELL_RENDERER,
518 "GtkWxCellRenderer", &cell_wx_info, (GTypeFlags)0 );
519 }
520
521 return cell_wx_type;
522 }
523
524 static void
525 gtk_wx_cell_renderer_init (GtkWxCellRenderer *cell)
526 {
527 cell->cell = NULL;
528 cell->last_click = 0;
529 }
530
531 static void
532 gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass *klass)
533 {
534 GObjectClass *object_class = G_OBJECT_CLASS (klass);
535 GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
536
537 cell_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
538
539 object_class->finalize = gtk_wx_cell_renderer_finalize;
540
541 cell_class->get_size = gtk_wx_cell_renderer_get_size;
542 cell_class->render = gtk_wx_cell_renderer_render;
543 cell_class->activate = gtk_wx_cell_renderer_activate;
544 }
545
546 static void
547 gtk_wx_cell_renderer_finalize (GObject *object)
548 {
549 /* must chain up */
550 (* G_OBJECT_CLASS (cell_parent_class)->finalize) (object);
551 }
552
553 GtkCellRenderer*
554 gtk_wx_cell_renderer_new (void)
555 {
556 return (GtkCellRenderer*) g_object_new (GTK_TYPE_WX_CELL_RENDERER, NULL);
557 }
558
559 static void
560 gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
561 GtkWidget *widget,
562 GdkRectangle *cell_area,
563 gint *x_offset,
564 gint *y_offset,
565 gint *width,
566 gint *height)
567 {
568 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
569 wxDataViewCustomCell *cell = wxrenderer->cell;
570
571 wxSize size = cell->GetSize();
572
573 gint calc_width = (gint) renderer->xpad * 2 + size.x;
574 gint calc_height = (gint) renderer->ypad * 2 + size.y;
575
576 if (x_offset)
577 *x_offset = 0;
578 if (y_offset)
579 *y_offset = 0;
580
581 if (cell_area && size.x > 0 && size.y > 0)
582 {
583 if (x_offset)
584 {
585 *x_offset = (gint)((renderer->xalign *
586 (cell_area->width - calc_width - 2 * renderer->xpad)));
587 *x_offset = MAX (*x_offset, 0) + renderer->xpad;
588 }
589 if (y_offset)
590 {
591 *y_offset = (gint)((renderer->yalign *
592 (cell_area->height - calc_height - 2 * renderer->ypad)));
593 *y_offset = MAX (*y_offset, 0) + renderer->ypad;
594 }
595 }
596
597 if (width)
598 *width = calc_width;
599
600 if (height)
601 *height = calc_height;
602 }
603
604 static void
605 gtk_wx_cell_renderer_render (GtkCellRenderer *renderer,
606 GdkWindow *window,
607 GtkWidget *widget,
608 GdkRectangle *background_area,
609 GdkRectangle *cell_area,
610 GdkRectangle *expose_area,
611 GtkCellRendererState flags)
612
613 {
614 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
615 wxDataViewCustomCell *cell = wxrenderer->cell;
616
617 GdkRectangle rect;
618 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
619 &rect.x,
620 &rect.y,
621 &rect.width,
622 &rect.height);
623
624 rect.x += cell_area->x;
625 rect.y += cell_area->y;
626 rect.width -= renderer->xpad * 2;
627 rect.height -= renderer->ypad * 2;
628
629 GdkRectangle dummy;
630 if (gdk_rectangle_intersect (expose_area, &rect, &dummy))
631 {
632 wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
633 wxWindowDC* dc = (wxWindowDC*) cell->GetDC();
634 if (dc->m_window == NULL)
635 {
636 dc->m_window = window;
637 dc->SetUpDC();
638 }
639
640 int state = 0;
641 if (flags & GTK_CELL_RENDERER_SELECTED)
642 state |= wxDATAVIEW_CELL_SELECTED;
643 if (flags & GTK_CELL_RENDERER_PRELIT)
644 state |= wxDATAVIEW_CELL_PRELIT;
645 if (flags & GTK_CELL_RENDERER_INSENSITIVE)
646 state |= wxDATAVIEW_CELL_INSENSITIVE;
647 if (flags & GTK_CELL_RENDERER_INSENSITIVE)
648 state |= wxDATAVIEW_CELL_INSENSITIVE;
649 if (flags & GTK_CELL_RENDERER_FOCUSED)
650 state |= wxDATAVIEW_CELL_FOCUSED;
651 cell->Render( renderrect, dc, state );
652 }
653 }
654
655 static gboolean
656 gtk_wx_cell_renderer_activate(
657 GtkCellRenderer *renderer,
658 GdkEvent *event,
659 GtkWidget *widget,
660 const gchar *path,
661 GdkRectangle *background_area,
662 GdkRectangle *cell_area,
663 GtkCellRendererState flags )
664 {
665 GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
666 wxDataViewCustomCell *cell = wxrenderer->cell;
667
668 GdkRectangle rect;
669 gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
670 &rect.x,
671 &rect.y,
672 &rect.width,
673 &rect.height);
674
675 rect.x += cell_area->x;
676 rect.y += cell_area->y;
677 rect.width -= renderer->xpad * 2;
678 rect.height -= renderer->ypad * 2;
679
680 wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
681
682 wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
683
684 GtkTreePath *treepath = gtk_tree_path_new_from_string( path );
685 size_t model_row = (size_t)gtk_tree_path_get_indices (treepath)[0];
686 gtk_tree_path_free( treepath );
687
688 size_t model_col = cell->GetOwner()->GetModelColumn();
689
690 if (event->type == GDK_BUTTON_PRESS)
691 {
692 GdkEventButton *button_event = (GdkEventButton*) event;
693 wxPoint pt( ((int) button_event->x) - renderrect.x,
694 ((int) button_event->y) - renderrect.y );
695
696 bool ret = false;
697 if (button_event->button == 1)
698 {
699 if (cell->LeftClick( pt, renderrect, model, model_col, model_row ))
700 ret = true;
701 if (button_event->time - wxrenderer->last_click < 400)
702 if (cell->Activate( renderrect, model, model_col, model_row ))
703 ret = true;
704 }
705 if (button_event->button == 3)
706 {
707 if (cell->RightClick( pt, renderrect, model, model_col, model_row ))
708 ret = true;
709 }
710
711 wxrenderer->last_click = button_event->time;
712
713 return ret;
714 }
715
716 if (event->type == GDK_KEY_PRESS)
717 {
718 wxPrintf( wxT("key\n") );
719 GdkEventKey *key_event = (GdkEventKey*) event;
720 if ((key_event->keyval == GDK_Return) ||
721 (key_event->keyval == GDK_Linefeed) ||
722 (key_event->keyval == GDK_Execute))
723 {
724 return cell->Activate( renderrect, model, model_col, model_row );
725 }
726 }
727
728 return false;
729 }
730
731 // ---------------------------------------------------------
732 // wxGtkDataViewListModelNotifier
733 // ---------------------------------------------------------
734
735 class wxGtkDataViewListModelNotifier: public wxDataViewListModelNotifier
736 {
737 public:
738 wxGtkDataViewListModelNotifier( GtkWxListStore* gtk_store, wxDataViewListModel *wx_model );
739
740 virtual bool RowAppended();
741 virtual bool RowPrepended();
742 virtual bool RowInserted( size_t before );
743 virtual bool RowDeleted( size_t row );
744 virtual bool RowChanged( size_t row );
745 virtual bool ValueChanged( size_t col, size_t row );
746 virtual bool Cleared();
747
748 GtkWxListStore *m_gtk_store;
749 wxDataViewListModel *m_wx_model;
750 };
751
752 // ---------------------------------------------------------
753 // wxGtkDataViewListModelNotifier
754 // ---------------------------------------------------------
755
756 wxGtkDataViewListModelNotifier::wxGtkDataViewListModelNotifier(
757 GtkWxListStore* gtk_store, wxDataViewListModel *wx_model )
758 {
759 m_gtk_store = gtk_store;
760 m_wx_model = wx_model;
761 }
762
763 bool wxGtkDataViewListModelNotifier::RowAppended()
764 {
765 size_t pos = m_wx_model->GetNumberOfRows()-1;
766
767 GtkTreeIter iter;
768 iter.stamp = m_gtk_store->stamp;
769 iter.user_data = (gpointer) pos;
770
771 GtkTreePath *path = gtk_tree_path_new ();
772 gtk_tree_path_append_index (path, (gint) pos);
773 gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
774 gtk_tree_path_free (path);
775
776 return true;
777 }
778
779 bool wxGtkDataViewListModelNotifier::RowPrepended()
780 {
781 GtkTreeIter iter;
782 iter.stamp = m_gtk_store->stamp;
783 iter.user_data = (gpointer) 0;
784
785 GtkTreePath *path = gtk_tree_path_new ();
786 gtk_tree_path_append_index (path, (gint) 0);
787 gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
788 gtk_tree_path_free (path);
789
790 return true;
791 }
792
793 bool wxGtkDataViewListModelNotifier::RowInserted( size_t before )
794 {
795 return false;
796 }
797
798 bool wxGtkDataViewListModelNotifier::RowDeleted( size_t row )
799 {
800 return false;
801 }
802
803 bool wxGtkDataViewListModelNotifier::RowChanged( size_t row )
804 {
805 GtkTreeIter iter;
806 iter.stamp = m_gtk_store->stamp;
807 iter.user_data = (gpointer) row;
808 GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (m_gtk_store), &iter);
809 gtk_tree_model_row_changed (GTK_TREE_MODEL (m_gtk_store), path, &iter);
810 gtk_tree_path_free (path);
811
812 return true;
813 }
814
815 bool wxGtkDataViewListModelNotifier::ValueChanged( size_t col, size_t row )
816 {
817 return RowChanged( row );
818 }
819
820 bool wxGtkDataViewListModelNotifier::Cleared()
821 {
822 return false;
823 }
824
825 // ---------------------------------------------------------
826 // wxDataViewCell
827 // ---------------------------------------------------------
828
829 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
830
831 wxDataViewCell::wxDataViewCell( const wxString &varianttype, wxDataViewCellMode mode ) :
832 wxDataViewCellBase( varianttype, mode )
833 {
834 m_renderer = NULL;
835 }
836
837 // ---------------------------------------------------------
838 // wxDataViewTextCell
839 // ---------------------------------------------------------
840
841 extern "C" {
842 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *renderer,
843 gchar *arg1, gchar *arg2, gpointer user_data );
844 }
845
846 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *renderer,
847 gchar *arg1, gchar *arg2, gpointer user_data )
848 {
849 wxDataViewTextCell *cell = (wxDataViewTextCell*) user_data;
850
851 wxString tmp = wxGTK_CONV_BACK( arg2 );
852 wxVariant value = tmp;
853 if (!cell->Validate( value ))
854 return;
855
856 wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
857
858 GtkTreePath *path = gtk_tree_path_new_from_string( arg1 );
859 size_t model_row = (size_t)gtk_tree_path_get_indices (path)[0];
860 gtk_tree_path_free( path );
861
862 size_t model_col = cell->GetOwner()->GetModelColumn();
863
864 model->SetValue( value, model_col, model_row );
865 model->ValueChanged( model_col, model_row );
866 }
867
868 IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCell)
869
870 wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewCellMode mode ) :
871 wxDataViewCell( varianttype, mode )
872 {
873 m_renderer = (void*) gtk_cell_renderer_text_new();
874
875 if (m_mode & wxDATAVIEW_CELL_EDITABLE)
876 {
877 GValue gvalue = { 0, };
878 g_value_init( &gvalue, G_TYPE_BOOLEAN );
879 g_value_set_boolean( &gvalue, true );
880 g_object_set_property( G_OBJECT(m_renderer), "editable", &gvalue );
881 g_value_unset( &gvalue );
882
883 g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
884 }
885 }
886
887 bool wxDataViewTextCell::SetValue( const wxVariant &value )
888 {
889 wxString tmp = value;
890
891 GValue gvalue = { 0, };
892 g_value_init( &gvalue, G_TYPE_STRING );
893 g_value_set_string( &gvalue, wxGTK_CONV( tmp ) );
894 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
895 g_value_unset( &gvalue );
896
897 return true;
898 }
899
900 bool wxDataViewTextCell::GetValue( wxVariant &value )
901 {
902 GValue gvalue = { 0, };
903 g_value_init( &gvalue, G_TYPE_STRING );
904 g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
905 wxString tmp = wxGTK_CONV_BACK( g_value_get_string( &gvalue ) );
906 g_value_unset( &gvalue );
907
908 value = tmp;
909
910 return true;
911 }
912
913 // ---------------------------------------------------------
914 // wxDataViewToggleCell
915 // ---------------------------------------------------------
916
917 extern "C" {
918 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
919 gchar *path, gpointer user_data );
920 }
921
922 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
923 gchar *path, gpointer user_data )
924 {
925 wxDataViewToggleCell *cell = (wxDataViewToggleCell*) user_data;
926
927 // get old value
928 GValue gvalue = { 0, };
929 g_value_init( &gvalue, G_TYPE_BOOLEAN );
930 g_object_get_property( G_OBJECT(renderer), "active", &gvalue );
931 bool tmp = g_value_get_boolean( &gvalue );
932 g_value_unset( &gvalue );
933 // invert it
934 tmp = !tmp;
935
936 wxVariant value = tmp;
937 if (!cell->Validate( value ))
938 return;
939
940 wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
941
942 GtkTreePath *gtk_path = gtk_tree_path_new_from_string( path );
943 size_t model_row = (size_t)gtk_tree_path_get_indices (gtk_path)[0];
944 gtk_tree_path_free( gtk_path );
945
946 size_t model_col = cell->GetOwner()->GetModelColumn();
947
948 model->SetValue( value, model_col, model_row );
949 model->ValueChanged( model_col, model_row );
950 }
951
952 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCell)
953
954 wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
955 wxDataViewCellMode mode ) :
956 wxDataViewCell( varianttype, mode )
957 {
958 m_renderer = (void*) gtk_cell_renderer_toggle_new();
959
960 if (m_mode & wxDATAVIEW_CELL_EDITABLE)
961 {
962 g_signal_connect_after( m_renderer, "toggled", G_CALLBACK(wxGtkToggleRendererToggledCallback), this );
963 }
964 else
965 {
966
967 GValue gvalue = { 0, };
968 g_value_init( &gvalue, G_TYPE_BOOLEAN );
969 g_value_set_boolean( &gvalue, false );
970 g_object_set_property( G_OBJECT(m_renderer), "activatable", &gvalue );
971 g_value_unset( &gvalue );
972
973 GValue gvalue2 = { 0, };
974 g_value_init( &gvalue2, gtk_cell_renderer_mode_get_type() );
975 g_value_set_enum( &gvalue2, GTK_CELL_RENDERER_MODE_INERT );
976 g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue2 );
977 g_value_unset( &gvalue2 );
978
979 }
980 }
981
982 bool wxDataViewToggleCell::SetValue( const wxVariant &value )
983 {
984 bool tmp = value;
985
986 GValue gvalue = { 0, };
987 g_value_init( &gvalue, G_TYPE_BOOLEAN );
988 g_value_set_boolean( &gvalue, tmp );
989 g_object_set_property( G_OBJECT(m_renderer), "active", &gvalue );
990 g_value_unset( &gvalue );
991
992 return true;
993 }
994
995 bool wxDataViewToggleCell::GetValue( wxVariant &value )
996 {
997 GValue gvalue = { 0, };
998 g_value_init( &gvalue, G_TYPE_BOOLEAN );
999 g_object_get_property( G_OBJECT(m_renderer), "active", &gvalue );
1000 bool tmp = g_value_get_boolean( &gvalue );
1001 g_value_unset( &gvalue );
1002
1003 value = tmp;
1004
1005 return true;
1006 }
1007
1008 // ---------------------------------------------------------
1009 // wxDataViewCustomCell
1010 // ---------------------------------------------------------
1011
1012 class wxDataViewCtrlDC: public wxWindowDC
1013 {
1014 public:
1015 wxDataViewCtrlDC( wxDataViewCtrl *window )
1016 {
1017 GtkWidget *widget = window->m_treeview;
1018 // Set later
1019 m_window = NULL;
1020
1021 m_context = window->GtkGetPangoDefaultContext();
1022 m_layout = pango_layout_new( m_context );
1023 m_fontdesc = pango_font_description_copy( widget->style->font_desc );
1024
1025 m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
1026
1027 // Set m_window later
1028 // SetUpDC();
1029 // m_owner = window;
1030 }
1031 };
1032
1033 // ---------------------------------------------------------
1034 // wxDataViewCustomCell
1035 // ---------------------------------------------------------
1036
1037 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
1038
1039 wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,
1040 wxDataViewCellMode mode, bool no_init ) :
1041 wxDataViewCell( varianttype, mode )
1042 {
1043 m_dc = NULL;
1044
1045 if (no_init)
1046 m_renderer = NULL;
1047 else
1048 Init();
1049 }
1050
1051 bool wxDataViewCustomCell::Init()
1052 {
1053 GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
1054 renderer->cell = this;
1055
1056 m_renderer = (void*) renderer;
1057
1058 if (m_mode & wxDATAVIEW_CELL_ACTIVATABLE)
1059 {
1060 GValue gvalue = { 0, };
1061 g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1062 g_value_set_enum( &gvalue, GTK_CELL_RENDERER_MODE_ACTIVATABLE );
1063 g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue );
1064 g_value_unset( &gvalue );
1065 }
1066
1067 return true;
1068 }
1069
1070 wxDataViewCustomCell::~wxDataViewCustomCell()
1071 {
1072 if (m_dc)
1073 delete m_dc;
1074 }
1075
1076 wxDC *wxDataViewCustomCell::GetDC()
1077 {
1078 if (m_dc == NULL)
1079 {
1080 if (GetOwner() == NULL)
1081 return NULL;
1082 if (GetOwner()->GetOwner() == NULL)
1083 return NULL;
1084 m_dc = new wxDataViewCtrlDC( GetOwner()->GetOwner() );
1085 }
1086
1087 return m_dc;
1088 }
1089
1090 // ---------------------------------------------------------
1091 // wxDataViewProgressCell
1092 // ---------------------------------------------------------
1093
1094 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
1095
1096 wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,
1097 const wxString &varianttype, wxDataViewCellMode mode ) :
1098 wxDataViewCustomCell( varianttype, mode, true )
1099 {
1100 m_label = label;
1101 m_value = 0;
1102
1103 #ifdef __WXGTK26__
1104 if (!gtk_check_version(2,6,0))
1105 {
1106 m_renderer = (void*) gtk_cell_renderer_progress_new();
1107
1108 GValue gvalue = { 0, };
1109 g_value_init( &gvalue, G_TYPE_STRING );
1110 g_value_set_boolean( &gvalue, wxGTK_CONV(m_label) );
1111 g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
1112 g_value_unset( &gvalue );
1113 }
1114 else
1115 #endif
1116 {
1117 // Use custom cell code
1118 wxDataViewCustomCell::Init();
1119 }
1120 }
1121
1122 wxDataViewProgressCell::~wxDataViewProgressCell()
1123 {
1124 }
1125
1126 bool wxDataViewProgressCell::SetValue( const wxVariant &value )
1127 {
1128 #ifdef __WXGTK26__
1129 if (!gtk_check_version(2,6,0))
1130 {
1131 gint tmp = (int) value;
1132 GValue gvalue = { 0, };
1133 g_value_init( &gvalue, G_TYPE_INT );
1134 g_value_set_boolean( &gvalue, tmp );
1135 g_object_set_property( G_OBJECT(m_renderer), "value", &gvalue );
1136 g_value_unset( &gvalue );
1137 }
1138 else
1139 #endif
1140 {
1141 m_value = (long) value;
1142
1143 if (m_value < 0) m_value = 0;
1144 if (m_value > 100) m_value = 100;
1145 }
1146
1147 return true;
1148 }
1149
1150 bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int state )
1151 {
1152 double pct = (double)m_value / 100.0;
1153 wxRect bar = cell;
1154 bar.width = (int)(cell.width * pct);
1155 dc->SetPen( *wxTRANSPARENT_PEN );
1156 dc->SetBrush( *wxBLUE_BRUSH );
1157 dc->DrawRectangle( bar );
1158
1159 dc->SetBrush( *wxTRANSPARENT_BRUSH );
1160 dc->SetPen( *wxBLACK_PEN );
1161 dc->DrawRectangle( cell );
1162
1163 return true;
1164 }
1165
1166 wxSize wxDataViewProgressCell::GetSize()
1167 {
1168 return wxSize(40,12);
1169 }
1170
1171 // ---------------------------------------------------------
1172 // wxDataViewDateCell
1173 // ---------------------------------------------------------
1174
1175 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)
1176
1177 wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
1178 wxDataViewCellMode mode ) :
1179 wxDataViewCustomCell( varianttype, mode )
1180 {
1181 }
1182
1183 bool wxDataViewDateCell::SetValue( const wxVariant &value )
1184 {
1185 m_date = value.GetDateTime();
1186
1187 return true;
1188 }
1189
1190 bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int state )
1191 {
1192 dc->SetFont( GetOwner()->GetOwner()->GetFont() );
1193 wxString tmp = m_date.FormatDate();
1194 dc->DrawText( tmp, cell.x, cell.y );
1195
1196 return true;
1197 }
1198
1199 wxSize wxDataViewDateCell::GetSize()
1200 {
1201 wxDataViewCtrl* view = GetOwner()->GetOwner();
1202 wxString tmp = m_date.FormatDate();
1203 wxCoord x,y,d;
1204 view->GetTextExtent( tmp, &x, &y, &d );
1205 return wxSize(x,y+d);
1206 }
1207
1208 bool wxDataViewDateCell::Activate( wxRect cell, wxDataViewListModel *model, size_t col, size_t row )
1209 {
1210
1211 return true;
1212 }
1213
1214 // ---------------------------------------------------------
1215 // wxDataViewColumn
1216 // ---------------------------------------------------------
1217
1218 extern "C" {
1219 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *column,
1220 GtkCellRenderer *cell,
1221 GtkTreeModel *model,
1222 GtkTreeIter *iter,
1223 gpointer data );
1224 }
1225
1226
1227 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *column,
1228 GtkCellRenderer *renderer,
1229 GtkTreeModel *model,
1230 GtkTreeIter *iter,
1231 gpointer data )
1232 {
1233 g_return_if_fail (GTK_IS_WX_LIST_STORE (model));
1234 GtkWxListStore *list_store = (GtkWxListStore *) model;
1235
1236 wxDataViewCell *cell = (wxDataViewCell*) data;
1237
1238 size_t model_row = (size_t) iter->user_data;
1239
1240 wxVariant value = list_store->model->GetValue(
1241 cell->GetOwner()->GetModelColumn(), model_row );
1242
1243 if (value.GetType() != cell->GetVariantType())
1244 wxPrintf( wxT("Wrong type\n") );
1245
1246 cell->SetValue( value );
1247 }
1248
1249 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
1250
1251 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell,
1252 size_t model_column, int flags ) :
1253 wxDataViewColumnBase( title, cell, model_column, flags )
1254 {
1255 GtkCellRenderer *renderer = (GtkCellRenderer *) cell->GetGtkHandle();
1256
1257 GtkTreeViewColumn *column = gtk_tree_view_column_new();
1258
1259 gtk_tree_view_column_set_title( column, wxGTK_CONV(title) );
1260
1261 gtk_tree_view_column_pack_start( column, renderer, TRUE );
1262
1263 gtk_tree_view_column_set_cell_data_func( column, renderer,
1264 wxGtkTreeCellDataFunc, (gpointer) cell, NULL );
1265
1266 m_column = (void*) column;
1267 }
1268
1269 wxDataViewColumn::~wxDataViewColumn()
1270 {
1271 }
1272
1273 void wxDataViewColumn::SetTitle( const wxString &title )
1274 {
1275 wxDataViewColumnBase::SetTitle( title );
1276
1277 GtkTreeViewColumn *column = (GtkTreeViewColumn *)m_column;
1278 gtk_tree_view_column_set_title( column, wxGTK_CONV(title) );
1279 }
1280
1281 //-----------------------------------------------------------------------------
1282 // wxDataViewCtrl
1283 //-----------------------------------------------------------------------------
1284
1285 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
1286
1287 wxDataViewCtrl::~wxDataViewCtrl()
1288 {
1289 }
1290
1291 void wxDataViewCtrl::Init()
1292 {
1293 }
1294
1295 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
1296 const wxPoint& pos, const wxSize& size,
1297 long style, const wxValidator& validator )
1298 {
1299 Init();
1300
1301 m_needParent = TRUE;
1302 m_acceptsFocus = TRUE;
1303
1304 if (!PreCreation( parent, pos, size ) ||
1305 !CreateBase( parent, id, pos, size, style, validator ))
1306 {
1307 wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
1308 return FALSE;
1309 }
1310
1311 m_widget = gtk_scrolled_window_new (NULL, NULL);
1312 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (m_widget), GTK_SHADOW_IN);
1313
1314 m_treeview = gtk_tree_view_new();
1315 gtk_container_add (GTK_CONTAINER (m_widget), m_treeview);
1316
1317 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget),
1318 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
1319 gtk_widget_show (m_treeview);
1320
1321 m_parent->DoAddChild( this );
1322
1323 PostCreation(size);
1324
1325 return true;
1326 }
1327
1328 bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
1329 {
1330 if (!wxDataViewCtrlBase::AssociateModel( model ))
1331 return false;
1332
1333 GtkWxListStore *gtk_store = wxgtk_list_store_new();
1334 gtk_store->model = model;
1335
1336 wxGtkDataViewListModelNotifier *notifier =
1337 new wxGtkDataViewListModelNotifier( gtk_store, model );
1338
1339 model->SetNotifier( notifier );
1340
1341 gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview), GTK_TREE_MODEL(gtk_store) );
1342 g_object_unref( gtk_store );
1343
1344 return true;
1345 }
1346
1347 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
1348 {
1349 if (!wxDataViewCtrlBase::AppendColumn(col))
1350 return false;
1351
1352 GtkTreeViewColumn *column = (GtkTreeViewColumn *)col->GetGtkHandle();
1353
1354 gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview), column );
1355
1356 return true;
1357 }
1358
1359
1360 #endif // wxUSE_DATAVIEWCTRL
1361
wxWidgets (Impactor)