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                          wxPtrToUInt(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 static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
 484                         GtkCellRenderer         *cell,
 485                         GdkEvent                *event,
 486                         GtkWidget               *widget,
 487                         const gchar             *path,
 488                         GdkRectangle            *background_area,
 489                         GdkRectangle            *cell_area,
 490                         GtkCellRendererState     flags );
 491
 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         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     cell_class->start_editing = gtk_wx_cell_renderer_start_editing;
 545 }
 546
 547 static void
 548 gtk_wx_cell_renderer_finalize (GObject *object)
 549 {
 550     /* must chain up */
 551     (* G_OBJECT_CLASS (cell_parent_class)->finalize) (object);
 552 }
 553
 554 GtkCellRenderer*
 555 gtk_wx_cell_renderer_new (void)
 556 {
 557     return (GtkCellRenderer*) g_object_new (GTK_TYPE_WX_CELL_RENDERER, NULL);
 558 }
 559
 560
 561
 562 static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
 563                         GtkCellRenderer         *renderer,
 564                         GdkEvent                *event,
 565                         GtkWidget               *widget,
 566                         const gchar             *path,
 567                         GdkRectangle            *background_area,
 568                         GdkRectangle            *cell_area,
 569                         GtkCellRendererState     flags )
 570 {
 571     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
 572     wxDataViewCustomRenderer *cell = wxrenderer->cell;
 573     if (!cell->HasEditorCtrl())
 574         return NULL;
 575
 576     GdkRectangle rect;
 577     gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
 578                                    &rect.x,
 579                                    &rect.y,
 580                                    &rect.width,
 581                                    &rect.height);
 582
 583     rect.x += cell_area->x;
 584     rect.y += cell_area->y;
 585 //    rect.width  -= renderer->xpad * 2;
 586 //    rect.height -= renderer->ypad * 2;
 587
 588 //    wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
 589     wxRect renderrect( cell_area->x, cell_area->y, cell_area->width, cell_area->height );
 590
 591     // wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
 592
 593     GtkTreePath *treepath = gtk_tree_path_new_from_string( path );
 594     unsigned int model_row = (unsigned int)gtk_tree_path_get_indices (treepath)[0];
 595     gtk_tree_path_free( treepath );
 596
 597     cell->StartEditing( model_row, renderrect );
 598
 599     return NULL;
 600 }
 601
 602 static void
 603 gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
 604                                GtkWidget       *widget,
 605                                GdkRectangle    *cell_area,
 606                                gint            *x_offset,
 607                                gint            *y_offset,
 608                                gint            *width,
 609                                gint            *height)
 610 {
 611     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
 612     wxDataViewCustomRenderer *cell = wxrenderer->cell;
 613
 614     wxSize size = cell->GetSize();
 615
 616     gint calc_width  = (gint) renderer->xpad * 2 + size.x;
 617     gint calc_height = (gint) renderer->ypad * 2 + size.y;
 618
 619     if (x_offset)
 620         *x_offset = 0;
 621     if (y_offset)
 622         *y_offset = 0;
 623
 624     if (cell_area && size.x > 0 && size.y > 0)
 625     {
 626         if (x_offset)
 627         {
 628             *x_offset = (gint)((renderer->xalign *
 629                                (cell_area->width - calc_width - 2 * renderer->xpad)));
 630             *x_offset = MAX (*x_offset, 0) + renderer->xpad;
 631         }
 632         if (y_offset)
 633         {
 634             *y_offset = (gint)((renderer->yalign *
 635                                (cell_area->height - calc_height - 2 * renderer->ypad)));
 636             *y_offset = MAX (*y_offset, 0) + renderer->ypad;
 637         }
 638     }
 639
 640     if (width)
 641         *width = calc_width;
 642
 643     if (height)
 644         *height = calc_height;
 645 }
 646
 647 static void
 648 gtk_wx_cell_renderer_render (GtkCellRenderer      *renderer,
 649                              GdkWindow            *window,
 650                              GtkWidget            *widget,
 651                              GdkRectangle         *background_area,
 652                              GdkRectangle         *cell_area,
 653                              GdkRectangle         *expose_area,
 654                              GtkCellRendererState  flags)
 655
 656 {
 657     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
 658     wxDataViewCustomRenderer *cell = wxrenderer->cell;
 659
 660     GdkRectangle rect;
 661     gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
 662                                    &rect.x,
 663                                    &rect.y,
 664                                    &rect.width,
 665                                    &rect.height);
 666
 667     rect.x += cell_area->x;
 668     rect.y += cell_area->y;
 669     rect.width  -= renderer->xpad * 2;
 670     rect.height -= renderer->ypad * 2;
 671
 672     GdkRectangle dummy;
 673     if (gdk_rectangle_intersect (expose_area, &rect, &dummy))
 674     {
 675         wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
 676         wxWindowDC* dc = (wxWindowDC*) cell->GetDC();
 677         if (dc->m_window == NULL)
 678         {
 679             dc->m_window = window;
 680             dc->SetUpDC();
 681         }
 682
 683         int state = 0;
 684         if (flags & GTK_CELL_RENDERER_SELECTED)
 685             state |= wxDATAVIEW_CELL_SELECTED;
 686         if (flags & GTK_CELL_RENDERER_PRELIT)
 687             state |= wxDATAVIEW_CELL_PRELIT;
 688         if (flags & GTK_CELL_RENDERER_INSENSITIVE)
 689             state |= wxDATAVIEW_CELL_INSENSITIVE;
 690         if (flags & GTK_CELL_RENDERER_INSENSITIVE)
 691             state |= wxDATAVIEW_CELL_INSENSITIVE;
 692         if (flags & GTK_CELL_RENDERER_FOCUSED)
 693             state |= wxDATAVIEW_CELL_FOCUSED;
 694         cell->Render( renderrect, dc, state );
 695     }
 696 }
 697
 698 static gboolean
 699 gtk_wx_cell_renderer_activate(
 700                         GtkCellRenderer         *renderer,
 701                         GdkEvent                *event,
 702                         GtkWidget               *widget,
 703                         const gchar             *path,
 704                         GdkRectangle            *background_area,
 705                         GdkRectangle            *cell_area,
 706                         GtkCellRendererState     flags )
 707 {
 708     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
 709     wxDataViewCustomRenderer *cell = wxrenderer->cell;
 710
 711     GdkRectangle rect;
 712     gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
 713                                    &rect.x,
 714                                    &rect.y,
 715                                    &rect.width,
 716                                    &rect.height);
 717
 718     rect.x += cell_area->x;
 719     rect.y += cell_area->y;
 720     rect.width  -= renderer->xpad * 2;
 721     rect.height -= renderer->ypad * 2;
 722
 723     wxRect renderrect( rect.x, rect.y, rect.width, rect.height );
 724
 725     wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
 726
 727     GtkTreePath *treepath = gtk_tree_path_new_from_string( path );
 728     unsigned int model_row = (unsigned int)gtk_tree_path_get_indices (treepath)[0];
 729     gtk_tree_path_free( treepath );
 730
 731     unsigned int model_col = cell->GetOwner()->GetModelColumn();
 732
 733     if (!event)
 734     {
 735         bool ret = false;
 736
 737         // activated by <ENTER>
 738         if (cell->Activate( renderrect, model, model_col, model_row ))
 739                     ret = true;
 740
 741         return ret;
 742     }
 743     else if (event->type == GDK_BUTTON_PRESS)
 744     {
 745         GdkEventButton *button_event = (GdkEventButton*) event;
 746         wxPoint pt( ((int) button_event->x) - renderrect.x,
 747                     ((int) button_event->y) - renderrect.y );
 748
 749         bool ret = false;
 750         if (button_event->button == 1)
 751         {
 752             if (cell->LeftClick( pt, renderrect, model, model_col, model_row ))
 753                 ret = true;
 754             // TODO: query system double-click time
 755             if (button_event->time - wxrenderer->last_click < 400)
 756                 if (cell->Activate( renderrect, model, model_col, model_row ))
 757                     ret = true;
 758         }
 759         if (button_event->button == 3)
 760         {
 761             if (cell->RightClick( pt, renderrect, model, model_col, model_row ))
 762                 ret = true;
 763         }
 764
 765         wxrenderer->last_click = button_event->time;
 766
 767         return ret;
 768     }
 769
 770     return false;
 771 }
 772
 773 // ---------------------------------------------------------
 774 // wxGtkDataViewListModelNotifier
 775 // ---------------------------------------------------------
 776
 777 class wxGtkDataViewListModelNotifier: public wxDataViewListModelNotifier
 778 {
 779 public:
 780     wxGtkDataViewListModelNotifier( GtkWxListStore* gtk_store,
 781                                     wxDataViewListModel *wx_model,
 782                                     wxDataViewCtrl* ctrl );
 783     ~wxGtkDataViewListModelNotifier();
 784
 785     virtual bool RowAppended();
 786     virtual bool RowPrepended();
 787     virtual bool RowInserted( unsigned int before );
 788     virtual bool RowDeleted( unsigned int row );
 789     virtual bool RowChanged( unsigned int row );
 790     virtual bool ValueChanged( unsigned int col, unsigned int row );
 791     virtual bool RowsReordered( unsigned int *new_order );
 792     virtual bool Cleared();
 793
 794     GtkWxListStore      *m_gtk_store;
 795     wxDataViewListModel *m_wx_model;
 796     wxDataViewCtrl      *m_owner;
 797 };
 798
 799 // ---------------------------------------------------------
 800 // wxGtkDataViewListModelNotifier
 801 // ---------------------------------------------------------
 802
 803 wxGtkDataViewListModelNotifier::wxGtkDataViewListModelNotifier(
 804     GtkWxListStore* gtk_store, wxDataViewListModel *wx_model,
 805     wxDataViewCtrl *ctrl )
 806 {
 807     m_gtk_store = gtk_store;
 808     m_wx_model = wx_model;
 809     m_owner = ctrl;
 810 }
 811
 812 wxGtkDataViewListModelNotifier::~wxGtkDataViewListModelNotifier()
 813 {
 814     m_wx_model = NULL;
 815     m_gtk_store = NULL;
 816 }
 817
 818 bool wxGtkDataViewListModelNotifier::RowAppended()
 819 {
 820     unsigned int pos = m_wx_model->GetRowCount()-1;
 821
 822     GtkTreeIter iter;
 823     iter.stamp = m_gtk_store->stamp;
 824     iter.user_data = (gpointer) pos;
 825
 826     GtkTreePath *path = gtk_tree_path_new ();
 827     gtk_tree_path_append_index (path, (gint) pos);
 828     gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
 829     gtk_tree_path_free (path);
 830
 831     return true;
 832 }
 833
 834 bool wxGtkDataViewListModelNotifier::RowPrepended()
 835 {
 836     GtkTreeIter iter;
 837     iter.stamp = m_gtk_store->stamp;
 838     iter.user_data = (gpointer) 0;
 839
 840     GtkTreePath *path = gtk_tree_path_new ();
 841     gtk_tree_path_append_index (path, (gint) 0);
 842     gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
 843     gtk_tree_path_free (path);
 844
 845     return true;
 846 }
 847
 848 bool wxGtkDataViewListModelNotifier::RowInserted( unsigned int before )
 849 {
 850     GtkTreeIter iter;
 851     iter.stamp = m_gtk_store->stamp;
 852     iter.user_data = (gpointer) before;
 853
 854     GtkTreePath *path = gtk_tree_path_new ();
 855     gtk_tree_path_append_index (path, (gint) before);
 856     gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
 857     gtk_tree_path_free (path);
 858
 859     return true;
 860 }
 861
 862 bool wxGtkDataViewListModelNotifier::RowDeleted( unsigned int row )
 863 {
 864     GtkTreePath *path = gtk_tree_path_new ();
 865     gtk_tree_path_append_index (path, (gint) row);
 866     gtk_tree_model_row_deleted (GTK_TREE_MODEL (m_gtk_store), path);
 867     gtk_tree_path_free (path);
 868
 869     return true;
 870 }
 871
 872 bool wxGtkDataViewListModelNotifier::RowChanged( unsigned int row )
 873 {
 874     GtkTreeIter iter;
 875     iter.stamp = m_gtk_store->stamp;
 876     iter.user_data = (gpointer) row;
 877     GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (m_gtk_store), &iter);
 878     gtk_tree_model_row_changed (GTK_TREE_MODEL (m_gtk_store), path, &iter);
 879     gtk_tree_path_free (path);
 880
 881     return true;
 882 }
 883
 884 bool wxGtkDataViewListModelNotifier::ValueChanged( unsigned int model_col, unsigned int model_row )
 885 {
 886     // This adds GTK+'s missing MVC logic for ValueChanged
 887     unsigned int index;
 888     for (index = 0; index < m_owner->GetColumnCount(); index++)
 889     {
 890         wxDataViewColumn *column = m_owner->GetColumn( index );
 891         if (column->GetModelColumn() == model_col)
 892         {
 893             GtkTreeView *widget = GTK_TREE_VIEW(m_owner->m_treeview);
 894             GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
 895
 896             // Get cell area
 897             GtkTreePath *path = gtk_tree_path_new();
 898             gtk_tree_path_append_index( path, model_row );
 899             GdkRectangle cell_area;
 900             gtk_tree_view_get_cell_area( widget, path, gcolumn, &cell_area );
 901             gtk_tree_path_free( path );
 902
 903             GtkAdjustment* hadjust = gtk_tree_view_get_hadjustment( widget );
 904             double d = gtk_adjustment_get_value( hadjust );
 905             int xdiff = (int) d;
 906
 907             int ydiff = gcolumn->button->allocation.height;
 908             // Redraw
 909             gtk_widget_queue_draw_area( GTK_WIDGET(widget),
 910                 cell_area.x - xdiff, ydiff + cell_area.y, cell_area.width, cell_area.height );
 911         }
 912     }
 913
 914     return true;
 915 }
 916
 917 bool wxGtkDataViewListModelNotifier::RowsReordered( unsigned int *new_order )
 918 {
 919     // Assume sizeof(unsigned int)= == sizeof(gint)
 920
 921     GtkTreePath *path = gtk_tree_path_new ();
 922     gtk_tree_model_rows_reordered (GTK_TREE_MODEL (m_gtk_store), path, NULL, (gint*)new_order);
 923     gtk_tree_path_free (path);
 924
 925     // This adds GTK+'s missing MVC logic for RowsReordered
 926     GtkTreeView *widget = GTK_TREE_VIEW(m_owner->m_treeview);
 927     // Doesn't work yet...
 928     gtk_widget_queue_draw( GTK_WIDGET(widget) );
 929
 930     return true;
 931 }
 932
 933 bool wxGtkDataViewListModelNotifier::Cleared()
 934 {
 935     return false;
 936 }
 937
 938 // ---------------------------------------------------------
 939 // wxDataViewRenderer
 940 // ---------------------------------------------------------
 941
 942 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
 943
 944 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode,
 945                                         int align ) :
 946     wxDataViewRendererBase( varianttype, mode, align )
 947 {
 948     m_renderer = NULL;
 949
 950     // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
 951     //       after the m_renderer pointer has been initialized
 952 }
 953
 954 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode )
 955 {
 956     GtkCellRendererMode gtkMode;
 957     switch (mode)
 958     {
 959     case wxDATAVIEW_CELL_INERT:
 960         gtkMode = GTK_CELL_RENDERER_MODE_INERT;
 961         break;
 962     case wxDATAVIEW_CELL_ACTIVATABLE:
 963         gtkMode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
 964         break;
 965     case wxDATAVIEW_CELL_EDITABLE:
 966         gtkMode = GTK_CELL_RENDERER_MODE_EDITABLE;
 967         break;
 968     }
 969
 970     GValue gvalue = { 0, };
 971     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
 972     g_value_set_enum( &gvalue, gtkMode );
 973     g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue );
 974     g_value_unset( &gvalue );
 975 }
 976
 977 wxDataViewCellMode wxDataViewRenderer::GetMode() const
 978 {
 979     wxDataViewCellMode ret;
 980
 981     GValue gvalue;
 982     g_object_get( G_OBJECT(m_renderer), "mode", &gvalue, NULL);
 983
 984     switch (g_value_get_enum(&gvalue))
 985     {
 986     case GTK_CELL_RENDERER_MODE_INERT:
 987         ret = wxDATAVIEW_CELL_INERT;
 988         break;
 989     case GTK_CELL_RENDERER_MODE_ACTIVATABLE:
 990         ret = wxDATAVIEW_CELL_ACTIVATABLE;
 991         break;
 992     case GTK_CELL_RENDERER_MODE_EDITABLE:
 993         ret = wxDATAVIEW_CELL_EDITABLE;
 994         break;
 995     }
 996
 997     g_value_unset( &gvalue );
 998
 999     return ret;
1000 }
1001
1002 void wxDataViewRenderer::SetAlignment( int align )
1003 {
1004     // horizontal alignment:
1005
1006     gfloat xalign = 0.0;
1007     if (align & wxALIGN_RIGHT)
1008         xalign = 1.0;
1009     else if (align & wxALIGN_CENTER_HORIZONTAL)
1010         xalign = 0.5;
1011
1012     GValue gvalue = { 0, };
1013     g_value_init( &gvalue, G_TYPE_FLOAT );
1014     g_value_set_float( &gvalue, xalign );
1015     g_object_set_property( G_OBJECT(m_renderer), "xalign", &gvalue );
1016     g_value_unset( &gvalue );
1017
1018     // vertical alignment:
1019
1020     gfloat yalign = 0.0;
1021     if (align & wxALIGN_BOTTOM)
1022         yalign = 1.0;
1023     else if (align & wxALIGN_CENTER_VERTICAL)
1024         yalign = 0.5;
1025
1026     GValue gvalue2 = { 0, };
1027     g_value_init( &gvalue2, G_TYPE_FLOAT );
1028     g_value_set_float( &gvalue2, yalign );
1029     g_object_set_property( G_OBJECT(m_renderer), "yalign", &gvalue2 );
1030     g_value_unset( &gvalue2 );
1031 }
1032
1033 int wxDataViewRenderer::GetAlignment() const
1034 {
1035     int ret = 0;
1036     GValue gvalue;
1037
1038     // horizontal alignment:
1039
1040     g_object_get( G_OBJECT(m_renderer), "xalign", &gvalue, NULL );
1041     float xalign = g_value_get_float( &gvalue );
1042     if (xalign < 0.5)
1043         ret |= wxALIGN_LEFT;
1044     else if (xalign == 0.5)
1045         ret |= wxALIGN_CENTER_HORIZONTAL;
1046     else
1047         ret |= wxALIGN_RIGHT;
1048     g_value_unset( &gvalue );
1049
1050
1051     // vertical alignment:
1052
1053     g_object_get( G_OBJECT(m_renderer), "yalign", &gvalue, NULL );
1054     float yalign = g_value_get_float( &gvalue );
1055     if (yalign < 0.5)
1056         ret |= wxALIGN_TOP;
1057     else if (yalign == 0.5)
1058         ret |= wxALIGN_CENTER_VERTICAL;
1059     else
1060         ret |= wxALIGN_BOTTOM;
1061     g_value_unset( &gvalue );
1062
1063     return ret;
1064 }
1065
1066
1067
1068 // ---------------------------------------------------------
1069 // wxDataViewTextRenderer
1070 // ---------------------------------------------------------
1071
1072 extern "C" {
1073 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *renderer,
1074     gchar *arg1, gchar *arg2, gpointer user_data );
1075 }
1076
1077 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *renderer,
1078     gchar *arg1, gchar *arg2, gpointer user_data )
1079 {
1080     wxDataViewTextRenderer *cell = (wxDataViewTextRenderer*) user_data;
1081
1082     wxString tmp = wxGTK_CONV_BACK_FONT(arg2, cell->GetOwner()->GetOwner()->GetFont());
1083     wxVariant value = tmp;
1084     if (!cell->Validate( value ))
1085         return;
1086
1087     wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
1088
1089     GtkTreePath *path = gtk_tree_path_new_from_string( arg1 );
1090     unsigned int model_row = (unsigned int)gtk_tree_path_get_indices (path)[0];
1091     gtk_tree_path_free( path );
1092
1093     unsigned int model_col = cell->GetOwner()->GetModelColumn();
1094
1095     model->SetValue( value, model_col, model_row );
1096     model->ValueChanged( model_col, model_row );
1097 }
1098
1099 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer)
1100
1101 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1102                                                 int align ) :
1103     wxDataViewRenderer( varianttype, mode, align )
1104 {
1105     m_renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new();
1106
1107     if (mode & wxDATAVIEW_CELL_EDITABLE)
1108     {
1109         GValue gvalue = { 0, };
1110         g_value_init( &gvalue, G_TYPE_BOOLEAN );
1111         g_value_set_boolean( &gvalue, true );
1112         g_object_set_property( G_OBJECT(m_renderer), "editable", &gvalue );
1113         g_value_unset( &gvalue );
1114
1115         g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
1116     }
1117
1118     SetMode(mode);
1119     SetAlignment(align);
1120 }
1121
1122 bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
1123 {
1124     wxString tmp = value;
1125
1126     GValue gvalue = { 0, };
1127     g_value_init( &gvalue, G_TYPE_STRING );
1128     g_value_set_string( &gvalue, wxGTK_CONV_FONT( tmp, GetOwner()->GetOwner()->GetFont() ) );
1129     g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
1130     g_value_unset( &gvalue );
1131
1132     return true;
1133 }
1134
1135 bool wxDataViewTextRenderer::GetValue( wxVariant &value ) const
1136 {
1137     GValue gvalue = { 0, };
1138     g_value_init( &gvalue, G_TYPE_STRING );
1139     g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
1140     wxString tmp = wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue ),
1141         wx_const_cast(wxDataViewTextRenderer*, this)->GetOwner()->GetOwner()->GetFont() );
1142     g_value_unset( &gvalue );
1143
1144     value = tmp;
1145
1146     return true;
1147 }
1148
1149 void wxDataViewTextRenderer::SetAlignment( int align )
1150 {
1151     wxDataViewRenderer::SetAlignment(align);
1152
1153     if (gtk_check_version(2,10,0))
1154         return;
1155
1156     // horizontal alignment:
1157     PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
1158     if (align & wxALIGN_RIGHT)
1159         pangoAlign = PANGO_ALIGN_RIGHT;
1160     else if (align & wxALIGN_CENTER_HORIZONTAL)
1161         pangoAlign = PANGO_ALIGN_CENTER;
1162
1163     GValue gvalue = { 0, };
1164     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1165     g_value_set_enum( &gvalue, pangoAlign );
1166     g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
1167     g_value_unset( &gvalue );
1168 }
1169
1170 // ---------------------------------------------------------
1171 // wxDataViewBitmapRenderer
1172 // ---------------------------------------------------------
1173
1174 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer)
1175
1176 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1177                                                     int align ) :
1178     wxDataViewRenderer( varianttype, mode, align )
1179 {
1180     m_renderer = (GtkCellRenderer*) gtk_cell_renderer_pixbuf_new();
1181
1182     SetMode(mode);
1183     SetAlignment(align);
1184 }
1185
1186 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
1187 {
1188     if (value.GetType() == wxT("wxBitmap"))
1189     {
1190         wxBitmap bitmap;
1191         bitmap << value;
1192
1193         // This may create a Pixbuf representation in the
1194         // wxBitmap object (and it will stay there)
1195         GdkPixbuf *pixbuf = bitmap.GetPixbuf();
1196
1197         GValue gvalue = { 0, };
1198         g_value_init( &gvalue, G_TYPE_OBJECT );
1199         g_value_set_object( &gvalue, pixbuf );
1200         g_object_set_property( G_OBJECT(m_renderer), "pixbuf", &gvalue );
1201         g_value_unset( &gvalue );
1202
1203         return true;
1204     }
1205
1206     if (value.GetType() == wxT("wxIcon"))
1207     {
1208         wxIcon bitmap;
1209         bitmap << value;
1210
1211         // This may create a Pixbuf representation in the
1212         // wxBitmap object (and it will stay there)
1213         GdkPixbuf *pixbuf = bitmap.GetPixbuf();
1214
1215         GValue gvalue = { 0, };
1216         g_value_init( &gvalue, G_TYPE_OBJECT );
1217         g_value_set_object( &gvalue, pixbuf );
1218         g_object_set_property( G_OBJECT(m_renderer), "pixbuf", &gvalue );
1219         g_value_unset( &gvalue );
1220
1221         return true;
1222     }
1223
1224     return false;
1225 }
1226
1227 bool wxDataViewBitmapRenderer::GetValue( wxVariant &value ) const
1228 {
1229     return false;
1230 }
1231
1232 // ---------------------------------------------------------
1233 // wxDataViewToggleRenderer
1234 // ---------------------------------------------------------
1235
1236 extern "C" {
1237 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
1238     gchar *path, gpointer user_data );
1239 }
1240
1241 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
1242     gchar *path, gpointer user_data )
1243 {
1244     wxDataViewToggleRenderer *cell = (wxDataViewToggleRenderer*) user_data;
1245
1246     // get old value
1247     GValue gvalue = { 0, };
1248     g_value_init( &gvalue, G_TYPE_BOOLEAN );
1249     g_object_get_property( G_OBJECT(renderer), "active", &gvalue );
1250     bool tmp = g_value_get_boolean( &gvalue );
1251     g_value_unset( &gvalue );
1252     // invert it
1253     tmp = !tmp;
1254
1255     wxVariant value = tmp;
1256     if (!cell->Validate( value ))
1257         return;
1258
1259     wxDataViewListModel *model = cell->GetOwner()->GetOwner()->GetModel();
1260
1261     GtkTreePath *gtk_path = gtk_tree_path_new_from_string( path );
1262     unsigned int model_row = (unsigned int)gtk_tree_path_get_indices (gtk_path)[0];
1263     gtk_tree_path_free( gtk_path );
1264
1265     unsigned int model_col = cell->GetOwner()->GetModelColumn();
1266
1267     model->SetValue( value, model_col, model_row );
1268     model->ValueChanged( model_col, model_row );
1269 }
1270
1271 IMPLEMENT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer)
1272
1273 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
1274                                                     wxDataViewCellMode mode, int align ) :
1275     wxDataViewRenderer( varianttype, mode, align )
1276 {
1277     m_renderer = (GtkCellRenderer*) gtk_cell_renderer_toggle_new();
1278
1279     if (mode & wxDATAVIEW_CELL_ACTIVATABLE)
1280     {
1281         g_signal_connect_after( m_renderer, "toggled",
1282                                 G_CALLBACK(wxGtkToggleRendererToggledCallback), this );
1283     }
1284     else
1285     {
1286         GValue gvalue = { 0, };
1287         g_value_init( &gvalue, G_TYPE_BOOLEAN );
1288         g_value_set_boolean( &gvalue, false );
1289         g_object_set_property( G_OBJECT(m_renderer), "activatable", &gvalue );
1290         g_value_unset( &gvalue );
1291     }
1292
1293     SetMode(mode);
1294     SetAlignment(align);
1295 }
1296
1297 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
1298 {
1299     bool tmp = value;
1300
1301     GValue gvalue = { 0, };
1302     g_value_init( &gvalue, G_TYPE_BOOLEAN );
1303     g_value_set_boolean( &gvalue, tmp );
1304     g_object_set_property( G_OBJECT(m_renderer), "active", &gvalue );
1305     g_value_unset( &gvalue );
1306
1307     return true;
1308 }
1309
1310 bool wxDataViewToggleRenderer::GetValue( wxVariant &value ) const
1311 {
1312     GValue gvalue = { 0, };
1313     g_value_init( &gvalue, G_TYPE_BOOLEAN );
1314     g_object_get_property( G_OBJECT(m_renderer), "active", &gvalue );
1315     bool tmp = g_value_get_boolean( &gvalue );
1316     g_value_unset( &gvalue );
1317
1318     value = tmp;
1319
1320     return true;
1321 }
1322
1323 // ---------------------------------------------------------
1324 // wxDataViewCustomRenderer
1325 // ---------------------------------------------------------
1326
1327 class wxDataViewCtrlDC: public wxWindowDC
1328 {
1329 public:
1330     wxDataViewCtrlDC( wxDataViewCtrl *window )
1331     {
1332         GtkWidget *widget = window->m_treeview;
1333         // Set later
1334         m_window = NULL;
1335
1336         m_context = window->GtkGetPangoDefaultContext();
1337         m_layout = pango_layout_new( m_context );
1338         m_fontdesc = pango_font_description_copy( widget->style->font_desc );
1339
1340         m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
1341
1342         // Set m_window later
1343         // SetUpDC();
1344         // m_owner = window;
1345     }
1346 };
1347
1348 // ---------------------------------------------------------
1349 // wxDataViewCustomRenderer
1350 // ---------------------------------------------------------
1351
1352 IMPLEMENT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
1353
1354 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
1355                                                     wxDataViewCellMode mode, int align,
1356                                                     bool no_init ) :
1357     wxDataViewRenderer( varianttype, mode, align )
1358 {
1359     m_dc = NULL;
1360
1361     if (no_init)
1362         m_renderer = NULL;
1363     else
1364         Init(mode, align);
1365 }
1366
1367 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode, int align)
1368 {
1369     GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
1370     renderer->cell = this;
1371
1372     m_renderer = (GtkCellRenderer*) renderer;
1373
1374     SetMode(mode);
1375     SetAlignment(align);
1376
1377     return true;
1378 }
1379
1380 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
1381 {
1382     if (m_dc)
1383         delete m_dc;
1384 }
1385
1386 wxDC *wxDataViewCustomRenderer::GetDC()
1387 {
1388     if (m_dc == NULL)
1389     {
1390         if (GetOwner() == NULL)
1391             return NULL;
1392         if (GetOwner()->GetOwner() == NULL)
1393             return NULL;
1394         m_dc = new wxDataViewCtrlDC( GetOwner()->GetOwner() );
1395     }
1396
1397     return m_dc;
1398 }
1399
1400 // ---------------------------------------------------------
1401 // wxDataViewProgressRenderer
1402 // ---------------------------------------------------------
1403
1404 IMPLEMENT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
1405
1406 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
1407     const wxString &varianttype, wxDataViewCellMode mode, int align ) :
1408     wxDataViewCustomRenderer( varianttype, mode, align, true )
1409 {
1410     m_label = label;
1411     m_value = 0;
1412
1413 #ifdef __WXGTK26__
1414     if (!gtk_check_version(2,6,0))
1415     {
1416         m_renderer = (GtkCellRenderer*) gtk_cell_renderer_progress_new();
1417
1418         GValue gvalue = { 0, };
1419         g_value_init( &gvalue, G_TYPE_STRING );
1420
1421         // FIXME: font encoding support
1422         g_value_set_string( &gvalue, wxGTK_CONV_SYS(m_label) );
1423         g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
1424         g_value_unset( &gvalue );
1425
1426         SetMode(mode);
1427         SetAlignment(align);
1428     }
1429     else
1430 #endif
1431     {
1432         // Use custom cell code
1433         wxDataViewCustomRenderer::Init(mode, align);
1434     }
1435 }
1436
1437 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
1438 {
1439 }
1440
1441 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
1442 {
1443 #ifdef __WXGTK26__
1444     if (!gtk_check_version(2,6,0))
1445     {
1446         gint tmp = (long) value;
1447         GValue gvalue = { 0, };
1448         g_value_init( &gvalue, G_TYPE_INT );
1449         g_value_set_int( &gvalue, tmp );
1450         g_object_set_property( G_OBJECT(m_renderer), "value", &gvalue );
1451         g_value_unset( &gvalue );
1452     }
1453     else
1454 #endif
1455     {
1456         m_value = (long) value;
1457
1458         if (m_value < 0) m_value = 0;
1459         if (m_value > 100) m_value = 100;
1460     }
1461
1462     return true;
1463 }
1464
1465 bool wxDataViewProgressRenderer::GetValue( wxVariant &value ) const
1466 {
1467     return false;
1468 }
1469
1470 bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int state )
1471 {
1472     double pct = (double)m_value / 100.0;
1473     wxRect bar = cell;
1474     bar.width = (int)(cell.width * pct);
1475     dc->SetPen( *wxTRANSPARENT_PEN );
1476     dc->SetBrush( *wxBLUE_BRUSH );
1477     dc->DrawRectangle( bar );
1478
1479     dc->SetBrush( *wxTRANSPARENT_BRUSH );
1480     dc->SetPen( *wxBLACK_PEN );
1481     dc->DrawRectangle( cell );
1482
1483     return true;
1484 }
1485
1486 wxSize wxDataViewProgressRenderer::GetSize() const
1487 {
1488     return wxSize(40,12);
1489 }
1490
1491 // ---------------------------------------------------------
1492 // wxDataViewDateRenderer
1493 // ---------------------------------------------------------
1494
1495 class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
1496 {
1497 public:
1498     wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
1499         wxDataViewListModel *model, unsigned int col, unsigned int row ) :
1500         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
1501     {
1502         m_model = model;
1503         m_col = col;
1504         m_row = row;
1505         m_cal = new wxCalendarCtrl( this, -1, *value );
1506         wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
1507         sizer->Add( m_cal, 1, wxGROW );
1508         SetSizer( sizer );
1509         sizer->Fit( this );
1510     }
1511
1512     virtual void OnDismiss()
1513     {
1514     }
1515
1516     void OnCalendar( wxCalendarEvent &event );
1517
1518     wxCalendarCtrl      *m_cal;
1519     wxDataViewListModel *m_model;
1520     unsigned int               m_col;
1521     unsigned int               m_row;
1522
1523 private:
1524     DECLARE_EVENT_TABLE()
1525 };
1526
1527 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
1528     EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient::OnCalendar )
1529 END_EVENT_TABLE()
1530
1531 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
1532 {
1533     wxDateTime date = event.GetDate();
1534     wxVariant value = date;
1535     m_model->SetValue( value, m_col, m_row );
1536     m_model->ValueChanged( m_col, m_row );
1537     DismissAndNotify();
1538 }
1539
1540 IMPLEMENT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
1541
1542 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
1543                         wxDataViewCellMode mode, int align ) :
1544     wxDataViewCustomRenderer( varianttype, mode, align )
1545 {
1546     SetMode(mode);
1547     SetAlignment(align);
1548 }
1549
1550 bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
1551 {
1552     m_date = value.GetDateTime();
1553
1554     return true;
1555 }
1556
1557 bool wxDataViewDateRenderer::GetValue( wxVariant &value ) const
1558 {
1559     return false;
1560 }
1561
1562 bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int state )
1563 {
1564     dc->SetFont( GetOwner()->GetOwner()->GetFont() );
1565     wxString tmp = m_date.FormatDate();
1566     dc->DrawText( tmp, cell.x, cell.y );
1567
1568     return true;
1569 }
1570
1571 wxSize wxDataViewDateRenderer::GetSize() const
1572 {
1573     wxString tmp = m_date.FormatDate();
1574     wxCoord x,y,d;
1575     GetView()->GetTextExtent( tmp, &x, &y, &d );
1576     return wxSize(x,y+d);
1577 }
1578
1579 bool wxDataViewDateRenderer::Activate( wxRect cell, wxDataViewListModel *model,
1580                                        unsigned int col, unsigned int row )
1581 {
1582     wxVariant variant;
1583     model->GetValue( variant, col, row );
1584     wxDateTime value = variant.GetDateTime();
1585
1586     wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
1587         GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
1588     wxPoint pos = wxGetMousePosition();
1589     popup->Move( pos );
1590     popup->Layout();
1591     popup->Popup( popup->m_cal );
1592
1593     return true;
1594 }
1595
1596 // ---------------------------------------------------------
1597 // wxDataViewColumn
1598 // ---------------------------------------------------------
1599
1600
1601 static gboolean
1602 gtk_dataview_header_button_press_callback( GtkWidget *widget,
1603                                            GdkEventButton *gdk_event,
1604                                            wxDataViewColumn *column )
1605 {
1606     if (gdk_event->type != GDK_BUTTON_PRESS)
1607         return TRUE;
1608
1609     if (gdk_event->button == 1)
1610     {
1611         wxDataViewCtrl *dv = column->GetOwner();
1612         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
1613         event.SetDataViewColumn( column );
1614         event.SetModel( dv->GetModel() );
1615         dv->GetEventHandler()->ProcessEvent( event );
1616     }
1617
1618     return TRUE;
1619 }
1620
1621 extern "C" {
1622 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *column,
1623                             GtkCellRenderer *cell,
1624                             GtkTreeModel *model,
1625                             GtkTreeIter *iter,
1626                             gpointer data );
1627 }
1628
1629
1630 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *column,
1631                             GtkCellRenderer *renderer,
1632                             GtkTreeModel *model,
1633                             GtkTreeIter *iter,
1634                             gpointer data )
1635 {
1636     g_return_if_fail (GTK_IS_WX_LIST_STORE (model));
1637     GtkWxListStore *list_store = (GtkWxListStore *) model;
1638
1639     wxDataViewRenderer *cell = (wxDataViewRenderer*) data;
1640
1641     unsigned int model_row = wxPtrToUInt(iter->user_data);
1642
1643     wxVariant value;
1644     list_store->model->GetValue( value, cell->GetOwner()->GetModelColumn(), model_row );
1645
1646     if (value.GetType() != cell->GetVariantType())
1647         wxLogError( wxT("Wrong type, required: %s but: %s"),
1648                     value.GetType().c_str(),
1649                     cell->GetVariantType().c_str() );
1650
1651     cell->SetValue( value );
1652
1653     wxListItemAttr attr;
1654     list_store->model->GetAttr( attr, cell->GetOwner()->GetModelColumn(), model_row );
1655
1656     if (attr.HasBackgroundColour())
1657     {
1658         wxColour colour = attr.GetBackgroundColour();
1659         GdkColor *gcol = colour.GetColor();
1660
1661         GValue gvalue = { 0, };
1662         g_value_init( &gvalue, GDK_TYPE_COLOR );
1663         g_value_set_boxed( &gvalue, gcol );
1664         g_object_set_property( G_OBJECT(renderer), "cell-background_gdk", &gvalue );
1665         g_value_unset( &gvalue );
1666     }
1667     else
1668     {
1669         GValue gvalue = { 0, };
1670         g_value_init( &gvalue, G_TYPE_BOOLEAN );
1671         g_value_set_boolean( &gvalue, FALSE );
1672         g_object_set_property( G_OBJECT(renderer), "cell-background-set", &gvalue );
1673         g_value_unset( &gvalue );
1674     }
1675 }
1676
1677 IMPLEMENT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
1678
1679 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell,
1680                                     unsigned int model_column, int width,
1681                                     wxAlignment align, int flags ) :
1682     wxDataViewColumnBase( title, cell, model_column, width, align, flags )
1683 {
1684     Init( align, flags, width );
1685
1686     gtk_tree_view_column_set_clickable( GTK_TREE_VIEW_COLUMN(m_column), TRUE );
1687     SetTitle( title );
1688 }
1689
1690 wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell,
1691                                     unsigned int model_column, int width,
1692                                     wxAlignment align, int flags ) :
1693     wxDataViewColumnBase( bitmap, cell, model_column, width, align, flags )
1694 {
1695     Init( align, flags, width );
1696
1697     SetBitmap( bitmap );
1698 }
1699
1700 void wxDataViewColumn::Init(wxAlignment align, int flags, int width)
1701 {
1702     m_isConnected = false;
1703
1704     GtkCellRenderer *renderer = (GtkCellRenderer *) GetRenderer()->GetGtkHandle();
1705     GtkTreeViewColumn *column = gtk_tree_view_column_new();
1706     m_column = (GtkWidget*) column;
1707
1708     SetFlags( flags );
1709     SetAlignment( align );
1710
1711     // NOTE: we prefer not to call SetMinWidth(wxDVC_DEFAULT_MINWIDTH);
1712     //       as GTK+ is smart and unless explicitely told, will set the minimal
1713     //       width to the title's lenght, which is a better default
1714
1715     // the GTK_TREE_VIEW_COLUMN_FIXED is required by the "fixed height" mode
1716     // that we use for the wxDataViewCtrl
1717     gtk_tree_view_column_set_fixed_width( column, width < 0 ? wxDVC_DEFAULT_WIDTH : width );
1718     gtk_tree_view_column_set_sizing( column, GTK_TREE_VIEW_COLUMN_FIXED );
1719
1720     gtk_tree_view_column_pack_end( column, renderer, TRUE );
1721
1722     gtk_tree_view_column_set_cell_data_func( column, renderer,
1723         wxGtkTreeCellDataFunc, (gpointer) GetRenderer(), NULL );
1724 }
1725
1726 wxDataViewColumn::~wxDataViewColumn()
1727 {
1728 }
1729
1730 void wxDataViewColumn::OnInternalIdle()
1731 {
1732     if (m_isConnected)
1733         return;
1734
1735     if (GTK_WIDGET_REALIZED(GetOwner()->m_treeview))
1736     {
1737         GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1738         if (column->button)
1739         {
1740             g_signal_connect(column->button, "button_press_event",
1741                       G_CALLBACK (gtk_dataview_header_button_press_callback), this);
1742
1743             m_isConnected = true;
1744         }
1745     }
1746 }
1747
1748 void wxDataViewColumn::SetOwner( wxDataViewCtrl *owner )
1749 {
1750     wxDataViewColumnBase::SetOwner( owner );
1751
1752     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1753
1754     gtk_tree_view_column_set_title( column, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
1755 }
1756
1757 void wxDataViewColumn::SetTitle( const wxString &title )
1758 {
1759     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1760
1761     if (m_isConnected)
1762     {
1763         // disconnect before column->button gets recreated
1764         g_signal_handlers_disconnect_by_func( column->button,
1765                       (GtkWidget*) gtk_dataview_header_button_press_callback, this);
1766
1767         m_isConnected = false;
1768     }
1769
1770     // FIXME: can it really happen that we don't have the owner here??
1771     wxDataViewCtrl *ctrl = GetOwner();
1772     gtk_tree_view_column_set_title( column, ctrl ? wxGTK_CONV_FONT(title, ctrl->GetFont())
1773                                                  : wxGTK_CONV_SYS(title) );
1774
1775     gtk_tree_view_column_set_widget( column, NULL );
1776 }
1777
1778 wxString wxDataViewColumn::GetTitle() const
1779 {
1780     const gchar *str = gtk_tree_view_column_get_title( GTK_TREE_VIEW_COLUMN(m_column) );
1781     return wxConvFileName->cMB2WX(str);
1782 }
1783
1784 void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
1785 {
1786     wxDataViewColumnBase::SetBitmap( bitmap );
1787
1788     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1789     if (bitmap.Ok())
1790     {
1791         GtkImage *gtk_image = GTK_IMAGE( gtk_image_new() );
1792
1793         GdkBitmap *mask = (GdkBitmap *) NULL;
1794         if (bitmap.GetMask())
1795             mask = bitmap.GetMask()->GetBitmap();
1796
1797         if (bitmap.HasPixbuf())
1798         {
1799             gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image),
1800                                       bitmap.GetPixbuf());
1801         }
1802         else
1803         {
1804             gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image),
1805                                       bitmap.GetPixmap(), mask);
1806         }
1807         gtk_widget_show( GTK_WIDGET(gtk_image) );
1808
1809         gtk_tree_view_column_set_widget( column, GTK_WIDGET(gtk_image) );
1810     }
1811     else
1812     {
1813         gtk_tree_view_column_set_widget( column, NULL );
1814     }
1815 }
1816
1817 void wxDataViewColumn::SetHidden( bool hidden )
1818 {
1819     gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column), !hidden );
1820 }
1821
1822 void wxDataViewColumn::SetResizeable( bool resizeable )
1823 {
1824     gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizeable );
1825 }
1826
1827 void wxDataViewColumn::SetAlignment( wxAlignment align )
1828 {
1829     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1830
1831     gfloat xalign = 0.0;
1832     if (align == wxALIGN_RIGHT)
1833         xalign = 1.0;
1834     if (align == wxALIGN_CENTER_HORIZONTAL ||
1835         align == wxALIGN_CENTER)
1836         xalign = 0.5;
1837
1838     gtk_tree_view_column_set_alignment( column, xalign );
1839 }
1840
1841 wxAlignment wxDataViewColumn::GetAlignment() const
1842 {
1843     gfloat xalign = gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column) );
1844
1845     if (xalign == 1.0)
1846         return wxALIGN_RIGHT;
1847     if (xalign == 0.5)
1848         return wxALIGN_CENTER_HORIZONTAL;
1849
1850     return wxALIGN_LEFT;
1851 }
1852
1853 void wxDataViewColumn::SetSortable( bool sortable )
1854 {
1855     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1856     gtk_tree_view_column_set_sort_indicator( column, sortable );
1857 }
1858
1859 bool wxDataViewColumn::IsSortable() const
1860 {
1861     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1862     return gtk_tree_view_column_get_sort_indicator( column );
1863 }
1864
1865 bool wxDataViewColumn::IsResizeable() const
1866 {
1867     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1868     return gtk_tree_view_column_get_resizable( column );
1869 }
1870
1871 bool wxDataViewColumn::IsHidden() const
1872 {
1873     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1874     return !gtk_tree_view_column_get_visible( column );
1875 }
1876
1877 void wxDataViewColumn::SetSortOrder( bool ascending )
1878 {
1879     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1880
1881     if (ascending)
1882         gtk_tree_view_column_set_sort_order( column, GTK_SORT_ASCENDING );
1883     else
1884         gtk_tree_view_column_set_sort_order( column, GTK_SORT_DESCENDING );
1885 }
1886
1887 bool wxDataViewColumn::IsSortOrderAscending() const
1888 {
1889     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
1890
1891     return (gtk_tree_view_column_get_sort_order( column ) != GTK_SORT_DESCENDING);
1892 }
1893
1894 void wxDataViewColumn::SetMinWidth( int width )
1895 {
1896     gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column), width );
1897 }
1898
1899 int wxDataViewColumn::GetMinWidth() const
1900 {
1901     return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column) );
1902 }
1903
1904 int wxDataViewColumn::GetWidth() const
1905 {
1906     return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column) );
1907 }
1908
1909 void wxDataViewColumn::SetWidth( int width )
1910 {
1911     gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column), width );
1912 }
1913
1914
1915 //-----------------------------------------------------------------------------
1916 // wxDataViewCtrl signal callbacks
1917 //-----------------------------------------------------------------------------
1918
1919 static void
1920 wxdataview_selection_changed_callback( GtkTreeSelection* selection, wxDataViewCtrl *dv )
1921 {
1922     if (!GTK_WIDGET_REALIZED(dv->m_widget))
1923         return;
1924
1925     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ROW_SELECTED, dv->GetId() );
1926     event.SetRow( dv->GetSelection() );
1927     event.SetModel( dv->GetModel() );
1928     dv->GetEventHandler()->ProcessEvent( event );
1929 }
1930
1931 static void
1932 wxdataview_row_activated_callback( GtkTreeView* treeview, GtkTreePath *path,
1933                                    GtkTreeViewColumn *column, wxDataViewCtrl *dv )
1934 {
1935     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ROW_ACTIVATED, dv->GetId() );
1936     unsigned int row = (unsigned int)gtk_tree_path_get_indices (path)[0];
1937     event.SetRow( row );
1938     event.SetModel( dv->GetModel() );
1939     dv->GetEventHandler()->ProcessEvent( event );
1940 }
1941
1942 //-----------------------------------------------------------------------------
1943 // wxDataViewCtrl
1944 //-----------------------------------------------------------------------------
1945
1946 //-----------------------------------------------------------------------------
1947 // InsertChild for wxDataViewCtrl
1948 //-----------------------------------------------------------------------------
1949
1950 static void wxInsertChildInDataViewCtrl( wxWindowGTK* parent, wxWindowGTK* child )
1951 {
1952     wxDataViewCtrl * dvc = (wxDataViewCtrl*) parent;
1953     GtkWidget *treeview = dvc->GtkGetTreeView();
1954
1955     // Insert widget in GtkTreeView
1956     if (GTK_WIDGET_REALIZED(treeview))
1957         gtk_widget_set_parent_window( child->m_widget,
1958           gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview) ) );
1959     gtk_widget_set_parent( child->m_widget, treeview );
1960 }
1961
1962 static
1963 void gtk_dataviewctrl_size_callback( GtkWidget *WXUNUSED(widget),
1964                                      GtkAllocation *alloc,
1965                                      wxDataViewCtrl *win )
1966 {
1967
1968     wxWindowList::Node *node = win->GetChildren().GetFirst();
1969     while (node)
1970     {
1971         wxWindow *child = node->GetData();
1972
1973         GtkRequisition req;
1974         gtk_widget_size_request( child->m_widget, &req );
1975
1976         GtkAllocation alloc;
1977         alloc.x = child->m_x;
1978         alloc.y = child->m_y;
1979         alloc.width = child->m_width;
1980         alloc.height = child->m_height;
1981         gtk_widget_size_allocate( child->m_widget, &alloc );
1982
1983         node = node->GetNext();
1984     }
1985 }
1986
1987
1988
1989 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
1990
1991 wxDataViewCtrl::~wxDataViewCtrl()
1992 {
1993     if (m_notifier)
1994         GetModel()->RemoveNotifier( m_notifier );
1995
1996     // remove the model from the GtkTreeView before it gets destroyed by the
1997     // wxDataViewCtrlBase's dtor
1998     gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview), NULL );
1999 }
2000
2001 void wxDataViewCtrl::Init()
2002 {
2003     m_notifier = NULL;
2004 }
2005
2006 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
2007            const wxPoint& pos, const wxSize& size,
2008            long style, const wxValidator& validator )
2009 {
2010     Init();
2011
2012     if (!PreCreation( parent, pos, size ) ||
2013         !CreateBase( parent, id, pos, size, style, validator ))
2014     {
2015         wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
2016         return false;
2017     }
2018
2019     m_insertCallback = wxInsertChildInDataViewCtrl;
2020
2021     m_widget = gtk_scrolled_window_new (NULL, NULL);
2022
2023     GtkScrolledWindowSetBorder(m_widget, style);
2024
2025     m_treeview = gtk_tree_view_new();
2026     gtk_container_add (GTK_CONTAINER (m_widget), m_treeview);
2027
2028     g_signal_connect (m_treeview, "size_allocate",
2029                      G_CALLBACK (gtk_dataviewctrl_size_callback), this);
2030
2031 #ifdef __WXGTK26__
2032     if (!gtk_check_version(2,6,0))
2033         gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), TRUE );
2034 #endif
2035
2036     if (style & wxDV_MULTIPLE)
2037     {
2038         GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2039         gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
2040     }
2041
2042     gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview), (style & wxDV_NO_HEADER) == 0 );
2043
2044 #ifdef __WXGTK210__
2045     if (!gtk_check_version(2,10,0))
2046     {
2047         GtkTreeViewGridLines grid = GTK_TREE_VIEW_GRID_LINES_NONE;
2048
2049         if ((style & wxDV_HORIZ_RULES) != 0 &&
2050             (style & wxDV_VERT_RULES) != 0)
2051             grid = GTK_TREE_VIEW_GRID_LINES_BOTH;
2052         else if (style & wxDV_VERT_RULES)
2053             grid = GTK_TREE_VIEW_GRID_LINES_VERTICAL;
2054         else if (style & wxDV_HORIZ_RULES)
2055             grid = GTK_TREE_VIEW_GRID_LINES_HORIZONTAL;
2056
2057         gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview), grid );
2058     }
2059     else
2060 #endif
2061     {
2062         gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview), (style & wxDV_HORIZ_RULES) != 0 );
2063     }
2064
2065     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget),
2066         GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
2067     gtk_widget_show (m_treeview);
2068
2069     m_parent->DoAddChild( this );
2070
2071     PostCreation(size);
2072
2073     GtkEnableSelectionEvents();
2074
2075     g_signal_connect_after (m_treeview, "row_activated",
2076                             G_CALLBACK (wxdataview_row_activated_callback), this);
2077
2078     return true;
2079 }
2080
2081 void wxDataViewCtrl::OnInternalIdle()
2082 {
2083     wxWindow::OnInternalIdle();
2084
2085     unsigned int cols = GetColumnCount();
2086     unsigned int i;
2087     for (i = 0; i < cols; i++)
2088     {
2089         wxDataViewColumn *col = GetColumn( i );
2090         col->OnInternalIdle();
2091     }
2092 }
2093
2094 bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
2095 {
2096     if (!wxDataViewCtrlBase::AssociateModel( model ))
2097         return false;
2098
2099     GtkWxListStore *gtk_store = wxgtk_list_store_new();
2100     gtk_store->model = model;
2101
2102     m_notifier = new wxGtkDataViewListModelNotifier( gtk_store, model, this );
2103
2104     model->AddNotifier( m_notifier );
2105
2106     gtk_tree_view_set_model( GTK_TREE_VIEW(m_treeview), GTK_TREE_MODEL(gtk_store) );
2107     g_object_unref( gtk_store );
2108
2109     return true;
2110 }
2111
2112 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
2113 {
2114     if (!wxDataViewCtrlBase::AppendColumn(col))
2115         return false;
2116
2117     GtkTreeViewColumn *column = (GtkTreeViewColumn *)col->GetGtkHandle();
2118
2119     gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview), column );
2120
2121     return true;
2122 }
2123
2124 void wxDataViewCtrl::GtkDisableSelectionEvents()
2125 {
2126     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2127     g_signal_connect_after (selection, "changed",
2128                             G_CALLBACK (wxdataview_selection_changed_callback), this);
2129 }
2130
2131 void wxDataViewCtrl::GtkEnableSelectionEvents()
2132 {
2133     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2134     g_signal_handlers_disconnect_by_func( selection,
2135                             (gpointer) (wxdataview_selection_changed_callback), this);
2136 }
2137
2138 void wxDataViewCtrl::SetSelection( int row )
2139 {
2140     GtkDisableSelectionEvents();
2141
2142     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2143
2144     if (row < 0)
2145     {
2146         gtk_tree_selection_unselect_all( selection );
2147     }
2148     else
2149     {
2150         GtkTreePath *path = gtk_tree_path_new ();
2151         gtk_tree_path_append_index( path, row );
2152
2153         gtk_tree_selection_select_path( selection, path );
2154
2155         gtk_tree_path_free( path );
2156     }
2157
2158     GtkEnableSelectionEvents();
2159 }
2160
2161 void wxDataViewCtrl::Unselect( unsigned int row )
2162 {
2163     GtkDisableSelectionEvents();
2164
2165     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2166
2167     GtkTreePath *path = gtk_tree_path_new ();
2168     gtk_tree_path_append_index( path, row );
2169
2170     gtk_tree_selection_unselect_path( selection, path );
2171
2172     gtk_tree_path_free( path );
2173
2174     GtkEnableSelectionEvents();
2175 }
2176
2177 void wxDataViewCtrl::SetSelectionRange( unsigned int from, unsigned int to )
2178 {
2179     GtkDisableSelectionEvents();
2180
2181     if (from > to)
2182     {
2183         unsigned int tmp = from;
2184         from = to;
2185         to = tmp;
2186     }
2187
2188     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2189
2190     GtkTreePath *path_from = gtk_tree_path_new ();
2191     gtk_tree_path_append_index( path_from, from );
2192     GtkTreePath *path_to = gtk_tree_path_new ();
2193     gtk_tree_path_append_index( path_to, to );
2194
2195     gtk_tree_selection_select_range( selection, path_from, path_to );
2196
2197     gtk_tree_path_free( path_to );
2198     gtk_tree_path_free( path_from );
2199
2200     GtkEnableSelectionEvents();
2201 }
2202
2203 void wxDataViewCtrl::SetSelections( const wxArrayInt& aSelections)
2204 {
2205     GtkDisableSelectionEvents();
2206
2207     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2208
2209     unsigned int i;
2210     for (i = 0; i < aSelections.GetCount(); i++)
2211     {
2212         GtkTreePath *path = gtk_tree_path_new ();
2213         gtk_tree_path_append_index( path, aSelections[i] );
2214
2215         gtk_tree_selection_select_path( selection, path );
2216
2217         gtk_tree_path_free( path );
2218     }
2219
2220     GtkEnableSelectionEvents();
2221 }
2222
2223 bool wxDataViewCtrl::IsSelected( unsigned int row ) const
2224 {
2225     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2226
2227     GtkTreePath *path = gtk_tree_path_new ();
2228     gtk_tree_path_append_index( path, row );
2229
2230     gboolean ret =  gtk_tree_selection_path_is_selected( selection, path );
2231
2232     gtk_tree_path_free( path );
2233
2234     return ret;
2235 }
2236
2237 int wxDataViewCtrl::GetSelection() const
2238 {
2239     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2240     if (HasFlag(wxDV_MULTIPLE))
2241     {
2242         GtkTreeModel *model;
2243         GList *list = gtk_tree_selection_get_selected_rows( selection, &model );
2244
2245         // do something
2246         if (list)
2247         {
2248             // list = g_list_nth( list, 0 );  should be a noop
2249             GtkTreePath *path = (GtkTreePath*) list->data;
2250
2251             unsigned int row = (unsigned int)gtk_tree_path_get_indices (path)[0];
2252
2253             // delete list
2254             g_list_foreach( list, (GFunc) gtk_tree_path_free, NULL );
2255             g_list_free( list );
2256
2257             return (int) row;
2258         }
2259     }
2260     else
2261     {
2262
2263         GtkTreeModel *model;
2264         GtkTreeIter iter;
2265         gboolean has_selection = gtk_tree_selection_get_selected( selection, &model, &iter );
2266         if (has_selection)
2267         {
2268             unsigned int row = (wxUIntPtr) iter.user_data;
2269             return (int) row;
2270         }
2271     }
2272
2273     return -1;
2274 }
2275
2276 int wxDataViewCtrl::GetSelections(wxArrayInt& aSelections) const
2277 {
2278     aSelections.Clear();
2279
2280     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
2281     if (HasFlag(wxDV_MULTIPLE))
2282     {
2283         GtkTreeModel *model;
2284         GList *list = gtk_tree_selection_get_selected_rows( selection, &model );
2285
2286         int count = 0;
2287         while (list)
2288         {
2289
2290             // list = g_list_nth( list, 0 );  should be a noop
2291             GtkTreePath *path = (GtkTreePath*) list->data;
2292
2293             unsigned int row = (unsigned int)gtk_tree_path_get_indices (path)[0];
2294
2295             aSelections.Add( (int) row );
2296
2297             list = g_list_next( list );
2298         }
2299
2300         // delete list
2301         g_list_foreach( list, (GFunc) gtk_tree_path_free, NULL );
2302         g_list_free( list );
2303
2304         return count;
2305     }
2306     else
2307     {
2308         GtkTreeModel *model;
2309         GtkTreeIter iter;
2310         gboolean has_selection = gtk_tree_selection_get_selected( selection, &model, &iter );
2311         if (has_selection)
2312         {
2313             unsigned int row = (wxUIntPtr) iter.user_data;
2314             aSelections.Add( (int) row );
2315             return 1;
2316         }
2317     }
2318
2319     return 0;
2320 }
2321
2322 // static
2323 wxVisualAttributes
2324 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
2325 {
2326     return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new);
2327 }
2328
2329
2330 #endif
2331     // !wxUSE_GENERICDATAVIEWCTRL
2332
2333 #endif
2334     // wxUSE_DATAVIEWCTRL