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