src/gtk/dataview.cpp

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