src/gtk/dataview.cpp

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