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     #include "wx/settings.h"
  24     #include "wx/crt.h"
  25 #endif
  26
  27 #include "wx/stockitem.h"
  28 #include "wx/calctrl.h"
  29 #include "wx/popupwin.h"
  30 #include "wx/listimpl.cpp"
  31
  32 #include "wx/gtk/private.h"
  33 #include "wx/gtk/dc.h"
  34 #include "wx/gtk/dcclient.h"
  35
  36 #include "wx/gtk/private/gdkconv.h"
  37 using namespace wxGTKImpl;
  38
  39 class wxGtkDataViewModelNotifier;
  40
  41 //-----------------------------------------------------------------------------
  42 //-----------------------------------------------------------------------------
  43
  44 static wxDataViewCtrlInternal *gs_internal = NULL;
  45
  46 class wxGtkTreeModelNode;
  47
  48 extern "C" {
  49 typedef struct _GtkWxTreeModel       GtkWxTreeModel;
  50 }
  51
  52 // ----------------------------------------------------------------------------
  53 // wxGtkTreePath: self-destroying GtkTreePath
  54 // ----------------------------------------------------------------------------
  55
  56 // Usually this object is initialized with the associated GtkTreePath
  57 // immediately when it's constructed but it can also be changed later either by
  58 // using Assign() or by getting the pointer to the internally stored pointer
  59 // value using ByRef(). The latter should be avoided but is very convenient
  60 // when using GTK functions with GtkTreePath output parameters.
  61 class wxGtkTreePath
  62 {
  63 public:
  64     // Ctor takes ownership of the given path and will free it if non-NULL.
  65     wxGtkTreePath(GtkTreePath *path = NULL) : m_path(path) { }
  66
  67     // Creates a tree path for the given string path.
  68     wxGtkTreePath(const gchar *strpath)
  69         : m_path(gtk_tree_path_new_from_string(strpath))
  70     {
  71     }
  72
  73     // Set the stored pointer if not done by ctor.
  74     void Assign(GtkTreePath *path)
  75     {
  76         wxASSERT_MSG( !m_path, "shouldn't be already initialized" );
  77
  78         m_path = path;
  79     }
  80
  81     // Return the pointer to the internally stored pointer. This should only be
  82     // used to initialize the object by passing it to some GTK function.
  83     GtkTreePath **ByRef()
  84     {
  85         wxASSERT_MSG( !m_path, "shouldn't be already initialized" );
  86
  87         return &m_path;
  88     }
  89
  90
  91     operator GtkTreePath *() const { return m_path; }
  92
  93     ~wxGtkTreePath() { if ( m_path ) gtk_tree_path_free(m_path); }
  94
  95 private:
  96     GtkTreePath *m_path;
  97
  98     wxDECLARE_NO_COPY_CLASS(wxGtkTreePath);
  99 };
 100
 101 // ----------------------------------------------------------------------------
 102 // wxGtkTreeSelectionLock: prevent selection from changing during the
 103 //                                 lifetime of this object
 104 // ----------------------------------------------------------------------------
 105
 106 // Implementation note: it could be expected that setting the selection
 107 // function in this class ctor and resetting it back to the old value in its
 108 // dtor would work. However currently gtk_tree_selection_get_select_function()
 109 // can't be passed NULL (see https://bugzilla.gnome.org/show_bug.cgi?id=626276)
 110 // so we can't do this. Instead, we always use the selection function (which
 111 // imposes extra overhead, albeit minimal one, on all selection operations) and
 112 // just set/reset the flag telling it whether it should allow or forbid the
 113 // selection.
 114 //
 115 // Also notice that currently only a single object of this class may exist at
 116 // any given moment. It's just simpler like this and we don't need anything
 117 // more for now.
 118
 119 extern "C"
 120 gboolean wxdataview_selection_func(GtkTreeSelection * WXUNUSED(selection),
 121                                    GtkTreeModel * WXUNUSED(model),
 122                                    GtkTreePath * WXUNUSED(path),
 123                                    gboolean WXUNUSED(path_currently_selected),
 124                                    gpointer data)
 125 {
 126     return data == NULL;
 127 }
 128
 129 class wxGtkTreeSelectionLock
 130 {
 131 public:
 132     wxGtkTreeSelectionLock(GtkTreeSelection *selection)
 133         : m_selection(selection)
 134     {
 135         wxASSERT_MSG( !ms_instance, "this class is not reentrant currently" );
 136
 137         ms_instance = this;
 138
 139         CheckCurrentSelectionFunc(NULL);
 140
 141         // Pass some non-NULL pointer as "data" for the callback, it doesn't
 142         // matter what it is as long as it's non-NULL.
 143         gtk_tree_selection_set_select_function(selection,
 144                                                wxdataview_selection_func,
 145                                                this,
 146                                                NULL);
 147     }
 148
 149     ~wxGtkTreeSelectionLock()
 150     {
 151         CheckCurrentSelectionFunc(wxdataview_selection_func);
 152
 153         gtk_tree_selection_set_select_function(m_selection,
 154                                                wxdataview_selection_func,
 155                                                NULL,
 156                                                NULL);
 157
 158         ms_instance = NULL;
 159     }
 160
 161 private:
 162     void CheckCurrentSelectionFunc(GtkTreeSelectionFunc func)
 163     {
 164         // We can only use gtk_tree_selection_get_select_function() with 2.14+
 165         // so check for its availability both during compile- and run-time.
 166 #if GTK_CHECK_VERSION(2, 14, 0)
 167         if ( gtk_check_version(2, 14, 0) != NULL )
 168             return;
 169
 170         // If this assert is triggered, it means the code elsewhere has called
 171         // gtk_tree_selection_set_select_function() but currently doing this
 172         // breaks this class so the code here needs to be changed.
 173         wxASSERT_MSG
 174         (
 175             gtk_tree_selection_get_select_function(m_selection) == func,
 176             "selection function has changed unexpectedly, review this code!"
 177         );
 178 #endif // GTK+ 2.14+
 179
 180         wxUnusedVar(func);
 181     }
 182
 183     static wxGtkTreeSelectionLock *ms_instance;
 184
 185     GtkTreeSelection * const m_selection;
 186
 187     wxDECLARE_NO_COPY_CLASS(wxGtkTreeSelectionLock);
 188 };
 189
 190 wxGtkTreeSelectionLock *wxGtkTreeSelectionLock::ms_instance = NULL;
 191
 192 //-----------------------------------------------------------------------------
 193 // wxDataViewCtrlInternal
 194 //-----------------------------------------------------------------------------
 195
 196 WX_DECLARE_LIST(wxDataViewItem, ItemList);
 197 WX_DEFINE_LIST(ItemList)
 198
 199 class wxDataViewCtrlInternal
 200 {
 201 public:
 202     wxDataViewCtrlInternal( wxDataViewCtrl *owner, wxDataViewModel *wx_model );
 203     ~wxDataViewCtrlInternal();
 204
 205     // model iface
 206     GtkTreeModelFlags get_flags();
 207     gboolean get_iter( GtkTreeIter *iter, GtkTreePath *path );
 208     GtkTreePath *get_path( GtkTreeIter *iter);
 209     gboolean iter_next( GtkTreeIter *iter );
 210     gboolean iter_children( GtkTreeIter *iter, GtkTreeIter *parent);
 211     gboolean iter_has_child( GtkTreeIter *iter );
 212     gint iter_n_children( GtkTreeIter *iter );
 213     gboolean iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n );
 214     gboolean iter_parent( GtkTreeIter *iter, GtkTreeIter *child );
 215
 216     // dnd iface
 217
 218     bool EnableDragSource( const wxDataFormat &format );
 219     bool EnableDropTarget( const wxDataFormat &format );
 220
 221     gboolean row_draggable( GtkTreeDragSource *drag_source, GtkTreePath *path );
 222     gboolean drag_data_delete( GtkTreeDragSource *drag_source, GtkTreePath* path );
 223     gboolean drag_data_get( GtkTreeDragSource *drag_source, GtkTreePath *path,
 224         GtkSelectionData *selection_data );
 225     gboolean drag_data_received( GtkTreeDragDest *drag_dest, GtkTreePath *dest,
 226         GtkSelectionData *selection_data );
 227     gboolean row_drop_possible( GtkTreeDragDest *drag_dest, GtkTreePath *dest_path,
 228         GtkSelectionData *selection_data );
 229
 230     // notifactions from wxDataViewModel
 231     bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
 232     bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
 233     bool ItemChanged( const wxDataViewItem &item );
 234     bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );
 235     bool Cleared();
 236     bool BeforeReset();
 237     bool AfterReset();
 238     void Resort();
 239
 240     // sorting interface
 241     void SetSortOrder( GtkSortType sort_order ) { m_sort_order = sort_order; }
 242     GtkSortType GetSortOrder() const            { return m_sort_order; }
 243
 244     void SetSortColumn( int column )            { m_sort_column = column; }
 245     int GetSortColumn() const                   { return m_sort_column; }
 246
 247     void SetDataViewSortColumn( wxDataViewColumn *column ) { m_dataview_sort_column = column; }
 248     wxDataViewColumn *GetDataViewSortColumn()   { return m_dataview_sort_column; }
 249
 250     bool IsSorted()                             { return (m_sort_column >= 0); }
 251
 252     // accessors
 253     wxDataViewModel* GetDataViewModel() { return m_wx_model; }
 254     const wxDataViewModel* GetDataViewModel() const { return m_wx_model; }
 255     wxDataViewCtrl* GetOwner()          { return m_owner; }
 256     GtkWxTreeModel* GetGtkModel()       { return m_gtk_model; }
 257
 258     // item can be deleted already in the model
 259     int GetIndexOf( const wxDataViewItem &parent, const wxDataViewItem &item );
 260
 261     virtual void OnInternalIdle();
 262
 263 protected:
 264     void InitTree();
 265     void ScheduleRefresh();
 266
 267     wxGtkTreeModelNode *FindNode( const wxDataViewItem &item );
 268     wxGtkTreeModelNode *FindNode( GtkTreeIter *iter );
 269     wxGtkTreeModelNode *FindParentNode( const wxDataViewItem &item );
 270     wxGtkTreeModelNode *FindParentNode( GtkTreeIter *iter );
 271     void BuildBranch( wxGtkTreeModelNode *branch );
 272
 273 private:
 274     wxGtkTreeModelNode   *m_root;
 275     wxDataViewModel      *m_wx_model;
 276     GtkWxTreeModel       *m_gtk_model;
 277     wxDataViewCtrl       *m_owner;
 278     GtkSortType           m_sort_order;
 279     wxDataViewColumn     *m_dataview_sort_column;
 280     int                   m_sort_column;
 281
 282     GtkTargetEntry        m_dragSourceTargetEntry;
 283     wxCharBuffer          m_dragSourceTargetEntryTarget;
 284     wxDataObject         *m_dragDataObject;
 285
 286     GtkTargetEntry        m_dropTargetTargetEntry;
 287     wxCharBuffer          m_dropTargetTargetEntryTarget;
 288     wxDataObject         *m_dropDataObject;
 289
 290     wxGtkDataViewModelNotifier *m_notifier;
 291
 292     bool                  m_dirty;
 293 };
 294
 295
 296 //-----------------------------------------------------------------------------
 297 // wxGtkTreeModelNode
 298 //-----------------------------------------------------------------------------
 299
 300 static
 301 int LINKAGEMODE wxGtkTreeModelChildCmp( void** id1, void** id2 )
 302 {
 303     int ret = gs_internal->GetDataViewModel()->Compare( wxDataViewItem(*id1), wxDataViewItem(*id2),
 304         gs_internal->GetSortColumn(), (gs_internal->GetSortOrder() == GTK_SORT_ASCENDING) );
 305
 306     return ret;
 307 }
 308
 309 WX_DEFINE_ARRAY_PTR( wxGtkTreeModelNode*, wxGtkTreeModelNodes );
 310 WX_DEFINE_ARRAY_PTR( void*, wxGtkTreeModelChildren );
 311
 312 class wxGtkTreeModelNode
 313 {
 314 public:
 315     wxGtkTreeModelNode( wxGtkTreeModelNode* parent, const wxDataViewItem &item,
 316                         wxDataViewCtrlInternal *internal )
 317     {
 318         m_parent = parent;
 319         m_item = item;
 320         m_internal = internal;
 321     }
 322
 323     ~wxGtkTreeModelNode()
 324     {
 325         size_t count = m_nodes.GetCount();
 326         size_t i;
 327         for (i = 0; i < count; i++)
 328         {
 329             wxGtkTreeModelNode *child = m_nodes.Item( i );
 330             delete child;
 331         }
 332     }
 333
 334     unsigned int AddNode( wxGtkTreeModelNode* child )
 335         {
 336             m_nodes.Add( child );
 337
 338             void *id = child->GetItem().GetID();
 339
 340             m_children.Add( id );
 341
 342             if (m_internal->IsSorted() || m_internal->GetDataViewModel()->HasDefaultCompare())
 343             {
 344                 gs_internal = m_internal;
 345                 m_children.Sort( &wxGtkTreeModelChildCmp );
 346                 return m_children.Index( id );
 347             }
 348
 349             return m_children.GetCount()-1;
 350         }
 351
 352     unsigned int AddLeave( void* id )
 353         {
 354             m_children.Add( id );
 355
 356             if (m_internal->IsSorted() || m_internal->GetDataViewModel()->HasDefaultCompare())
 357             {
 358                 gs_internal = m_internal;
 359                 m_children.Sort( &wxGtkTreeModelChildCmp );
 360                 return m_children.Index( id );
 361             }
 362
 363             return m_children.GetCount()-1;
 364         }
 365
 366     void DeleteChild( void* id )
 367         {
 368             m_children.Remove( id );
 369
 370             unsigned int count = m_nodes.GetCount();
 371             unsigned int pos;
 372             for (pos = 0; pos < count; pos++)
 373             {
 374                 wxGtkTreeModelNode *node = m_nodes.Item( pos );
 375                 if (node->GetItem().GetID() == id)
 376                 {
 377                     m_nodes.RemoveAt( pos );
 378                     delete node;
 379                     break;
 380                 }
 381             }
 382         }
 383
 384     wxGtkTreeModelNode* GetParent()
 385         { return m_parent; }
 386     wxGtkTreeModelNodes &GetNodes()
 387         { return m_nodes; }
 388     wxGtkTreeModelChildren &GetChildren()
 389         { return m_children; }
 390
 391     unsigned int GetChildCount() const { return m_children.GetCount(); }
 392     unsigned int GetNodesCount() const { return m_nodes.GetCount(); }
 393
 394     wxDataViewItem &GetItem() { return m_item; }
 395     wxDataViewCtrlInternal *GetInternal() { return m_internal; }
 396
 397     void Resort();
 398
 399 private:
 400     wxGtkTreeModelNode         *m_parent;
 401     wxGtkTreeModelNodes         m_nodes;
 402     wxGtkTreeModelChildren      m_children;
 403     wxDataViewItem              m_item;
 404     wxDataViewCtrlInternal     *m_internal;
 405 };
 406
 407
 408 //-----------------------------------------------------------------------------
 409 // data
 410 //-----------------------------------------------------------------------------
 411
 412 extern bool   g_blockEventsOnDrag;
 413
 414 //-----------------------------------------------------------------------------
 415 // define new GTK+ class wxGtkTreeModel
 416 //-----------------------------------------------------------------------------
 417
 418 extern "C" {
 419
 420 #define GTK_TYPE_WX_TREE_MODEL               (gtk_wx_tree_model_get_type ())
 421 #define GTK_WX_TREE_MODEL(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModel))
 422 #define GTK_WX_TREE_MODEL_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
 423 #define GTK_IS_WX_TREE_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_TREE_MODEL))
 424 #define GTK_IS_WX_TREE_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_TREE_MODEL))
 425 #define GTK_WX_TREE_MODEL_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_TREE_MODEL, GtkWxTreeModelClass))
 426
 427 GType         gtk_wx_tree_model_get_type         (void);
 428
 429 typedef struct _GtkWxTreeModelClass  GtkWxTreeModelClass;
 430
 431 struct _GtkWxTreeModel
 432 {
 433   GObject parent;
 434
 435   /*< private >*/
 436   gint stamp;
 437   wxDataViewCtrlInternal *internal;
 438 };
 439
 440 struct _GtkWxTreeModelClass
 441 {
 442   GObjectClass list_parent_class;
 443 };
 444
 445 static GtkWxTreeModel *wxgtk_tree_model_new          (void);
 446 static void         wxgtk_tree_model_init            (GtkWxTreeModel       *tree_model);
 447 static void         wxgtk_tree_model_class_init      (GtkWxTreeModelClass  *klass);
 448
 449 static void         wxgtk_tree_model_tree_model_init (GtkTreeModelIface       *iface);
 450 static void         wxgtk_tree_model_sortable_init   (GtkTreeSortableIface    *iface);
 451 static void         wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface  *iface);
 452 static void         wxgtk_tree_model_drag_dest_init  (GtkTreeDragDestIface    *iface);
 453
 454 static void         wxgtk_tree_model_finalize        (GObject           *object);
 455 static GtkTreeModelFlags wxgtk_tree_model_get_flags  (GtkTreeModel      *tree_model);
 456 static gint         wxgtk_tree_model_get_n_columns   (GtkTreeModel      *tree_model);
 457 static GType        wxgtk_tree_model_get_column_type (GtkTreeModel      *tree_model,
 458                                                       gint               index);
 459 static gboolean     wxgtk_tree_model_get_iter        (GtkTreeModel      *tree_model,
 460                                                       GtkTreeIter       *iter,
 461                                                       GtkTreePath       *path);
 462 static GtkTreePath *wxgtk_tree_model_get_path        (GtkTreeModel      *tree_model,
 463                                                       GtkTreeIter       *iter);
 464 static void         wxgtk_tree_model_get_value       (GtkTreeModel      *tree_model,
 465                                                       GtkTreeIter       *iter,
 466                                                       gint               column,
 467                                                       GValue            *value);
 468 static gboolean     wxgtk_tree_model_iter_next       (GtkTreeModel      *tree_model,
 469                                                       GtkTreeIter       *iter);
 470 static gboolean     wxgtk_tree_model_iter_children   (GtkTreeModel      *tree_model,
 471                                                       GtkTreeIter       *iter,
 472                                                       GtkTreeIter       *parent);
 473 static gboolean     wxgtk_tree_model_iter_has_child  (GtkTreeModel      *tree_model,
 474                                                       GtkTreeIter       *iter);
 475 static gint         wxgtk_tree_model_iter_n_children (GtkTreeModel      *tree_model,
 476                                                       GtkTreeIter       *iter);
 477 static gboolean     wxgtk_tree_model_iter_nth_child  (GtkTreeModel      *tree_model,
 478                                                       GtkTreeIter       *iter,
 479                                                       GtkTreeIter       *parent,
 480                                                       gint               n);
 481 static gboolean     wxgtk_tree_model_iter_parent     (GtkTreeModel      *tree_model,
 482                                                       GtkTreeIter       *iter,
 483                                                       GtkTreeIter       *child);
 484
 485 /* sortable */
 486 static gboolean wxgtk_tree_model_get_sort_column_id    (GtkTreeSortable       *sortable,
 487                                                         gint                  *sort_column_id,
 488                                                         GtkSortType           *order);
 489 static void     wxgtk_tree_model_set_sort_column_id    (GtkTreeSortable       *sortable,
 490                                                         gint                   sort_column_id,
 491                                                         GtkSortType            order);
 492 static void     wxgtk_tree_model_set_sort_func         (GtkTreeSortable       *sortable,
 493                                                         gint                   sort_column_id,
 494                                                         GtkTreeIterCompareFunc func,
 495                                                         gpointer               data,
 496                                                         GDestroyNotify       destroy);
 497 static void     wxgtk_tree_model_set_default_sort_func (GtkTreeSortable       *sortable,
 498                                                         GtkTreeIterCompareFunc func,
 499                                                         gpointer               data,
 500                                                         GDestroyNotify       destroy);
 501 static gboolean wxgtk_tree_model_has_default_sort_func (GtkTreeSortable       *sortable);
 502
 503 /* drag'n'drop */
 504 static gboolean wxgtk_tree_model_row_draggable         (GtkTreeDragSource     *drag_source,
 505                                                         GtkTreePath           *path);
 506 static gboolean wxgtk_tree_model_drag_data_delete      (GtkTreeDragSource     *drag_source,
 507                                                         GtkTreePath           *path);
 508 static gboolean wxgtk_tree_model_drag_data_get         (GtkTreeDragSource     *drag_source,
 509                                                         GtkTreePath           *path,
 510                                                         GtkSelectionData      *selection_data);
 511 static gboolean wxgtk_tree_model_drag_data_received    (GtkTreeDragDest       *drag_dest,
 512                                                         GtkTreePath           *dest,
 513                                                         GtkSelectionData      *selection_data);
 514 static gboolean wxgtk_tree_model_row_drop_possible     (GtkTreeDragDest       *drag_dest,
 515                                                         GtkTreePath           *dest_path,
 516                                                         GtkSelectionData      *selection_data);
 517
 518
 519 static GObjectClass *list_parent_class = NULL;
 520
 521 GType
 522 gtk_wx_tree_model_get_type (void)
 523 {
 524     static GType tree_model_type = 0;
 525
 526     if (!tree_model_type)
 527     {
 528         const GTypeInfo tree_model_info =
 529         {
 530             sizeof (GtkWxTreeModelClass),
 531             NULL,   /* base_init */
 532             NULL,   /* base_finalize */
 533             (GClassInitFunc) wxgtk_tree_model_class_init,
 534             NULL,   /* class_finalize */
 535             NULL,   /* class_data */
 536             sizeof (GtkWxTreeModel),
 537             0,
 538             (GInstanceInitFunc) wxgtk_tree_model_init,
 539         };
 540
 541         static const GInterfaceInfo tree_model_iface_info =
 542         {
 543             (GInterfaceInitFunc) wxgtk_tree_model_tree_model_init,
 544             NULL,
 545             NULL
 546         };
 547
 548         static const GInterfaceInfo sortable_iface_info =
 549         {
 550             (GInterfaceInitFunc) wxgtk_tree_model_sortable_init,
 551             NULL,
 552             NULL
 553         };
 554
 555         static const GInterfaceInfo drag_source_iface_info =
 556         {
 557             (GInterfaceInitFunc) wxgtk_tree_model_drag_source_init,
 558             NULL,
 559             NULL
 560         };
 561
 562         static const GInterfaceInfo drag_dest_iface_info =
 563         {
 564             (GInterfaceInitFunc) wxgtk_tree_model_drag_dest_init,
 565             NULL,
 566             NULL
 567         };
 568
 569         tree_model_type = g_type_register_static (G_TYPE_OBJECT, "GtkWxTreeModel",
 570                                                 &tree_model_info, (GTypeFlags)0 );
 571
 572         g_type_add_interface_static (tree_model_type,
 573                                      GTK_TYPE_TREE_MODEL,
 574                                      &tree_model_iface_info);
 575         g_type_add_interface_static (tree_model_type,
 576                                      GTK_TYPE_TREE_SORTABLE,
 577                                      &sortable_iface_info);
 578         g_type_add_interface_static (tree_model_type,
 579                                      GTK_TYPE_TREE_DRAG_DEST,
 580                                      &drag_dest_iface_info);
 581         g_type_add_interface_static (tree_model_type,
 582                                      GTK_TYPE_TREE_DRAG_SOURCE,
 583                                      &drag_source_iface_info);
 584     }
 585
 586     return tree_model_type;
 587 }
 588
 589 static GtkWxTreeModel *
 590 wxgtk_tree_model_new(void)
 591 {
 592     GtkWxTreeModel *retval = (GtkWxTreeModel *) g_object_new (GTK_TYPE_WX_TREE_MODEL, NULL);
 593     return retval;
 594 }
 595
 596 static void
 597 wxgtk_tree_model_class_init (GtkWxTreeModelClass *klass)
 598 {
 599     list_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
 600     GObjectClass *object_class = (GObjectClass*) klass;
 601     object_class->finalize = wxgtk_tree_model_finalize;
 602 }
 603
 604 static void
 605 wxgtk_tree_model_tree_model_init (GtkTreeModelIface *iface)
 606 {
 607     iface->get_flags = wxgtk_tree_model_get_flags;
 608     iface->get_n_columns = wxgtk_tree_model_get_n_columns;
 609     iface->get_column_type = wxgtk_tree_model_get_column_type;
 610     iface->get_iter = wxgtk_tree_model_get_iter;
 611     iface->get_path = wxgtk_tree_model_get_path;
 612     iface->get_value = wxgtk_tree_model_get_value;
 613     iface->iter_next = wxgtk_tree_model_iter_next;
 614     iface->iter_children = wxgtk_tree_model_iter_children;
 615     iface->iter_has_child = wxgtk_tree_model_iter_has_child;
 616     iface->iter_n_children = wxgtk_tree_model_iter_n_children;
 617     iface->iter_nth_child = wxgtk_tree_model_iter_nth_child;
 618     iface->iter_parent = wxgtk_tree_model_iter_parent;
 619 }
 620
 621 static void
 622 wxgtk_tree_model_sortable_init (GtkTreeSortableIface *iface)
 623 {
 624     iface->get_sort_column_id = wxgtk_tree_model_get_sort_column_id;
 625     iface->set_sort_column_id = wxgtk_tree_model_set_sort_column_id;
 626     iface->set_sort_func = wxgtk_tree_model_set_sort_func;
 627     iface->set_default_sort_func = wxgtk_tree_model_set_default_sort_func;
 628     iface->has_default_sort_func = wxgtk_tree_model_has_default_sort_func;
 629 }
 630
 631 static void
 632 wxgtk_tree_model_drag_source_init(GtkTreeDragSourceIface  *iface)
 633 {
 634     iface->row_draggable = wxgtk_tree_model_row_draggable;
 635     iface->drag_data_delete = wxgtk_tree_model_drag_data_delete;
 636     iface->drag_data_get = wxgtk_tree_model_drag_data_get;
 637 }
 638
 639 static void
 640 wxgtk_tree_model_drag_dest_init  (GtkTreeDragDestIface    *iface)
 641 {
 642     iface->drag_data_received = wxgtk_tree_model_drag_data_received;
 643     iface->row_drop_possible = wxgtk_tree_model_row_drop_possible;
 644 }
 645
 646 static void
 647 wxgtk_tree_model_init (GtkWxTreeModel *tree_model)
 648 {
 649     tree_model->internal = NULL;
 650     tree_model->stamp = g_random_int();
 651 }
 652
 653 static void
 654 wxgtk_tree_model_finalize (GObject *object)
 655 {
 656     /* must chain up */
 657     (* list_parent_class->finalize) (object);
 658 }
 659
 660 } // extern "C"
 661
 662 //-----------------------------------------------------------------------------
 663 // implement callbacks from wxGtkTreeModel class by letting
 664 // them call the methods of wxWidgets' wxDataViewModel
 665 //-----------------------------------------------------------------------------
 666
 667 static GtkTreeModelFlags
 668 wxgtk_tree_model_get_flags (GtkTreeModel *tree_model)
 669 {
 670     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 671     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), (GtkTreeModelFlags)0 );
 672
 673     return wxtree_model->internal->get_flags();
 674 }
 675
 676 static gint
 677 wxgtk_tree_model_get_n_columns (GtkTreeModel *tree_model)
 678 {
 679     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 680     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), 0);
 681
 682     return wxtree_model->internal->GetDataViewModel()->GetColumnCount();
 683 }
 684
 685 static GType
 686 wxgtk_tree_model_get_column_type (GtkTreeModel *tree_model,
 687                                   gint          index)
 688 {
 689     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 690     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), G_TYPE_INVALID);
 691
 692     GType gtype = G_TYPE_INVALID;
 693
 694     wxString wxtype = wxtree_model->internal->GetDataViewModel()->GetColumnType( (unsigned int) index );
 695
 696     if (wxtype == wxT("string"))
 697         gtype = G_TYPE_STRING;
 698     else
 699     {
 700         gtype = G_TYPE_POINTER;
 701         // wxFAIL_MSG( wxT("non-string columns not supported for searching yet") );
 702     }
 703
 704     return gtype;
 705 }
 706
 707 static gboolean
 708 wxgtk_tree_model_get_iter (GtkTreeModel *tree_model,
 709                            GtkTreeIter  *iter,
 710                            GtkTreePath  *path)
 711 {
 712     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 713     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 714     g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
 715
 716     return wxtree_model->internal->get_iter( iter, path );
 717 }
 718
 719 static GtkTreePath *
 720 wxgtk_tree_model_get_path (GtkTreeModel *tree_model,
 721                            GtkTreeIter  *iter)
 722 {
 723     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 724     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), NULL);
 725     g_return_val_if_fail (iter->stamp == GTK_WX_TREE_MODEL (wxtree_model)->stamp, NULL);
 726
 727     return wxtree_model->internal->get_path( iter );
 728 }
 729
 730 static void
 731 wxgtk_tree_model_get_value (GtkTreeModel *tree_model,
 732                             GtkTreeIter  *iter,
 733                             gint          column,
 734                             GValue       *value)
 735 {
 736     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 737     g_return_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model) );
 738
 739     wxDataViewModel *model = wxtree_model->internal->GetDataViewModel();
 740     wxString mtype = model->GetColumnType( (unsigned int) column );
 741     if (mtype == wxT("string"))
 742     {
 743         wxVariant variant;
 744         g_value_init( value, G_TYPE_STRING );
 745         wxDataViewItem item( (void*) iter->user_data );
 746         model->GetValue( variant, item, (unsigned int) column );
 747
 748         g_value_set_string( value, variant.GetString().utf8_str() );
 749     }
 750     else
 751     {
 752         wxFAIL_MSG( wxT("non-string columns not supported yet") );
 753     }
 754 }
 755
 756 static gboolean
 757 wxgtk_tree_model_iter_next (GtkTreeModel  *tree_model,
 758                             GtkTreeIter   *iter)
 759 {
 760     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 761
 762     // This happens when clearing the view by calling .._set_model( NULL );
 763     if (iter->stamp == 0) return FALSE;
 764
 765     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 766     g_return_val_if_fail (wxtree_model->stamp == iter->stamp, FALSE);
 767
 768     return wxtree_model->internal->iter_next( iter );
 769 }
 770
 771 static gboolean
 772 wxgtk_tree_model_iter_children (GtkTreeModel *tree_model,
 773                                 GtkTreeIter  *iter,
 774                                 GtkTreeIter  *parent)
 775 {
 776     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 777     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 778     if (parent)
 779     {
 780         g_return_val_if_fail (wxtree_model->stamp == parent->stamp, FALSE);
 781     }
 782
 783     return wxtree_model->internal->iter_children( iter, parent );
 784 }
 785
 786 static gboolean
 787 wxgtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
 788                                  GtkTreeIter  *iter)
 789 {
 790     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 791     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 792     g_return_val_if_fail (wxtree_model->stamp == iter->stamp, FALSE);
 793
 794     return wxtree_model->internal->iter_has_child( iter );
 795 }
 796
 797 static gint
 798 wxgtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
 799                                   GtkTreeIter  *iter)
 800 {
 801     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 802     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), 0);
 803     g_return_val_if_fail ( !iter || wxtree_model->stamp == iter->stamp, 0);
 804
 805     return wxtree_model->internal->iter_n_children( iter );
 806 }
 807
 808 static gboolean
 809 wxgtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
 810                                  GtkTreeIter  *iter,
 811                                  GtkTreeIter  *parent,
 812                                  gint          n)
 813 {
 814     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 815     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 816
 817     return wxtree_model->internal->iter_nth_child( iter, parent, n );
 818 }
 819
 820 static gboolean
 821 wxgtk_tree_model_iter_parent (GtkTreeModel *tree_model,
 822                               GtkTreeIter  *iter,
 823                               GtkTreeIter  *child)
 824 {
 825     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) tree_model;
 826     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 827     g_return_val_if_fail (wxtree_model->stamp == child->stamp, FALSE);
 828
 829     return wxtree_model->internal->iter_parent( iter, child );
 830 }
 831
 832 /* drag'n'drop iface */
 833 static gboolean
 834 wxgtk_tree_model_row_draggable (GtkTreeDragSource *drag_source,
 835                                 GtkTreePath       *path)
 836 {
 837     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_source;
 838     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 839
 840     return wxtree_model->internal->row_draggable( drag_source, path );
 841 }
 842
 843 static gboolean
 844 wxgtk_tree_model_drag_data_delete (GtkTreeDragSource *drag_source,
 845                                    GtkTreePath       *path)
 846 {
 847     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_source;
 848     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 849
 850     return wxtree_model->internal->drag_data_delete( drag_source, path );
 851 }
 852
 853 static gboolean
 854 wxgtk_tree_model_drag_data_get (GtkTreeDragSource *drag_source,
 855                                 GtkTreePath       *path,
 856                                 GtkSelectionData  *selection_data)
 857 {
 858     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_source;
 859     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 860
 861 #if 0
 862     wxPrintf( "drag_get_data\n");
 863
 864     wxGtkString atom_selection(gdk_atom_name(selection_data->selection));
 865     wxPrintf( "selection %s\n", wxString::FromAscii(atom_selection) );
 866
 867     wxGtkString atom_target(gdk_atom_name(selection_data->target));
 868     wxPrintf( "target %s\n", wxString::FromAscii(atom_target) );
 869
 870     wxGtkString atom_type(gdk_atom_name(selection_data->type));
 871     wxPrintf( "type %s\n", wxString::FromAscii(atom_type) );
 872
 873     wxPrintf( "format %d\n", selection_data->format );
 874 #endif
 875
 876     return wxtree_model->internal->drag_data_get( drag_source, path, selection_data );
 877 }
 878
 879 static gboolean
 880 wxgtk_tree_model_drag_data_received (GtkTreeDragDest  *drag_dest,
 881                                      GtkTreePath      *dest,
 882                                      GtkSelectionData *selection_data)
 883 {
 884     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_dest;
 885     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 886
 887     return wxtree_model->internal->drag_data_received( drag_dest, dest, selection_data );
 888 }
 889
 890 static gboolean
 891 wxgtk_tree_model_row_drop_possible (GtkTreeDragDest  *drag_dest,
 892                                     GtkTreePath      *dest_path,
 893                                     GtkSelectionData *selection_data)
 894 {
 895     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) drag_dest;
 896     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (wxtree_model), FALSE);
 897
 898     return wxtree_model->internal->row_drop_possible( drag_dest, dest_path, selection_data );
 899 }
 900
 901 /* sortable iface */
 902 static gboolean
 903 wxgtk_tree_model_get_sort_column_id (GtkTreeSortable *sortable,
 904                                      gint            *sort_column_id,
 905                                      GtkSortType     *order)
 906 {
 907     GtkWxTreeModel *wxtree_model = (GtkWxTreeModel *) sortable;
 908
 909     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable), FALSE);
 910
 911     if (!wxtree_model->internal->IsSorted())
 912     {
 913         if (sort_column_id)
 914             *sort_column_id = -1;
 915
 916         return TRUE;
 917     }
 918
 919
 920     if (sort_column_id)
 921         *sort_column_id = wxtree_model->internal->GetSortColumn();
 922
 923     if (order)
 924         *order = wxtree_model->internal->GetSortOrder();
 925
 926     return TRUE;
 927 }
 928
 929 wxDataViewColumn *gs_lastLeftClickHeader = NULL;
 930
 931 static void
 932 wxgtk_tree_model_set_sort_column_id (GtkTreeSortable *sortable,
 933                                      gint             sort_column_id,
 934                                      GtkSortType      order)
 935 {
 936     GtkWxTreeModel *tree_model = (GtkWxTreeModel *) sortable;
 937     g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
 938
 939     tree_model->internal->SetDataViewSortColumn( gs_lastLeftClickHeader );
 940
 941     if ((sort_column_id != (gint) tree_model->internal->GetSortColumn()) ||
 942         (order != tree_model->internal->GetSortOrder()))
 943     {
 944         tree_model->internal->SetSortColumn( sort_column_id );
 945         tree_model->internal->SetSortOrder( order );
 946
 947         gtk_tree_sortable_sort_column_changed (sortable);
 948
 949         tree_model->internal->GetDataViewModel()->Resort();
 950     }
 951
 952     if (gs_lastLeftClickHeader)
 953     {
 954         wxDataViewCtrl *dv = tree_model->internal->GetOwner();
 955         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, dv->GetId() );
 956         event.SetDataViewColumn( gs_lastLeftClickHeader );
 957         event.SetModel( dv->GetModel() );
 958         dv->HandleWindowEvent( event );
 959     }
 960
 961     gs_lastLeftClickHeader = NULL;
 962 }
 963
 964 static void
 965 wxgtk_tree_model_set_sort_func (GtkTreeSortable        *sortable,
 966                                 gint                    WXUNUSED(sort_column_id),
 967                                 GtkTreeIterCompareFunc  func,
 968                                 gpointer                WXUNUSED(data),
 969                                 GDestroyNotify        WXUNUSED(destroy))
 970 {
 971     g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
 972     g_return_if_fail (func != NULL);
 973 }
 974
 975 static void
 976 wxgtk_tree_model_set_default_sort_func (GtkTreeSortable          *sortable,
 977                                         GtkTreeIterCompareFunc    func,
 978                                         gpointer                  WXUNUSED(data),
 979                                         GDestroyNotify          WXUNUSED(destroy))
 980 {
 981     g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
 982     g_return_if_fail (func != NULL);
 983
 984     //wxPrintf( "wxgtk_tree_model_set_default_sort_func\n" );
 985     // TODO: remove this code
 986 }
 987
 988 static gboolean
 989 wxgtk_tree_model_has_default_sort_func (GtkTreeSortable        *sortable)
 990 {
 991     g_return_val_if_fail (GTK_IS_WX_TREE_MODEL (sortable), FALSE );
 992
 993     return FALSE;
 994 }
 995
 996 //-----------------------------------------------------------------------------
 997 // define new GTK+ class GtkWxRendererText
 998 //-----------------------------------------------------------------------------
 999
1000 extern "C" {
1001
1002 #define GTK_TYPE_WX_CELL_RENDERER_TEXT               (gtk_wx_cell_renderer_text_get_type ())
1003 #define GTK_WX_CELL_RENDERER_TEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererText))
1004 #define GTK_WX_CELL_RENDERER_TEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
1005 #define GTK_IS_WX_CELL_RENDERER_TEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT))
1006 #define GTK_IS_WX_CELL_RENDERER_TEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER_TEXT))
1007 #define GTK_WX_CELL_RENDERER_TEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER_TEXT, GtkWxCellRendererTextClass))
1008
1009 GType            gtk_wx_cell_renderer_text_get_type (void);
1010
1011 typedef struct _GtkWxCellRendererText GtkWxCellRendererText;
1012 typedef struct _GtkWxCellRendererTextClass GtkWxCellRendererTextClass;
1013
1014 struct _GtkWxCellRendererText
1015 {
1016   GtkCellRendererText parent;
1017
1018   wxDataViewRenderer *wx_renderer;
1019 };
1020
1021 struct _GtkWxCellRendererTextClass
1022 {
1023   GtkCellRendererTextClass cell_parent_class;
1024 };
1025
1026
1027 static GtkWxCellRendererText *gtk_wx_cell_renderer_text_new   (void);
1028 static void gtk_wx_cell_renderer_text_init (
1029                         GtkWxCellRendererText      *cell );
1030 static void gtk_wx_cell_renderer_text_class_init(
1031                         GtkWxCellRendererTextClass *klass );
1032 static void gtk_wx_cell_renderer_text_finalize (
1033                         GObject                *object );
1034 static GtkCellEditable *gtk_wx_cell_renderer_text_start_editing(
1035                         GtkCellRenderer         *cell,
1036                         GdkEvent                *event,
1037                         GtkWidget               *widget,
1038                         const gchar             *path,
1039                         GdkRectangle            *background_area,
1040                         GdkRectangle            *cell_area,
1041                         GtkCellRendererState     flags );
1042
1043
1044 static GObjectClass *text_cell_parent_class = NULL;
1045
1046 }  // extern "C"
1047
1048 GType
1049 gtk_wx_cell_renderer_text_get_type (void)
1050 {
1051     static GType cell_wx_type = 0;
1052
1053     if (!cell_wx_type)
1054     {
1055         const GTypeInfo cell_wx_info =
1056         {
1057             sizeof (GtkWxCellRendererTextClass),
1058             NULL, /* base_init */
1059             NULL, /* base_finalize */
1060             (GClassInitFunc) gtk_wx_cell_renderer_text_class_init,
1061             NULL, /* class_finalize */
1062             NULL, /* class_data */
1063             sizeof (GtkWxCellRendererText),
1064             0,          /* n_preallocs */
1065             (GInstanceInitFunc) gtk_wx_cell_renderer_text_init,
1066         };
1067
1068         cell_wx_type = g_type_register_static( GTK_TYPE_CELL_RENDERER_TEXT,
1069             "GtkWxCellRendererText", &cell_wx_info, (GTypeFlags)0 );
1070     }
1071
1072     return cell_wx_type;
1073 }
1074
1075 static void
1076 gtk_wx_cell_renderer_text_init (GtkWxCellRendererText *cell)
1077 {
1078     cell->wx_renderer = NULL;
1079 }
1080
1081 static void
1082 gtk_wx_cell_renderer_text_class_init (GtkWxCellRendererTextClass *klass)
1083 {
1084     GObjectClass *object_class = G_OBJECT_CLASS (klass);
1085     GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
1086
1087     text_cell_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
1088
1089     object_class->finalize = gtk_wx_cell_renderer_text_finalize;
1090
1091     cell_class->start_editing = gtk_wx_cell_renderer_text_start_editing;
1092 }
1093
1094 static void
1095 gtk_wx_cell_renderer_text_finalize (GObject *object)
1096 {
1097     /* must chain up */
1098     (* G_OBJECT_CLASS (text_cell_parent_class)->finalize) (object);
1099 }
1100
1101 GtkWxCellRendererText*
1102 gtk_wx_cell_renderer_text_new (void)
1103 {
1104     return (GtkWxCellRendererText*) g_object_new (GTK_TYPE_WX_CELL_RENDERER_TEXT, NULL);
1105 }
1106
1107 static GtkCellEditable *gtk_wx_cell_renderer_text_start_editing(
1108                         GtkCellRenderer         *gtk_renderer,
1109                         GdkEvent                *gdk_event,
1110                         GtkWidget               *widget,
1111                         const gchar             *path,
1112                         GdkRectangle            *background_area,
1113                         GdkRectangle            *cell_area,
1114                         GtkCellRendererState     flags )
1115 {
1116     GtkWxCellRendererText *wxgtk_renderer = (GtkWxCellRendererText *) gtk_renderer;
1117     wxDataViewRenderer *wx_renderer = wxgtk_renderer->wx_renderer;
1118     wxDataViewColumn *column = wx_renderer->GetOwner();
1119
1120     wxDataViewItem
1121         item(column->GetOwner()->GTKPathToItem(wxGtkTreePath(path)));
1122
1123     wxDataViewCtrl *dv = column->GetOwner();
1124     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, dv->GetId() );
1125     event.SetDataViewColumn( column );
1126     event.SetModel( dv->GetModel() );
1127     event.SetColumn( column->GetModelColumn() );
1128     event.SetItem( item );
1129     dv->HandleWindowEvent( event );
1130
1131     if (event.IsAllowed())
1132         return GTK_CELL_RENDERER_CLASS(text_cell_parent_class)->
1133            start_editing( gtk_renderer, gdk_event, widget, path, background_area, cell_area, flags );
1134     else
1135         return NULL;
1136 }
1137
1138 //-----------------------------------------------------------------------------
1139 // define new GTK+ class GtkWxCellRenderer
1140 //-----------------------------------------------------------------------------
1141
1142 extern "C" {
1143
1144 #define GTK_TYPE_WX_CELL_RENDERER               (gtk_wx_cell_renderer_get_type ())
1145 #define GTK_WX_CELL_RENDERER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRenderer))
1146 #define GTK_WX_CELL_RENDERER_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
1147 #define GTK_IS_WX_CELL_RENDERER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_CELL_RENDERER))
1148 #define GTK_IS_WX_CELL_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_CELL_RENDERER))
1149 #define GTK_WX_CELL_RENDERER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_CELL_RENDERER, GtkWxCellRendererClass))
1150
1151 GType            gtk_wx_cell_renderer_get_type (void);
1152
1153 typedef struct _GtkWxCellRenderer GtkWxCellRenderer;
1154 typedef struct _GtkWxCellRendererClass GtkWxCellRendererClass;
1155
1156 struct _GtkWxCellRenderer
1157 {
1158   GtkCellRenderer parent;
1159
1160   /*< private >*/
1161   wxDataViewCustomRenderer *cell;
1162   guint32 last_click;
1163 };
1164
1165 struct _GtkWxCellRendererClass
1166 {
1167   GtkCellRendererClass cell_parent_class;
1168 };
1169
1170
1171 static GtkCellRenderer *gtk_wx_cell_renderer_new   (void);
1172 static void gtk_wx_cell_renderer_init (
1173                         GtkWxCellRenderer      *cell );
1174 static void gtk_wx_cell_renderer_class_init(
1175                         GtkWxCellRendererClass *klass );
1176 static void gtk_wx_cell_renderer_finalize (
1177                         GObject                *object );
1178 static void gtk_wx_cell_renderer_get_size (
1179                         GtkCellRenderer         *cell,
1180                         GtkWidget               *widget,
1181                         GdkRectangle            *rectangle,
1182                         gint                    *x_offset,
1183                         gint                    *y_offset,
1184                         gint                    *width,
1185                         gint                    *height );
1186 static void gtk_wx_cell_renderer_render (
1187                         GtkCellRenderer         *cell,
1188                         GdkWindow               *window,
1189                         GtkWidget               *widget,
1190                         GdkRectangle            *background_area,
1191                         GdkRectangle            *cell_area,
1192                         GdkRectangle            *expose_area,
1193                         GtkCellRendererState     flags );
1194 static gboolean gtk_wx_cell_renderer_activate(
1195                         GtkCellRenderer         *cell,
1196                         GdkEvent                *event,
1197                         GtkWidget               *widget,
1198                         const gchar             *path,
1199                         GdkRectangle            *background_area,
1200                         GdkRectangle            *cell_area,
1201                         GtkCellRendererState     flags );
1202 static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
1203                         GtkCellRenderer         *cell,
1204                         GdkEvent                *event,
1205                         GtkWidget               *widget,
1206                         const gchar             *path,
1207                         GdkRectangle            *background_area,
1208                         GdkRectangle            *cell_area,
1209                         GtkCellRendererState     flags );
1210
1211
1212 static GObjectClass *cell_parent_class = NULL;
1213
1214 }  // extern "C"
1215
1216 GType
1217 gtk_wx_cell_renderer_get_type (void)
1218 {
1219     static GType cell_wx_type = 0;
1220
1221     if (!cell_wx_type)
1222     {
1223         const GTypeInfo cell_wx_info =
1224         {
1225             sizeof (GtkWxCellRendererClass),
1226             NULL, /* base_init */
1227             NULL, /* base_finalize */
1228             (GClassInitFunc) gtk_wx_cell_renderer_class_init,
1229             NULL, /* class_finalize */
1230             NULL, /* class_data */
1231             sizeof (GtkWxCellRenderer),
1232             0,          /* n_preallocs */
1233             (GInstanceInitFunc) gtk_wx_cell_renderer_init,
1234         };
1235
1236         cell_wx_type = g_type_register_static( GTK_TYPE_CELL_RENDERER,
1237             "GtkWxCellRenderer", &cell_wx_info, (GTypeFlags)0 );
1238     }
1239
1240     return cell_wx_type;
1241 }
1242
1243 static void
1244 gtk_wx_cell_renderer_init (GtkWxCellRenderer *cell)
1245 {
1246     cell->cell = NULL;
1247     cell->last_click = 0;
1248 }
1249
1250 static void
1251 gtk_wx_cell_renderer_class_init (GtkWxCellRendererClass *klass)
1252 {
1253     GObjectClass *object_class = G_OBJECT_CLASS (klass);
1254     GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
1255
1256     cell_parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
1257
1258     object_class->finalize = gtk_wx_cell_renderer_finalize;
1259
1260     cell_class->get_size = gtk_wx_cell_renderer_get_size;
1261     cell_class->render = gtk_wx_cell_renderer_render;
1262     cell_class->activate = gtk_wx_cell_renderer_activate;
1263     cell_class->start_editing = gtk_wx_cell_renderer_start_editing;
1264 }
1265
1266 static void
1267 gtk_wx_cell_renderer_finalize (GObject *object)
1268 {
1269     /* must chain up */
1270     (* G_OBJECT_CLASS (cell_parent_class)->finalize) (object);
1271 }
1272
1273 GtkCellRenderer*
1274 gtk_wx_cell_renderer_new (void)
1275 {
1276     return (GtkCellRenderer*) g_object_new (GTK_TYPE_WX_CELL_RENDERER, NULL);
1277 }
1278
1279 static GtkCellEditable *gtk_wx_cell_renderer_start_editing(
1280                         GtkCellRenderer         *renderer,
1281                         GdkEvent                *WXUNUSED(event),
1282                         GtkWidget               *widget,
1283                         const gchar             *path,
1284                         GdkRectangle            *WXUNUSED(background_area),
1285                         GdkRectangle            *cell_area,
1286                         GtkCellRendererState     WXUNUSED(flags) )
1287 {
1288     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1289     wxDataViewCustomRenderer *cell = wxrenderer->cell;
1290
1291     // Renderer doesn't support in-place editing
1292     if (!cell->HasEditorCtrl())
1293         return NULL;
1294
1295     // An in-place editing control is still around
1296     if (cell->GetEditorCtrl())
1297         return NULL;
1298
1299     GdkRectangle rect;
1300     gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
1301                                    &rect.x,
1302                                    &rect.y,
1303                                    &rect.width,
1304                                    &rect.height);
1305
1306     rect.x += cell_area->x;
1307     rect.y += cell_area->y;
1308 //    rect.width  -= renderer->xpad * 2;
1309 //    rect.height -= renderer->ypad * 2;
1310
1311 //    wxRect renderrect(wxRectFromGDKRect(&rect));
1312     wxRect renderrect(wxRectFromGDKRect(cell_area));
1313
1314     wxDataViewItem
1315         item(cell->GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(path)));
1316
1317     cell->StartEditing( item, renderrect );
1318
1319     return NULL;
1320 }
1321
1322 static void
1323 gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
1324                                GtkWidget       *WXUNUSED(widget),
1325                                GdkRectangle    *cell_area,
1326                                gint            *x_offset,
1327                                gint            *y_offset,
1328                                gint            *width,
1329                                gint            *height)
1330 {
1331     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1332     wxDataViewCustomRenderer *cell = wxrenderer->cell;
1333
1334     wxSize size = cell->GetSize();
1335
1336     wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
1337
1338     // Uniform row height, if specified, overrides the value returned by the
1339     // renderer.
1340     if ( !ctrl->HasFlag(wxDV_VARIABLE_LINE_HEIGHT) )
1341     {
1342         const int uniformHeight = ctrl->GTKGetUniformRowHeight();
1343         if ( uniformHeight > 0 )
1344             size.y = uniformHeight;
1345     }
1346
1347     int xpad, ypad;
1348     gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1349     int calc_width  = xpad * 2 + size.x;
1350     int calc_height = ypad * 2 + size.y;
1351
1352     if (x_offset)
1353         *x_offset = 0;
1354     if (y_offset)
1355         *y_offset = 0;
1356
1357     if (cell_area && size.x > 0 && size.y > 0)
1358     {
1359         float xalign, yalign;
1360         gtk_cell_renderer_get_alignment(renderer, &xalign, &yalign);
1361         if (x_offset)
1362         {
1363             *x_offset = int(xalign * (cell_area->width - calc_width - 2 * xpad));
1364             *x_offset = MAX(*x_offset, 0) + xpad;
1365         }
1366         if (y_offset)
1367         {
1368             *y_offset = int(yalign * (cell_area->height - calc_height - 2 * ypad));
1369             *y_offset = MAX(*y_offset, 0) + ypad;
1370         }
1371     }
1372
1373     if (width)
1374         *width = calc_width;
1375
1376     if (height)
1377         *height = calc_height;
1378 }
1379
1380 static void
1381 gtk_wx_cell_renderer_render (GtkCellRenderer      *renderer,
1382                              GdkWindow            *window,
1383                              GtkWidget            *widget,
1384                              GdkRectangle         *background_area,
1385                              GdkRectangle         *cell_area,
1386                              GdkRectangle         *expose_area,
1387                              GtkCellRendererState  flags)
1388
1389 {
1390     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1391     wxDataViewCustomRenderer *cell = wxrenderer->cell;
1392
1393     cell->GTKStashRenderParams(window, widget,
1394                                background_area, expose_area, flags);
1395
1396     wxRect rect(wxRectFromGDKRect(cell_area));
1397     int xpad, ypad;
1398     gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1399     rect = rect.Deflate(xpad, ypad);
1400
1401     wxWindowDC* dc = (wxWindowDC*) cell->GetDC();
1402     wxWindowDCImpl *impl = (wxWindowDCImpl *) dc->GetImpl();
1403
1404     // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1405     // window such as a DnD drop window.
1406     if (window != impl->m_gdkwindow)
1407     {
1408         impl->Destroy();
1409         impl->m_gdkwindow = window;
1410         impl->SetUpDC();
1411     }
1412
1413     int state = 0;
1414     if (flags & GTK_CELL_RENDERER_SELECTED)
1415         state |= wxDATAVIEW_CELL_SELECTED;
1416     if (flags & GTK_CELL_RENDERER_PRELIT)
1417         state |= wxDATAVIEW_CELL_PRELIT;
1418     if (flags & GTK_CELL_RENDERER_INSENSITIVE)
1419         state |= wxDATAVIEW_CELL_INSENSITIVE;
1420     if (flags & GTK_CELL_RENDERER_INSENSITIVE)
1421         state |= wxDATAVIEW_CELL_INSENSITIVE;
1422     if (flags & GTK_CELL_RENDERER_FOCUSED)
1423         state |= wxDATAVIEW_CELL_FOCUSED;
1424     cell->WXCallRender( rect, dc, state );
1425 }
1426
1427 static gboolean
1428 gtk_wx_cell_renderer_activate(
1429                         GtkCellRenderer         *renderer,
1430                         GdkEvent                *event,
1431                         GtkWidget               *widget,
1432                         const gchar             *path,
1433                         GdkRectangle            *WXUNUSED(background_area),
1434                         GdkRectangle            *cell_area,
1435                         GtkCellRendererState     WXUNUSED(flags) )
1436 {
1437     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1438     wxDataViewCustomRenderer *cell = wxrenderer->cell;
1439
1440     GdkRectangle rect;
1441     gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
1442                                    &rect.x,
1443                                    &rect.y,
1444                                    &rect.width,
1445                                    &rect.height);
1446
1447     rect.x += cell_area->x;
1448     rect.y += cell_area->y;
1449     int xpad, ypad;
1450     gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1451     rect.width  -= xpad * 2;
1452     rect.height -= ypad * 2;
1453
1454     wxRect renderrect(wxRectFromGDKRect(&rect));
1455
1456     wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
1457     wxDataViewModel *model = ctrl->GetModel();
1458
1459     wxDataViewItem item(ctrl->GTKPathToItem(wxGtkTreePath(path)));
1460
1461     unsigned int model_col = cell->GetOwner()->GetModelColumn();
1462
1463     if (!event)
1464     {
1465         bool ret = false;
1466
1467         // activated by <ENTER>
1468         if (cell->Activate( renderrect, model, item, model_col ))
1469                     ret = true;
1470
1471         return ret;
1472     }
1473     else if (event->type == GDK_BUTTON_PRESS)
1474     {
1475         GdkEventButton *button_event = (GdkEventButton*) event;
1476         wxPoint pt( ((int) button_event->x) - renderrect.x,
1477                     ((int) button_event->y) - renderrect.y );
1478
1479         bool ret = false;
1480         if (button_event->button == 1)
1481         {
1482             if (cell->LeftClick( pt, renderrect, model, item, model_col ))
1483                 ret = true;
1484             // TODO: query system double-click time
1485             if (button_event->time - wxrenderer->last_click < 400)
1486                 if (cell->Activate( renderrect, model, item, model_col ))
1487                     ret = true;
1488         }
1489         wxrenderer->last_click = button_event->time;
1490
1491         return ret;
1492     }
1493
1494     return false;
1495 }
1496
1497 // ---------------------------------------------------------
1498 // wxGtkDataViewModelNotifier
1499 // ---------------------------------------------------------
1500
1501 class wxGtkDataViewModelNotifier: public wxDataViewModelNotifier
1502 {
1503 public:
1504     wxGtkDataViewModelNotifier( wxDataViewModel *wx_model, wxDataViewCtrlInternal *internal );
1505     ~wxGtkDataViewModelNotifier();
1506
1507     virtual bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
1508     virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
1509     virtual bool ItemChanged( const wxDataViewItem &item );
1510     virtual bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );
1511     virtual bool Cleared();
1512     virtual void Resort();
1513     virtual bool BeforeReset();
1514     virtual bool AfterReset();
1515
1516     void UpdateLastCount();
1517
1518 private:
1519     wxDataViewModel         *m_wx_model;
1520     wxDataViewCtrlInternal  *m_internal;
1521 };
1522
1523 // ---------------------------------------------------------
1524 // wxGtkDataViewListModelNotifier
1525 // ---------------------------------------------------------
1526
1527 wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
1528     wxDataViewModel *wx_model, wxDataViewCtrlInternal *internal )
1529 {
1530     m_wx_model = wx_model;
1531     m_internal = internal;
1532 }
1533
1534 wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
1535 {
1536     m_wx_model = NULL;
1537     m_internal = NULL;
1538 }
1539
1540 bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
1541 {
1542     m_internal->ItemAdded( parent, item );
1543     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1544
1545     GtkTreeIter iter;
1546     iter.stamp = wxgtk_model->stamp;
1547     iter.user_data = item.GetID();
1548
1549     wxGtkTreePath path(wxgtk_tree_model_get_path(
1550         GTK_TREE_MODEL(wxgtk_model), &iter ));
1551     gtk_tree_model_row_inserted(
1552         GTK_TREE_MODEL(wxgtk_model), path, &iter);
1553
1554     return true;
1555 }
1556
1557 bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
1558 {
1559     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1560 #if 0
1561     // using _get_path for a deleted item cannot be
1562     // a good idea
1563     GtkTreeIter iter;
1564     iter.stamp = wxgtk_model->stamp;
1565     iter.user_data = (gpointer) item.GetID();
1566     wxGtkTreePath path(wxgtk_tree_model_get_path(
1567         GTK_TREE_MODEL(wxgtk_model), &iter ));
1568 #else
1569     // so get the path from the parent
1570     GtkTreeIter iter;
1571     iter.stamp = wxgtk_model->stamp;
1572     iter.user_data = (gpointer) parent.GetID();
1573     wxGtkTreePath path(wxgtk_tree_model_get_path(
1574         GTK_TREE_MODEL(wxgtk_model), &iter ));
1575     // and add the final index ourselves
1576     int index = m_internal->GetIndexOf( parent, item );
1577     gtk_tree_path_append_index( path, index );
1578 #endif
1579
1580     gtk_tree_model_row_deleted(
1581         GTK_TREE_MODEL(wxgtk_model), path );
1582
1583     m_internal->ItemDeleted( parent, item );
1584
1585     return true;
1586 }
1587
1588 void wxGtkDataViewModelNotifier::Resort()
1589 {
1590     m_internal->Resort();
1591 }
1592
1593 bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem &item )
1594 {
1595     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1596
1597     GtkTreeIter iter;
1598     iter.stamp = wxgtk_model->stamp;
1599     iter.user_data = (gpointer) item.GetID();
1600
1601     wxGtkTreePath path(wxgtk_tree_model_get_path(
1602         GTK_TREE_MODEL(wxgtk_model), &iter ));
1603     gtk_tree_model_row_changed(
1604         GTK_TREE_MODEL(wxgtk_model), path, &iter );
1605
1606     m_internal->ItemChanged( item );
1607
1608     return true;
1609 }
1610
1611 bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem &item, unsigned int model_column )
1612 {
1613     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1614     wxDataViewCtrl *ctrl = m_internal->GetOwner();
1615
1616     // This adds GTK+'s missing MVC logic for ValueChanged
1617     unsigned int index;
1618     for (index = 0; index < ctrl->GetColumnCount(); index++)
1619     {
1620         wxDataViewColumn *column = ctrl->GetColumn( index );
1621         if (column->GetModelColumn() == model_column)
1622         {
1623             GtkTreeView *widget = GTK_TREE_VIEW(ctrl->GtkGetTreeView());
1624             GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
1625
1626             // Get cell area
1627             GtkTreeIter iter;
1628             iter.stamp = wxgtk_model->stamp;
1629             iter.user_data = (gpointer) item.GetID();
1630             wxGtkTreePath path(wxgtk_tree_model_get_path(
1631                 GTK_TREE_MODEL(wxgtk_model), &iter ));
1632             GdkRectangle cell_area;
1633             gtk_tree_view_get_cell_area( widget, path, gcolumn, &cell_area );
1634
1635             GtkAdjustment* hadjust = gtk_tree_view_get_hadjustment( widget );
1636             double d = gtk_adjustment_get_value( hadjust );
1637             int xdiff = (int) d;
1638
1639             int ydiff = gcolumn->button->allocation.height;
1640             // Redraw
1641             gtk_widget_queue_draw_area( GTK_WIDGET(widget),
1642                 cell_area.x - xdiff, ydiff + cell_area.y, cell_area.width, cell_area.height );
1643
1644             m_internal->ValueChanged( item, model_column );
1645
1646             return true;
1647         }
1648     }
1649
1650     return false;
1651 }
1652
1653 bool wxGtkDataViewModelNotifier::BeforeReset()
1654 {
1655     GtkWidget *treeview = m_internal->GetOwner()->GtkGetTreeView();
1656     gtk_tree_view_set_model( GTK_TREE_VIEW(treeview), NULL );
1657
1658     return true;
1659 }
1660
1661 bool wxGtkDataViewModelNotifier::AfterReset()
1662 {
1663     GtkWidget *treeview = m_internal->GetOwner()->GtkGetTreeView();
1664     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1665
1666     m_internal->Cleared();
1667
1668     gtk_tree_view_set_model( GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(wxgtk_model) );
1669
1670     return true;
1671 }
1672
1673 bool wxGtkDataViewModelNotifier::Cleared()
1674 {
1675     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1676
1677     // There is no call to tell the model that everything
1678     // has been deleted so call row_deleted() for every
1679     // child of root...
1680
1681     int count = m_internal->iter_n_children( NULL ); // number of children of root
1682
1683     GtkTreePath *path = gtk_tree_path_new_first();  // points to root
1684
1685     int i;
1686     for (i = 0; i < count; i++)
1687         gtk_tree_model_row_deleted( GTK_TREE_MODEL(wxgtk_model), path );
1688
1689     gtk_tree_path_free( path );
1690
1691     m_internal->Cleared();
1692
1693     return true;
1694 }
1695
1696 // ---------------------------------------------------------
1697 // wxDataViewRenderer
1698 // ---------------------------------------------------------
1699
1700 static gpointer s_user_data = NULL;
1701
1702 static void
1703 wxgtk_cell_editable_editing_done( GtkCellEditable *WXUNUSED(editable),
1704                                   wxDataViewRenderer *wxrenderer )
1705 {
1706     wxDataViewColumn *column = wxrenderer->GetOwner();
1707     wxDataViewCtrl *dv = column->GetOwner();
1708     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv->GetId() );
1709     event.SetDataViewColumn( column );
1710     event.SetModel( dv->GetModel() );
1711     wxDataViewItem item( s_user_data );
1712     event.SetItem( item );
1713     dv->HandleWindowEvent( event );
1714 }
1715
1716 static void
1717 wxgtk_renderer_editing_started( GtkCellRenderer *WXUNUSED(cell), GtkCellEditable *editable,
1718                                 gchar *path, wxDataViewRenderer *wxrenderer )
1719 {
1720     if (!editable)
1721        return;
1722
1723     wxDataViewColumn *column = wxrenderer->GetOwner();
1724     wxDataViewCtrl *dv = column->GetOwner();
1725     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, dv->GetId() );
1726     event.SetDataViewColumn( column );
1727     event.SetModel( dv->GetModel() );
1728     wxDataViewItem item(dv->GTKPathToItem(wxGtkTreePath(path)));
1729     event.SetItem( item );
1730     dv->HandleWindowEvent( event );
1731
1732     if (GTK_IS_CELL_EDITABLE(editable))
1733     {
1734         s_user_data = item.GetID();
1735
1736         g_signal_connect (GTK_CELL_EDITABLE (editable), "editing_done",
1737             G_CALLBACK (wxgtk_cell_editable_editing_done),
1738             (gpointer) wxrenderer );
1739
1740     }
1741 }
1742
1743
1744 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
1745
1746 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1747                                         int align ) :
1748     wxDataViewRendererBase( varianttype, mode, align )
1749 {
1750     m_renderer = NULL;
1751     m_mode = mode;
1752
1753     // we haven't changed them yet
1754     m_usingDefaultAttrs = true;
1755
1756     // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1757     //       after the m_renderer pointer has been initialized
1758 }
1759
1760 void wxDataViewRenderer::GtkPackIntoColumn(GtkTreeViewColumn *column)
1761 {
1762     gtk_tree_view_column_pack_end( column, m_renderer, TRUE /* expand */);
1763 }
1764
1765 void wxDataViewRenderer::GtkInitHandlers()
1766 {
1767     if (!gtk_check_version(2,6,0))
1768     {
1769         g_signal_connect (GTK_CELL_RENDERER(m_renderer), "editing_started",
1770             G_CALLBACK (wxgtk_renderer_editing_started),
1771             this);
1772     }
1773 }
1774
1775 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode )
1776 {
1777     GtkCellRendererMode gtkMode;
1778     switch (mode)
1779     {
1780         case wxDATAVIEW_CELL_INERT:
1781             gtkMode = GTK_CELL_RENDERER_MODE_INERT;
1782             break;
1783
1784         case wxDATAVIEW_CELL_ACTIVATABLE:
1785             gtkMode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
1786             break;
1787
1788         case wxDATAVIEW_CELL_EDITABLE:
1789             gtkMode = GTK_CELL_RENDERER_MODE_EDITABLE;
1790             break;
1791
1792         default:
1793             wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1794             return;
1795     }
1796
1797     m_mode = mode;
1798
1799     // This value is most often ignored in GtkTreeView
1800     GValue gvalue = { 0, };
1801     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1802     g_value_set_enum( &gvalue, gtkMode );
1803     g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue );
1804     g_value_unset( &gvalue );
1805 }
1806
1807 wxDataViewCellMode wxDataViewRenderer::GetMode() const
1808 {
1809     wxDataViewCellMode ret;
1810
1811     GValue gvalue;
1812     g_object_get( G_OBJECT(m_renderer), "mode", &gvalue, NULL);
1813
1814     switch (g_value_get_enum(&gvalue))
1815     {
1816         default:
1817             wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1818             // fall through (we have to return something)
1819
1820         case GTK_CELL_RENDERER_MODE_INERT:
1821             ret = wxDATAVIEW_CELL_INERT;
1822             break;
1823
1824         case GTK_CELL_RENDERER_MODE_ACTIVATABLE:
1825             ret = wxDATAVIEW_CELL_ACTIVATABLE;
1826             break;
1827
1828         case GTK_CELL_RENDERER_MODE_EDITABLE:
1829             ret = wxDATAVIEW_CELL_EDITABLE;
1830             break;
1831     }
1832
1833     g_value_unset( &gvalue );
1834
1835     return ret;
1836 }
1837
1838 void wxDataViewRenderer::GtkApplyAlignment(GtkCellRenderer *renderer)
1839 {
1840     int align = m_alignment;
1841
1842     // query alignment from column ?
1843     if (align == -1)
1844     {
1845         // None there yet
1846         if (GetOwner() == NULL)
1847             return;
1848
1849         align = GetOwner()->GetAlignment();
1850         align |= wxALIGN_CENTRE_VERTICAL;
1851     }
1852
1853     // horizontal alignment:
1854
1855     gfloat xalign = 0.0;
1856     if (align & wxALIGN_RIGHT)
1857         xalign = 1.0;
1858     else if (align & wxALIGN_CENTER_HORIZONTAL)
1859         xalign = 0.5;
1860
1861     GValue gvalue = { 0, };
1862     g_value_init( &gvalue, G_TYPE_FLOAT );
1863     g_value_set_float( &gvalue, xalign );
1864     g_object_set_property( G_OBJECT(renderer), "xalign", &gvalue );
1865     g_value_unset( &gvalue );
1866
1867     // vertical alignment:
1868
1869     gfloat yalign = 0.0;
1870     if (align & wxALIGN_BOTTOM)
1871         yalign = 1.0;
1872     else if (align & wxALIGN_CENTER_VERTICAL)
1873         yalign = 0.5;
1874
1875     GValue gvalue2 = { 0, };
1876     g_value_init( &gvalue2, G_TYPE_FLOAT );
1877     g_value_set_float( &gvalue2, yalign );
1878     g_object_set_property( G_OBJECT(renderer), "yalign", &gvalue2 );
1879     g_value_unset( &gvalue2 );
1880 }
1881
1882 void wxDataViewRenderer::SetAlignment( int align )
1883 {
1884     m_alignment = align;
1885     GtkUpdateAlignment();
1886 }
1887
1888 int wxDataViewRenderer::GetAlignment() const
1889 {
1890     return m_alignment;
1891 }
1892
1893 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode)
1894 {
1895 #ifdef __WXGTK26__
1896     if ( gtk_check_version(2, 6, 0) != NULL )
1897         return;
1898
1899     GtkCellRendererText * const rend = GtkGetTextRenderer();
1900     if ( !rend )
1901         return;
1902
1903     // we use the same values in wxEllipsizeMode as PangoEllipsizeMode so we
1904     // can just cast between them
1905     GValue gvalue = { 0, };
1906     g_value_init( &gvalue, PANGO_TYPE_ELLIPSIZE_MODE );
1907     g_value_set_enum( &gvalue, static_cast<PangoEllipsizeMode>(mode) );
1908     g_object_set_property( G_OBJECT(rend), "ellipsize", &gvalue );
1909     g_value_unset( &gvalue );
1910 #else // GTK < 2.6
1911     wxUnusedVar(mode);
1912 #endif // GTK 2.6/before
1913 }
1914
1915 wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const
1916 {
1917 #ifdef __WXGTK26__
1918     if ( gtk_check_version(2, 6, 0) != NULL )
1919         return wxELLIPSIZE_NONE;
1920
1921     GtkCellRendererText * const rend = GtkGetTextRenderer();
1922     if ( !rend )
1923         return wxELLIPSIZE_NONE;
1924
1925     GValue gvalue = { 0, };
1926     g_value_init( &gvalue, PANGO_TYPE_ELLIPSIZE_MODE );
1927     g_object_get_property( G_OBJECT(rend), "ellipsize", &gvalue );
1928     wxEllipsizeMode
1929         mode = static_cast<wxEllipsizeMode>(g_value_get_enum( &gvalue ));
1930     g_value_unset( &gvalue );
1931
1932     return mode;
1933 #else // GTK < 2.6
1934     return wxELLIPSIZE_NONE;
1935 #endif // GTK 2.6/before
1936 }
1937
1938 void
1939 wxDataViewRenderer::GtkOnTextEdited(const gchar *itempath, const wxString& str)
1940 {
1941     wxVariant value(str);
1942     if (!Validate( value ))
1943         return;
1944
1945     wxDataViewItem
1946         item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath)));
1947
1948     GtkOnCellChanged(value, item, GetOwner()->GetModelColumn());
1949 }
1950
1951 void
1952 wxDataViewRenderer::GtkOnCellChanged(const wxVariant& value,
1953                                      const wxDataViewItem& item,
1954                                      unsigned col)
1955 {
1956     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
1957     model->ChangeValue( value, item, col );
1958 }
1959
1960 // ---------------------------------------------------------
1961 // wxDataViewTextRenderer
1962 // ---------------------------------------------------------
1963
1964 extern "C"
1965 {
1966
1967 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *WXUNUSED(renderer),
1968     gchar *arg1, gchar *arg2, gpointer user_data )
1969 {
1970     wxDataViewRenderer *cell = (wxDataViewRenderer*) user_data;
1971
1972     cell->GtkOnTextEdited(arg1, wxGTK_CONV_BACK_FONT(
1973                 arg2, cell->GetOwner()->GetOwner()->GetFont()));
1974 }
1975
1976 }
1977
1978 namespace
1979 {
1980
1981 // helper function used by wxDataViewTextRenderer and
1982 // wxDataViewCustomRenderer::RenderText(): it applies the attributes to the
1983 // given text renderer and returns true if anything was done
1984 bool GtkApplyAttr(GtkCellRendererText *renderer, const wxDataViewItemAttr& attr)
1985 {
1986     bool usingDefaultAttrs = true;
1987     if (attr.HasColour())
1988     {
1989         const GdkColor * const gcol = attr.GetColour().GetColor();
1990
1991         GValue gvalue = { 0, };
1992         g_value_init( &gvalue, GDK_TYPE_COLOR );
1993         g_value_set_boxed( &gvalue, gcol );
1994         g_object_set_property( G_OBJECT(renderer), "foreground_gdk", &gvalue );
1995         g_value_unset( &gvalue );
1996
1997         usingDefaultAttrs = false;
1998     }
1999     else
2000     {
2001         GValue gvalue = { 0, };
2002         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2003         g_value_set_boolean( &gvalue, FALSE );
2004         g_object_set_property( G_OBJECT(renderer), "foreground-set", &gvalue );
2005         g_value_unset( &gvalue );
2006     }
2007
2008     if (attr.GetItalic())
2009     {
2010         GValue gvalue = { 0, };
2011         g_value_init( &gvalue, PANGO_TYPE_STYLE );
2012         g_value_set_enum( &gvalue, PANGO_STYLE_ITALIC );
2013         g_object_set_property( G_OBJECT(renderer), "style", &gvalue );
2014         g_value_unset( &gvalue );
2015
2016         usingDefaultAttrs = false;
2017     }
2018     else
2019     {
2020         GValue gvalue = { 0, };
2021         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2022         g_value_set_boolean( &gvalue, FALSE );
2023         g_object_set_property( G_OBJECT(renderer), "style-set", &gvalue );
2024         g_value_unset( &gvalue );
2025     }
2026
2027
2028     if (attr.GetBold())
2029     {
2030         GValue gvalue = { 0, };
2031         g_value_init( &gvalue, PANGO_TYPE_WEIGHT );
2032         g_value_set_enum( &gvalue, PANGO_WEIGHT_BOLD );
2033         g_object_set_property( G_OBJECT(renderer), "weight", &gvalue );
2034         g_value_unset( &gvalue );
2035
2036         usingDefaultAttrs = false;
2037     }
2038     else
2039     {
2040         GValue gvalue = { 0, };
2041         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2042         g_value_set_boolean( &gvalue, FALSE );
2043         g_object_set_property( G_OBJECT(renderer), "weight-set", &gvalue );
2044         g_value_unset( &gvalue );
2045     }
2046
2047 #if 0
2048     if (attr.HasBackgroundColour())
2049     {
2050         wxColour colour = attr.GetBackgroundColour();
2051         const GdkColor * const gcol = colour.GetColor();
2052
2053         GValue gvalue = { 0, };
2054         g_value_init( &gvalue, GDK_TYPE_COLOR );
2055         g_value_set_boxed( &gvalue, gcol );
2056         g_object_set_property( G_OBJECT(renderer), "cell-background_gdk", &gvalue );
2057         g_value_unset( &gvalue );
2058     }
2059     else
2060     {
2061         GValue gvalue = { 0, };
2062         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2063         g_value_set_boolean( &gvalue, FALSE );
2064         g_object_set_property( G_OBJECT(renderer), "cell-background-set", &gvalue );
2065         g_value_unset( &gvalue );
2066     }
2067 #endif
2068
2069     return !usingDefaultAttrs;
2070 }
2071
2072 } // anonymous namespace
2073
2074 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer)
2075
2076 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode,
2077                                                 int align ) :
2078     wxDataViewRenderer( varianttype, mode, align )
2079 {
2080     GtkWxCellRendererText *text_renderer = gtk_wx_cell_renderer_text_new();
2081     text_renderer->wx_renderer = this;
2082     m_renderer = (GtkCellRenderer*) text_renderer;
2083
2084     if (mode & wxDATAVIEW_CELL_EDITABLE)
2085     {
2086         GValue gvalue = { 0, };
2087         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2088         g_value_set_boolean( &gvalue, true );
2089         g_object_set_property( G_OBJECT(m_renderer), "editable", &gvalue );
2090         g_value_unset( &gvalue );
2091
2092         g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
2093
2094         GtkInitHandlers();
2095     }
2096
2097     SetMode(mode);
2098     SetAlignment(align);
2099 }
2100
2101 bool wxDataViewTextRenderer::SetTextValue(const wxString& str)
2102 {
2103     GValue gvalue = { 0, };
2104     g_value_init( &gvalue, G_TYPE_STRING );
2105     g_value_set_string( &gvalue, wxGTK_CONV_FONT( str, GetOwner()->GetOwner()->GetFont() ) );
2106     g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2107     g_value_unset( &gvalue );
2108
2109     return true;
2110 }
2111
2112 bool wxDataViewTextRenderer::GetTextValue(wxString& str) const
2113 {
2114     GValue gvalue = { 0, };
2115     g_value_init( &gvalue, G_TYPE_STRING );
2116     g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
2117     str = wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue ), const_cast<wxDataViewTextRenderer*>(this)->GetOwner()->GetOwner()->GetFont() );
2118     g_value_unset( &gvalue );
2119
2120     return true;
2121 }
2122
2123 void wxDataViewTextRenderer::SetAlignment( int align )
2124 {
2125     wxDataViewRenderer::SetAlignment(align);
2126
2127     if (gtk_check_version(2,10,0))
2128         return;
2129
2130     // horizontal alignment:
2131     PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
2132     if (align & wxALIGN_RIGHT)
2133         pangoAlign = PANGO_ALIGN_RIGHT;
2134     else if (align & wxALIGN_CENTER_HORIZONTAL)
2135         pangoAlign = PANGO_ALIGN_CENTER;
2136
2137     GValue gvalue = { 0, };
2138     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
2139     g_value_set_enum( &gvalue, pangoAlign );
2140     g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
2141     g_value_unset( &gvalue );
2142 }
2143
2144 bool wxDataViewTextRenderer::GtkSetAttr(const wxDataViewItemAttr& attr)
2145 {
2146     return GtkApplyAttr(GtkGetTextRenderer(), attr);
2147 }
2148
2149 GtkCellRendererText *wxDataViewTextRenderer::GtkGetTextRenderer() const
2150 {
2151     return GTK_CELL_RENDERER_TEXT(m_renderer);
2152 }
2153
2154 // ---------------------------------------------------------
2155 // wxDataViewBitmapRenderer
2156 // ---------------------------------------------------------
2157
2158 namespace
2159 {
2160
2161 // set "pixbuf" property on the given renderer
2162 void SetPixbufProp(GtkCellRenderer *renderer, GdkPixbuf *pixbuf)
2163 {
2164     GValue gvalue = { 0, };
2165     g_value_init( &gvalue, G_TYPE_OBJECT );
2166     g_value_set_object( &gvalue, pixbuf );
2167     g_object_set_property( G_OBJECT(renderer), "pixbuf", &gvalue );
2168     g_value_unset( &gvalue );
2169 }
2170
2171 } // anonymous namespace
2172
2173 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer)
2174
2175 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode,
2176                                                     int align ) :
2177     wxDataViewRenderer( varianttype, mode, align )
2178 {
2179     m_renderer = gtk_cell_renderer_pixbuf_new();
2180
2181     SetMode(mode);
2182     SetAlignment(align);
2183 }
2184
2185 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
2186 {
2187     if (value.GetType() == wxT("wxBitmap"))
2188     {
2189         wxBitmap bitmap;
2190         bitmap << value;
2191
2192         // GetPixbuf() may create a Pixbuf representation in the wxBitmap
2193         // object (and it will stay there and remain owned by wxBitmap)
2194         SetPixbufProp(m_renderer, bitmap.GetPixbuf());
2195     }
2196     else if (value.GetType() == wxT("wxIcon"))
2197     {
2198         wxIcon icon;
2199         icon << value;
2200
2201         SetPixbufProp(m_renderer, icon.GetPixbuf());
2202     }
2203     else
2204     {
2205         return false;
2206     }
2207
2208     return true;
2209 }
2210
2211 bool wxDataViewBitmapRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2212 {
2213     return false;
2214 }
2215
2216 // ---------------------------------------------------------
2217 // wxDataViewToggleRenderer
2218 // ---------------------------------------------------------
2219
2220 extern "C" {
2221 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
2222     gchar *path, gpointer user_data );
2223 }
2224
2225 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
2226     gchar *path, gpointer user_data )
2227 {
2228     wxDataViewToggleRenderer *cell = (wxDataViewToggleRenderer*) user_data;
2229
2230     // get old value
2231     GValue gvalue = { 0, };
2232     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2233     g_object_get_property( G_OBJECT(renderer), "active", &gvalue );
2234     bool tmp = g_value_get_boolean( &gvalue );
2235     g_value_unset( &gvalue );
2236     // invert it
2237     tmp = !tmp;
2238
2239     wxVariant value = tmp;
2240     if (!cell->Validate( value ))
2241         return;
2242
2243     wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
2244     wxDataViewModel *model = ctrl->GetModel();
2245
2246     wxDataViewItem item(ctrl->GTKPathToItem(wxGtkTreePath(path)));
2247
2248     unsigned int model_col = cell->GetOwner()->GetModelColumn();
2249
2250     model->ChangeValue( value, item, model_col );
2251 }
2252
2253 IMPLEMENT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer)
2254
2255 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
2256                                                     wxDataViewCellMode mode, int align ) :
2257     wxDataViewRenderer( varianttype, mode, align )
2258 {
2259     m_renderer = (GtkCellRenderer*) gtk_cell_renderer_toggle_new();
2260
2261     if (mode & wxDATAVIEW_CELL_ACTIVATABLE)
2262     {
2263         g_signal_connect_after( m_renderer, "toggled",
2264                                 G_CALLBACK(wxGtkToggleRendererToggledCallback), this );
2265     }
2266     else
2267     {
2268         GValue gvalue = { 0, };
2269         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2270         g_value_set_boolean( &gvalue, false );
2271         g_object_set_property( G_OBJECT(m_renderer), "activatable", &gvalue );
2272         g_value_unset( &gvalue );
2273     }
2274
2275     SetMode(mode);
2276     SetAlignment(align);
2277 }
2278
2279 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
2280 {
2281     bool tmp = value;
2282
2283     GValue gvalue = { 0, };
2284     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2285     g_value_set_boolean( &gvalue, tmp );
2286     g_object_set_property( G_OBJECT(m_renderer), "active", &gvalue );
2287     g_value_unset( &gvalue );
2288
2289     return true;
2290 }
2291
2292 bool wxDataViewToggleRenderer::GetValue( wxVariant &value ) const
2293 {
2294     GValue gvalue = { 0, };
2295     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2296     g_object_get_property( G_OBJECT(m_renderer), "active", &gvalue );
2297     bool tmp = g_value_get_boolean( &gvalue );
2298     g_value_unset( &gvalue );
2299
2300     value = tmp;
2301
2302     return true;
2303 }
2304
2305 // ---------------------------------------------------------
2306 // wxDataViewCustomRenderer
2307 // ---------------------------------------------------------
2308
2309 class wxDataViewCtrlDCImpl: public wxWindowDCImpl
2310 {
2311 public:
2312    wxDataViewCtrlDCImpl( wxDC *owner, wxDataViewCtrl *window ) :
2313        wxWindowDCImpl( owner )
2314    {
2315         GtkWidget *widget = window->m_treeview;
2316         // Set later
2317         m_gdkwindow = NULL;
2318
2319         m_window = window;
2320
2321         m_context = window->GTKGetPangoDefaultContext();
2322         m_layout = pango_layout_new( m_context );
2323         m_fontdesc = pango_font_description_copy(gtk_widget_get_style(widget)->font_desc);
2324
2325         m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
2326
2327         // Set m_gdkwindow later
2328         // SetUpDC();
2329     }
2330 };
2331
2332 class wxDataViewCtrlDC: public wxWindowDC
2333 {
2334 public:
2335     wxDataViewCtrlDC( wxDataViewCtrl *window ) :
2336         wxWindowDC( new wxDataViewCtrlDCImpl( this, window ) )
2337         { }
2338 };
2339
2340
2341 // ---------------------------------------------------------
2342 // wxDataViewCustomRenderer
2343 // ---------------------------------------------------------
2344
2345 IMPLEMENT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
2346
2347 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
2348                                                     wxDataViewCellMode mode,
2349                                                     int align,
2350                                                     bool no_init )
2351     : wxDataViewCustomRendererBase( varianttype, mode, align )
2352 {
2353     m_dc = NULL;
2354     m_text_renderer = NULL;
2355
2356     if (no_init)
2357         m_renderer = NULL;
2358     else
2359         Init(mode, align);
2360 }
2361
2362 void wxDataViewCustomRenderer::GtkInitTextRenderer()
2363 {
2364     m_text_renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
2365     g_object_ref_sink(m_text_renderer);
2366
2367     GtkApplyAlignment(GTK_CELL_RENDERER(m_text_renderer));
2368 }
2369
2370 GtkCellRendererText *wxDataViewCustomRenderer::GtkGetTextRenderer() const
2371 {
2372     if ( !m_text_renderer )
2373     {
2374         // we create it on demand so need to do it even from a const function
2375         const_cast<wxDataViewCustomRenderer *>(this)->GtkInitTextRenderer();
2376     }
2377
2378     return m_text_renderer;
2379 }
2380
2381 void wxDataViewCustomRenderer::RenderText( const wxString &text,
2382                                            int xoffset,
2383                                            wxRect cell,
2384                                            wxDC *WXUNUSED(dc),
2385                                            int WXUNUSED(state) )
2386 {
2387
2388     GtkCellRendererText * const textRenderer = GtkGetTextRenderer();
2389
2390     GValue gvalue = { 0, };
2391     g_value_init( &gvalue, G_TYPE_STRING );
2392     g_value_set_string( &gvalue, wxGTK_CONV_FONT( text, GetOwner()->GetOwner()->GetFont() ) );
2393     g_object_set_property( G_OBJECT(textRenderer), "text", &gvalue );
2394     g_value_unset( &gvalue );
2395
2396     GtkApplyAttr(textRenderer, GetAttr());
2397
2398     GdkRectangle cell_area;
2399     wxRectToGDKRect(cell, cell_area);
2400     cell_area.x += xoffset;
2401     cell_area.width -= xoffset;
2402
2403     gtk_cell_renderer_render( GTK_CELL_RENDERER(textRenderer),
2404         m_renderParams.window,
2405         m_renderParams.widget,
2406         m_renderParams.background_area,
2407         &cell_area,
2408         m_renderParams.expose_area,
2409         (GtkCellRendererState) m_renderParams.flags );
2410 }
2411
2412 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode, int align)
2413 {
2414     GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
2415     renderer->cell = this;
2416
2417     m_renderer = (GtkCellRenderer*) renderer;
2418
2419     SetMode(mode);
2420     SetAlignment(align);
2421
2422     GtkInitHandlers();
2423
2424     return true;
2425 }
2426
2427 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
2428 {
2429     if (m_dc)
2430         delete m_dc;
2431
2432     if (m_text_renderer)
2433         g_object_unref(m_text_renderer);
2434 }
2435
2436 wxDC *wxDataViewCustomRenderer::GetDC()
2437 {
2438     if (m_dc == NULL)
2439     {
2440         if (GetOwner() == NULL)
2441             return NULL;
2442         if (GetOwner()->GetOwner() == NULL)
2443             return NULL;
2444         m_dc = new wxDataViewCtrlDC( GetOwner()->GetOwner() );
2445     }
2446
2447     return m_dc;
2448 }
2449
2450 // ---------------------------------------------------------
2451 // wxDataViewProgressRenderer
2452 // ---------------------------------------------------------
2453
2454 IMPLEMENT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
2455
2456 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
2457     const wxString &varianttype, wxDataViewCellMode mode, int align ) :
2458     wxDataViewCustomRenderer( varianttype, mode, align, true )
2459 {
2460     m_label = label;
2461     m_value = 0;
2462
2463 #ifdef __WXGTK26__
2464     if (!gtk_check_version(2,6,0))
2465     {
2466         m_renderer = (GtkCellRenderer*) gtk_cell_renderer_progress_new();
2467
2468         SetMode(mode);
2469         SetAlignment(align);
2470
2471 #if !wxUSE_UNICODE
2472         // We can't initialize the renderer just yet because we don't have the
2473         // pointer to the column that uses this renderer yet and so attempt to
2474         // dereference GetOwner() to get the font that is used as a source of
2475         // encoding in multibyte-to-Unicode conversion in GTKSetLabel() in
2476         // non-Unicode builds would crash. So simply remember to do it later.
2477         if ( !m_label.empty() )
2478             m_needsToSetLabel = true;
2479         else
2480 #endif // !wxUSE_UNICODE
2481             GTKSetLabel();
2482     }
2483     else
2484 #endif
2485     {
2486         // Use custom cell code
2487         wxDataViewCustomRenderer::Init(mode, align);
2488     }
2489 }
2490
2491 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
2492 {
2493 }
2494
2495 void wxDataViewProgressRenderer::GTKSetLabel()
2496 {
2497     GValue gvalue = { 0, };
2498     g_value_init( &gvalue, G_TYPE_STRING );
2499
2500     // Take care to not use GetOwner() here if the label is empty, we can be
2501     // called from ctor when GetOwner() is still NULL in this case.
2502     g_value_set_string( &gvalue,
2503                         m_label.empty() ? ""
2504                                         : wxGTK_CONV_FONT(m_label,
2505                                             GetOwner()->GetOwner()->GetFont())
2506                       );
2507     g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2508     g_value_unset( &gvalue );
2509
2510 #if !wxUSE_UNICODE
2511     m_needsToSetLabel = false;
2512 #endif // !wxUSE_UNICODE
2513 }
2514
2515 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
2516 {
2517 #ifdef __WXGTK26__
2518     if (!gtk_check_version(2,6,0))
2519     {
2520 #if !wxUSE_UNICODE
2521         if ( m_needsToSetLabel )
2522             GTKSetLabel();
2523 #endif // !wxUSE_UNICODE
2524
2525         gint tmp = (long) value;
2526         GValue gvalue = { 0, };
2527         g_value_init( &gvalue, G_TYPE_INT );
2528         g_value_set_int( &gvalue, tmp );
2529         g_object_set_property( G_OBJECT(m_renderer), "value", &gvalue );
2530         g_value_unset( &gvalue );
2531     }
2532     else
2533 #endif
2534     {
2535         m_value = (long) value;
2536
2537         if (m_value < 0) m_value = 0;
2538         if (m_value > 100) m_value = 100;
2539     }
2540
2541     return true;
2542 }
2543
2544 bool wxDataViewProgressRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2545 {
2546     return false;
2547 }
2548
2549 bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
2550 {
2551     double pct = (double)m_value / 100.0;
2552     wxRect bar = cell;
2553     bar.width = (int)(cell.width * pct);
2554     dc->SetPen( *wxTRANSPARENT_PEN );
2555     dc->SetBrush( *wxBLUE_BRUSH );
2556     dc->DrawRectangle( bar );
2557
2558     dc->SetBrush( *wxTRANSPARENT_BRUSH );
2559     dc->SetPen( *wxBLACK_PEN );
2560     dc->DrawRectangle( cell );
2561
2562     return true;
2563 }
2564
2565 wxSize wxDataViewProgressRenderer::GetSize() const
2566 {
2567     return wxSize(40,12);
2568 }
2569
2570 // -------------------------------------
2571 // wxDataViewChoiceRenderer
2572 // -------------------------------------
2573
2574 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString &choices,
2575                             wxDataViewCellMode mode, int alignment  ) :
2576     wxDataViewCustomRenderer( "string", mode, alignment, true )
2577 {
2578    m_choices = choices;
2579
2580 #ifdef __WXGTK26__
2581     if (!gtk_check_version(2,6,0))
2582     {
2583         m_renderer = (GtkCellRenderer*) gtk_cell_renderer_combo_new();
2584
2585         GtkListStore *store = gtk_list_store_new( 1, G_TYPE_STRING );
2586         for (size_t n = 0; n < m_choices.GetCount(); n++)
2587         {
2588             gtk_list_store_insert_with_values(
2589                 store, NULL, n, 0,
2590                 static_cast<const char *>(m_choices[n].utf8_str()), -1 );
2591         }
2592
2593         g_object_set (m_renderer,
2594                 "model", store,
2595                 "text-column", 0,
2596                 "has-entry", FALSE,
2597                 NULL);
2598
2599         bool editable = (mode & wxDATAVIEW_CELL_EDITABLE);
2600         g_object_set (m_renderer, "editable", editable, NULL);
2601
2602         SetAlignment(alignment);
2603
2604         g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
2605
2606         GtkInitHandlers();
2607     }
2608     else
2609 #endif
2610     {
2611         // Use custom cell code
2612         wxDataViewCustomRenderer::Init(mode, alignment);
2613     }
2614 }
2615
2616 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
2617 {
2618     RenderText( m_data, 0, rect, dc, state );
2619     return true;
2620 }
2621
2622 wxSize wxDataViewChoiceRenderer::GetSize() const
2623 {
2624     return wxSize(70,20);
2625 }
2626
2627 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
2628 {
2629
2630 #ifdef __WXGTK26__
2631     if (!gtk_check_version(2,6,0))
2632     {
2633         GValue gvalue = { 0, };
2634         g_value_init( &gvalue, G_TYPE_STRING );
2635         g_value_set_string(&gvalue,
2636                            wxGTK_CONV_FONT(value.GetString(),
2637                                            GetOwner()->GetOwner()->GetFont()));
2638         g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2639         g_value_unset( &gvalue );
2640     }
2641     else
2642 #endif
2643         m_data = value.GetString();
2644
2645     return true;
2646 }
2647
2648 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
2649 {
2650 #ifdef __WXGTK26__
2651     if (!gtk_check_version(2,6,0))
2652     {
2653         GValue gvalue = { 0, };
2654         g_value_init( &gvalue, G_TYPE_STRING );
2655         g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
2656         wxString temp = wxGTK_CONV_BACK_FONT(g_value_get_string(&gvalue),
2657                                              GetOwner()->GetOwner()->GetFont());
2658         g_value_unset( &gvalue );
2659         value = temp;
2660
2661         //wxPrintf( "temp %s\n", temp );
2662         // TODO: remove this code
2663     }
2664     else
2665 #endif
2666         value = m_data;
2667
2668     return true;
2669 }
2670
2671 void wxDataViewChoiceRenderer::SetAlignment( int align )
2672 {
2673     wxDataViewCustomRenderer::SetAlignment(align);
2674
2675     if (gtk_check_version(2,10,0))
2676         return;
2677
2678     // horizontal alignment:
2679     PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
2680     if (align & wxALIGN_RIGHT)
2681         pangoAlign = PANGO_ALIGN_RIGHT;
2682     else if (align & wxALIGN_CENTER_HORIZONTAL)
2683         pangoAlign = PANGO_ALIGN_CENTER;
2684
2685     GValue gvalue = { 0, };
2686     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
2687     g_value_set_enum( &gvalue, pangoAlign );
2688     g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
2689     g_value_unset( &gvalue );
2690 }
2691
2692 // ----------------------------------------------------------------------------
2693 // wxDataViewChoiceByIndexRenderer
2694 // ----------------------------------------------------------------------------
2695
2696 wxDataViewChoiceByIndexRenderer::wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
2697                               wxDataViewCellMode mode, int alignment ) :
2698       wxDataViewChoiceRenderer( choices, mode, alignment )
2699 {
2700 }
2701
2702 void wxDataViewChoiceByIndexRenderer::GtkOnTextEdited(const gchar *itempath, const wxString& str)
2703 {
2704     wxVariant value( (long) GetChoices().Index( str ) );
2705
2706     if (!Validate( value ))
2707         return;
2708
2709     wxDataViewItem
2710         item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath)));
2711
2712     GtkOnCellChanged(value, item, GetOwner()->GetModelColumn());
2713 }
2714
2715 bool wxDataViewChoiceByIndexRenderer::SetValue( const wxVariant &value )
2716 {
2717     wxVariant string_value = GetChoice( value.GetLong() );
2718     return wxDataViewChoiceRenderer::SetValue( string_value );
2719 }
2720
2721 bool wxDataViewChoiceByIndexRenderer::GetValue( wxVariant &value ) const
2722 {
2723     wxVariant string_value;
2724     if (!wxDataViewChoiceRenderer::GetValue( string_value ))
2725          return false;
2726
2727     value = (long) GetChoices().Index( string_value.GetString() );
2728     return true;
2729 }
2730
2731 // ---------------------------------------------------------
2732 // wxDataViewDateRenderer
2733 // ---------------------------------------------------------
2734
2735 class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
2736 {
2737 public:
2738     wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
2739         wxDataViewModel *model, const wxDataViewItem &item, unsigned int col ) :
2740         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
2741     {
2742         m_model = model;
2743         m_item = item;
2744         m_col = col;
2745         m_cal = new wxCalendarCtrl( this, -1, *value );
2746         wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
2747         sizer->Add( m_cal, 1, wxGROW );
2748         SetSizer( sizer );
2749         sizer->Fit( this );
2750     }
2751
2752     virtual void OnDismiss()
2753     {
2754     }
2755
2756     void OnCalendar( wxCalendarEvent &event );
2757
2758     wxCalendarCtrl   *m_cal;
2759     wxDataViewModel  *m_model;
2760     wxDataViewItem    m_item;
2761     unsigned int      m_col;
2762
2763 private:
2764     DECLARE_EVENT_TABLE()
2765 };
2766
2767 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
2768     EVT_CALENDAR( -1, wxDataViewDateRendererPopupTransient::OnCalendar )
2769 END_EVENT_TABLE()
2770
2771 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
2772 {
2773     m_model->ChangeValue( event.GetDate(), m_item, m_col );
2774     DismissAndNotify();
2775 }
2776
2777 IMPLEMENT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
2778
2779 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
2780                         wxDataViewCellMode mode, int align ) :
2781     wxDataViewCustomRenderer( varianttype, mode, align )
2782 {
2783     SetMode(mode);
2784     SetAlignment(align);
2785 }
2786
2787 bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
2788 {
2789     m_date = value.GetDateTime();
2790
2791     return true;
2792 }
2793
2794 bool wxDataViewDateRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2795 {
2796     return false;
2797 }
2798
2799 bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int state )
2800 {
2801     dc->SetFont( GetOwner()->GetOwner()->GetFont() );
2802     wxString tmp = m_date.FormatDate();
2803     RenderText( tmp, 0, cell, dc, state );
2804     return true;
2805 }
2806
2807 wxSize wxDataViewDateRenderer::GetSize() const
2808 {
2809     wxString tmp = m_date.FormatDate();
2810     wxCoord x,y,d;
2811     GetView()->GetTextExtent( tmp, &x, &y, &d );
2812     return wxSize(x,y+d);
2813 }
2814
2815 bool wxDataViewDateRenderer::Activate( const wxRect& WXUNUSED(cell), wxDataViewModel *model,
2816                                        const wxDataViewItem &item, unsigned int col )
2817 {
2818     wxVariant variant;
2819     model->GetValue( variant, item, col );
2820     wxDateTime value = variant.GetDateTime();
2821
2822     wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
2823         GetOwner()->GetOwner()->GetParent(), &value, model, item, col );
2824     wxPoint pos = wxGetMousePosition();
2825     popup->Move( pos );
2826     popup->Layout();
2827     popup->Popup( popup->m_cal );
2828
2829     return true;
2830 }
2831
2832
2833 // ---------------------------------------------------------
2834 // wxDataViewIconTextRenderer
2835 // ---------------------------------------------------------
2836
2837 IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewCustomRenderer)
2838
2839 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer
2840                             (
2841                              const wxString &varianttype,
2842                              wxDataViewCellMode mode,
2843                              int align
2844                             )
2845     : wxDataViewTextRenderer(varianttype, mode, align)
2846 {
2847     m_rendererIcon = gtk_cell_renderer_pixbuf_new();
2848 }
2849
2850 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
2851 {
2852 }
2853
2854 void wxDataViewIconTextRenderer::GtkPackIntoColumn(GtkTreeViewColumn *column)
2855 {
2856     // add the icon renderer first
2857     gtk_tree_view_column_pack_start(column, m_rendererIcon, FALSE /* !expand */);
2858
2859     // add the text renderer too
2860     wxDataViewRenderer::GtkPackIntoColumn(column);
2861 }
2862
2863 bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value )
2864 {
2865     m_value << value;
2866
2867     SetTextValue(m_value.GetText());
2868     SetPixbufProp(m_rendererIcon, m_value.GetIcon().GetPixbuf());
2869
2870     return true;
2871 }
2872
2873 bool wxDataViewIconTextRenderer::GetValue(wxVariant& value) const
2874 {
2875     wxString str;
2876     if ( !GetTextValue(str) )
2877         return false;
2878
2879     // user doesn't have any way to edit the icon so leave it unchanged
2880     value << wxDataViewIconText(str, m_value.GetIcon());
2881
2882     return true;
2883 }
2884
2885 void
2886 wxDataViewIconTextRenderer::GtkOnCellChanged(const wxVariant& value,
2887                                              const wxDataViewItem& item,
2888                                              unsigned col)
2889 {
2890     // we receive just the text part of our value as it's the only one which
2891     // can be edited, but we need the full wxDataViewIconText value for the
2892     // model
2893     wxVariant valueIconText;
2894     valueIconText << wxDataViewIconText(value.GetString(), m_value.GetIcon());
2895     wxDataViewTextRenderer::GtkOnCellChanged(valueIconText, item, col);
2896 }
2897
2898 // ---------------------------------------------------------
2899 // wxDataViewColumn
2900 // ---------------------------------------------------------
2901
2902
2903 static gboolean
2904 gtk_dataview_header_button_press_callback( GtkWidget *WXUNUSED(widget),
2905                                            GdkEventButton *gdk_event,
2906                                            wxDataViewColumn *column )
2907 {
2908     if (gdk_event->type != GDK_BUTTON_PRESS)
2909         return FALSE;
2910
2911     if (gdk_event->button == 1)
2912     {
2913         gs_lastLeftClickHeader = column;
2914
2915         wxDataViewCtrl *dv = column->GetOwner();
2916         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
2917         event.SetDataViewColumn( column );
2918         event.SetModel( dv->GetModel() );
2919         if (dv->HandleWindowEvent( event ))
2920             return FALSE;
2921     }
2922
2923     if (gdk_event->button == 3)
2924     {
2925         wxDataViewCtrl *dv = column->GetOwner();
2926         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, dv->GetId() );
2927         event.SetDataViewColumn( column );
2928         event.SetModel( dv->GetModel() );
2929         if (dv->HandleWindowEvent( event ))
2930             return FALSE;
2931     }
2932
2933     return FALSE;
2934 }
2935
2936 extern "C"
2937 {
2938
2939 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *WXUNUSED(column),
2940                             GtkCellRenderer *renderer,
2941                             GtkTreeModel *model,
2942                             GtkTreeIter *iter,
2943                             gpointer data )
2944 {
2945     g_return_if_fail (GTK_IS_WX_TREE_MODEL (model));
2946     GtkWxTreeModel *tree_model = (GtkWxTreeModel *) model;
2947
2948     wxDataViewRenderer *cell = (wxDataViewRenderer*) data;
2949
2950     wxDataViewItem item( (void*) iter->user_data );
2951
2952     wxDataViewModel *wx_model = tree_model->internal->GetDataViewModel();
2953
2954     if (!wx_model->IsVirtualListModel())
2955     {
2956         gboolean visible;
2957         if (wx_model->IsContainer( item ))
2958         {
2959             visible = wx_model->HasContainerColumns( item ) ||
2960                         (cell->GetOwner()->GetModelColumn() == 0);
2961         }
2962         else
2963         {
2964             visible = true;
2965         }
2966
2967         GValue gvalue = { 0, };
2968         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2969         g_value_set_boolean( &gvalue, visible );
2970         g_object_set_property( G_OBJECT(renderer), "visible", &gvalue );
2971         g_value_unset( &gvalue );
2972
2973         if ( !visible )
2974             return;
2975     }
2976
2977     wxVariant value;
2978     wx_model->GetValue( value, item, cell->GetOwner()->GetModelColumn() );
2979
2980     if (value.GetType() != cell->GetVariantType())
2981     {
2982         wxLogError( wxT("Wrong type, required: %s but: %s"),
2983                     value.GetType().c_str(),
2984                     cell->GetVariantType().c_str() );
2985     }
2986
2987     cell->SetValue( value );
2988
2989     // deal with disabled items
2990     bool enabled = wx_model->IsEnabled( item, cell->GetOwner()->GetModelColumn() );
2991
2992     // a) this sets the appearance to disabled grey
2993     GValue gvalue = { 0, };
2994     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2995     g_value_set_boolean( &gvalue, enabled );
2996     g_object_set_property( G_OBJECT(renderer), "sensitive", &gvalue );
2997     g_value_unset( &gvalue );
2998
2999     // b) this actually disables the control/renderer
3000     if (enabled)
3001         cell->SetMode( cell->GtkGetMode() );
3002     else
3003         cell->SetMode( wxDATAVIEW_CELL_INERT );
3004
3005
3006     // deal with attributes: if the renderer doesn't support them at all, we
3007     // don't even need to query the model for them
3008     if ( !cell->GtkSupportsAttrs() )
3009         return;
3010
3011     // it can support attributes so check if this item has any
3012     wxDataViewItemAttr attr;
3013     if ( wx_model->GetAttr( item, cell->GetOwner()->GetModelColumn(), attr )
3014             || !cell->GtkIsUsingDefaultAttrs() )
3015     {
3016         bool usingDefaultAttrs = !cell->GtkSetAttr(attr);
3017         cell->GtkSetUsingDefaultAttrs(usingDefaultAttrs);
3018     }
3019     // else: no custom attributes specified and we're already using the default
3020     //       ones -- nothing to do
3021
3022 }
3023
3024 } // extern "C"
3025
3026 #include <wx/listimpl.cpp>
3027 WX_DEFINE_LIST(wxDataViewColumnList)
3028
3029 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell,
3030                                     unsigned int model_column, int width,
3031                                     wxAlignment align, int flags )
3032     : wxDataViewColumnBase( cell, model_column )
3033 {
3034     Init( align, flags, width );
3035
3036     SetTitle( title );
3037 }
3038
3039 wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell,
3040                                     unsigned int model_column, int width,
3041                                     wxAlignment align, int flags )
3042     : wxDataViewColumnBase( bitmap, cell, model_column )
3043 {
3044     Init( align, flags, width );
3045
3046     SetBitmap( bitmap );
3047 }
3048
3049 void wxDataViewColumn::Init(wxAlignment align, int flags, int width)
3050 {
3051     m_isConnected = false;
3052
3053     GtkTreeViewColumn *column = gtk_tree_view_column_new();
3054     m_column = (GtkWidget*) column;
3055
3056     SetFlags( flags );
3057     SetAlignment( align );
3058
3059     SetWidth( width );
3060
3061     // Create container for icon and label
3062     GtkWidget *box = gtk_hbox_new( FALSE, 1 );
3063     gtk_widget_show( box );
3064     // gtk_container_set_border_width((GtkContainer*)box, 2);
3065     m_image = gtk_image_new();
3066     gtk_box_pack_start(GTK_BOX(box), m_image, FALSE, FALSE, 1);
3067     m_label = gtk_label_new("");
3068     gtk_box_pack_end( GTK_BOX(box), GTK_WIDGET(m_label), FALSE, FALSE, 1 );
3069     gtk_tree_view_column_set_widget( column, box );
3070
3071     wxDataViewRenderer * const colRenderer = GetRenderer();
3072     GtkCellRenderer * const cellRenderer = colRenderer->GetGtkHandle();
3073
3074     colRenderer->GtkPackIntoColumn(column);
3075
3076     gtk_tree_view_column_set_cell_data_func( column, cellRenderer,
3077         wxGtkTreeCellDataFunc, (gpointer) colRenderer, NULL );
3078 }
3079
3080 void wxDataViewColumn::OnInternalIdle()
3081 {
3082     if (m_isConnected)
3083         return;
3084
3085     if (gtk_widget_get_realized(GetOwner()->m_treeview))
3086     {
3087         GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3088         if (column->button)
3089         {
3090             g_signal_connect(column->button, "button_press_event",
3091                       G_CALLBACK (gtk_dataview_header_button_press_callback), this);
3092
3093             // otherwise the event will be blocked by GTK+
3094             gtk_tree_view_column_set_clickable( column, TRUE );
3095
3096             m_isConnected = true;
3097         }
3098     }
3099 }
3100
3101 void wxDataViewColumn::SetOwner( wxDataViewCtrl *owner )
3102 {
3103     wxDataViewColumnBase::SetOwner( owner );
3104
3105     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3106
3107     gtk_tree_view_column_set_title( column, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
3108 }
3109
3110 void wxDataViewColumn::SetTitle( const wxString &title )
3111 {
3112     wxDataViewCtrl *ctrl = GetOwner();
3113     gtk_label_set_text( GTK_LABEL(m_label), ctrl ? wxGTK_CONV_FONT(title, ctrl->GetFont())
3114                                                  : wxGTK_CONV_SYS(title) );
3115     if (title.empty())
3116         gtk_widget_hide( m_label );
3117     else
3118         gtk_widget_show( m_label );
3119 }
3120
3121 wxString wxDataViewColumn::GetTitle() const
3122 {
3123     return wxGTK_CONV_BACK_FONT(
3124             gtk_label_get_text( GTK_LABEL(m_label) ),
3125             GetOwner()->GetFont()
3126            );
3127 }
3128
3129 void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
3130 {
3131     wxDataViewColumnBase::SetBitmap( bitmap );
3132
3133     if (bitmap.IsOk())
3134     {
3135         GtkImage *gtk_image = GTK_IMAGE(m_image);
3136
3137         GdkBitmap *mask = NULL;
3138         if (bitmap.GetMask())
3139             mask = bitmap.GetMask()->GetBitmap();
3140
3141         if (bitmap.HasPixbuf())
3142         {
3143             gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image),
3144                                       bitmap.GetPixbuf());
3145         }
3146         else
3147         {
3148             gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image),
3149                                       bitmap.GetPixmap(), mask);
3150         }
3151         gtk_widget_show( m_image );
3152     }
3153     else
3154     {
3155         gtk_widget_hide( m_image );
3156     }
3157 }
3158
3159 void wxDataViewColumn::SetHidden( bool hidden )
3160 {
3161     gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column), !hidden );
3162 }
3163
3164 void wxDataViewColumn::SetResizeable( bool resizable )
3165 {
3166     gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizable );
3167 }
3168
3169 void wxDataViewColumn::SetAlignment( wxAlignment align )
3170 {
3171     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3172
3173     gfloat xalign = 0.0;
3174     if (align == wxALIGN_RIGHT)
3175         xalign = 1.0;
3176     if (align == wxALIGN_CENTER_HORIZONTAL ||
3177         align == wxALIGN_CENTER)
3178         xalign = 0.5;
3179
3180     gtk_tree_view_column_set_alignment( column, xalign );
3181
3182     if (m_renderer && m_renderer->GetAlignment() == -1)
3183         m_renderer->GtkUpdateAlignment();
3184 }
3185
3186 wxAlignment wxDataViewColumn::GetAlignment() const
3187 {
3188     gfloat xalign = gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column) );
3189
3190     if (xalign == 1.0)
3191         return wxALIGN_RIGHT;
3192     if (xalign == 0.5)
3193         return wxALIGN_CENTER_HORIZONTAL;
3194
3195     return wxALIGN_LEFT;
3196 }
3197
3198 void wxDataViewColumn::SetSortable( bool sortable )
3199 {
3200     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3201
3202     if ( sortable )
3203     {
3204         gtk_tree_view_column_set_sort_column_id( column, GetModelColumn() );
3205     }
3206     else
3207     {
3208         gtk_tree_view_column_set_sort_column_id( column, -1 );
3209         gtk_tree_view_column_set_sort_indicator( column, FALSE );
3210         gtk_tree_view_column_set_clickable( column, FALSE );
3211     }
3212 }
3213
3214 bool wxDataViewColumn::IsSortable() const
3215 {
3216     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3217     return gtk_tree_view_column_get_clickable( column );
3218 }
3219
3220 void wxDataViewColumn::SetAsSortKey( bool WXUNUSED(sort) )
3221 {
3222     // it might not make sense to have this function in wxHeaderColumn at
3223     // all in fact, changing of the sort order should only be done using the
3224     // associated control API
3225     wxFAIL_MSG( "not implemented" );
3226 }
3227
3228 bool wxDataViewColumn::IsSortKey() const
3229 {
3230     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3231     return gtk_tree_view_column_get_sort_indicator( column );
3232 }
3233
3234 bool wxDataViewColumn::IsResizeable() const
3235 {
3236     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3237     return gtk_tree_view_column_get_resizable( column );
3238 }
3239
3240 bool wxDataViewColumn::IsHidden() const
3241 {
3242     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3243     return !gtk_tree_view_column_get_visible( column );
3244 }
3245
3246 void wxDataViewColumn::SetSortOrder( bool ascending )
3247 {
3248     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3249
3250     if (ascending)
3251         gtk_tree_view_column_set_sort_order( column, GTK_SORT_ASCENDING );
3252     else
3253         gtk_tree_view_column_set_sort_order( column, GTK_SORT_DESCENDING );
3254
3255     gtk_tree_view_column_set_sort_indicator( column, TRUE );
3256 }
3257
3258 bool wxDataViewColumn::IsSortOrderAscending() const
3259 {
3260     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3261
3262     return (gtk_tree_view_column_get_sort_order( column ) != GTK_SORT_DESCENDING);
3263 }
3264
3265 void wxDataViewColumn::SetMinWidth( int width )
3266 {
3267     gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column), width );
3268 }
3269
3270 int wxDataViewColumn::GetMinWidth() const
3271 {
3272     return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column) );
3273 }
3274
3275 int wxDataViewColumn::GetWidth() const
3276 {
3277     return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column) );
3278 }
3279
3280 void wxDataViewColumn::SetWidth( int width )
3281 {
3282     if ( width == wxCOL_WIDTH_AUTOSIZE )
3283     {
3284         // NB: this disables user resizing
3285         gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column), GTK_TREE_VIEW_COLUMN_AUTOSIZE );
3286     }
3287     else
3288     {
3289         if ( width == wxCOL_WIDTH_DEFAULT )
3290         {
3291             // TODO find a better calculation
3292             width = wxDVC_DEFAULT_WIDTH;
3293         }
3294
3295         gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column), GTK_TREE_VIEW_COLUMN_FIXED );
3296         gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column), width );
3297     }
3298 }
3299
3300 void wxDataViewColumn::SetReorderable( bool reorderable )
3301 {
3302     gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column), reorderable );
3303 }
3304
3305 bool wxDataViewColumn::IsReorderable() const
3306 {
3307     return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column) );
3308 }
3309
3310 //-----------------------------------------------------------------------------
3311 // wxGtkTreeModelNode
3312 //-----------------------------------------------------------------------------
3313
3314 #if 0
3315 class wxGtkTreeModelChildWithPos
3316 {
3317 public:
3318     unsigned int pos;
3319     void        *id;
3320 };
3321
3322 static
3323 int wxGtkTreeModelChildWithPosCmp( const void* data1, const void* data2, const void* user_data )
3324 {
3325     const wxGtkTreeModelChildWithPos* child1 = (const wxGtkTreeModelChildWithPos*) data1;
3326     const wxGtkTreeModelChildWithPos* child2 = (const wxGtkTreeModelChildWithPos*) data2;
3327     const wxDataViewCtrlInternal *internal = (const wxDataViewCtrlInternal *) user_data;
3328     int ret = internal->GetDataViewModel()->Compare( child1->id, child2->id,
3329         internal->GetSortColumn(), (internal->GetSortOrder() == GTK_SORT_DESCENDING) );
3330
3331     return ret;
3332 }
3333 #else
3334 static
3335 int LINKAGEMODE wxGtkTreeModelChildPtrCmp( void*** data1, void*** data2 )
3336 {
3337     return gs_internal->GetDataViewModel()->Compare( wxDataViewItem(**data1), wxDataViewItem(**data2),
3338         gs_internal->GetSortColumn(), (gs_internal->GetSortOrder() == GTK_SORT_ASCENDING) );
3339 }
3340
3341 WX_DEFINE_ARRAY_PTR( void**, wxGtkTreeModelChildrenPtr );
3342 #endif
3343
3344 void wxGtkTreeModelNode::Resort()
3345 {
3346     size_t child_count = GetChildCount();
3347     if (child_count == 0)
3348         return;
3349
3350     size_t node_count = GetNodesCount();
3351
3352     if (child_count == 1)
3353     {
3354         if (node_count == 1)
3355         {
3356             wxGtkTreeModelNode *node = m_nodes.Item( 0 );
3357             node->Resort();
3358         }
3359         return;
3360     }
3361
3362     gint *new_order = new gint[child_count];
3363
3364 #if 1
3365     // m_children has the original *void
3366     // ptrs points to these
3367     wxGtkTreeModelChildrenPtr ptrs;
3368     size_t i;
3369     for (i = 0; i < child_count; i++)
3370        ptrs.Add( &(m_children[i]) );
3371     // Sort the ptrs
3372     gs_internal = m_internal;
3373     ptrs.Sort( &wxGtkTreeModelChildPtrCmp );
3374
3375     wxGtkTreeModelChildren temp;
3376     void** base_ptr = &(m_children[0]);
3377     // Transfer positions to new_order array and
3378     // IDs to temp
3379     for (i = 0; i < child_count; i++)
3380     {
3381         new_order[i] = ptrs[i] - base_ptr;
3382         temp.Add( *ptrs[i] );
3383     }
3384
3385     // Transfer IDs back to m_children
3386     m_children.Clear();
3387     WX_APPEND_ARRAY( temp, m_children );
3388 #endif
3389 #if 0
3390     // Too slow
3391
3392     // Build up array with IDs and original positions
3393     wxGtkTreeModelChildWithPos* temp = new wxGtkTreeModelChildWithPos[child_count];
3394     size_t i;
3395     for (i = 0; i < child_count; i++)
3396     {
3397        temp[i].pos = i;
3398        temp[i].id = m_children[i];
3399     }
3400     // Sort array keeping original positions
3401     wxQsort( temp, child_count, sizeof(wxGtkTreeModelChildWithPos),
3402              &wxGtkTreeModelChildWithPosCmp, m_internal );
3403     // Transfer positions to new_order array and
3404     // IDs to m_children
3405     m_children.Clear();
3406     for (i = 0; i < child_count; i++)
3407     {
3408        new_order[i] = temp[i].pos;
3409        m_children.Add( temp[i].id );
3410     }
3411     // Delete array
3412     delete [] temp;
3413 #endif
3414
3415 #if 0
3416     // Too slow
3417
3418     wxGtkTreeModelChildren temp;
3419     WX_APPEND_ARRAY( temp, m_children );
3420
3421     gs_internal = m_internal;
3422     m_children.Sort( &wxGtkTreeModelChildCmp );
3423
3424     unsigned int pos;
3425     for (pos = 0; pos < child_count; pos++)
3426     {
3427         void *id = m_children.Item( pos );
3428         int old_pos = temp.Index( id );
3429         new_order[pos] = old_pos;
3430     }
3431 #endif
3432
3433     GtkTreeModel *gtk_tree_model = GTK_TREE_MODEL( m_internal->GetGtkModel() );
3434
3435     GtkTreeIter iter;
3436     iter.user_data = GetItem().GetID();
3437     iter.stamp = m_internal->GetGtkModel()->stamp;
3438
3439     gtk_tree_model_rows_reordered( gtk_tree_model,
3440             wxGtkTreePath(m_internal->get_path(&iter)), &iter, new_order );
3441
3442     delete [] new_order;
3443
3444     unsigned int pos;
3445     for (pos = 0; pos < node_count; pos++)
3446     {
3447         wxGtkTreeModelNode *node = m_nodes.Item( pos );
3448         node->Resort();
3449     }
3450 }
3451
3452 //-----------------------------------------------------------------------------
3453 // wxDataViewCtrlInternal
3454 //-----------------------------------------------------------------------------
3455
3456 wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl *owner, wxDataViewModel *wx_model )
3457 {
3458     m_owner = owner;
3459     m_wx_model = wx_model;
3460
3461     m_gtk_model = NULL;
3462     m_root = NULL;
3463     m_sort_order = GTK_SORT_ASCENDING;
3464     m_sort_column = -1;
3465     m_dataview_sort_column = NULL;
3466
3467     m_dragDataObject = NULL;
3468     m_dropDataObject = NULL;
3469
3470     m_dirty = false;
3471
3472     m_gtk_model = wxgtk_tree_model_new();
3473     m_gtk_model->internal = this;
3474
3475     m_notifier = new wxGtkDataViewModelNotifier( wx_model, this );
3476
3477     wx_model->AddNotifier( m_notifier );
3478
3479     // g_object_unref( gtk_model ); ???
3480
3481     if (!m_wx_model->IsVirtualListModel())
3482         InitTree();
3483
3484     gtk_tree_view_set_model( GTK_TREE_VIEW(m_owner->GtkGetTreeView()), GTK_TREE_MODEL(m_gtk_model) );
3485 }
3486
3487 wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
3488 {
3489     m_wx_model->RemoveNotifier( m_notifier );
3490
3491     // remove the model from the GtkTreeView before it gets destroyed
3492     gtk_tree_view_set_model( GTK_TREE_VIEW( m_owner->GtkGetTreeView() ), NULL );
3493
3494     g_object_unref( m_gtk_model );
3495
3496     delete m_dragDataObject;
3497     delete m_dropDataObject;
3498 }
3499
3500 void wxDataViewCtrlInternal::ScheduleRefresh()
3501 {
3502     m_dirty = true;
3503 }
3504
3505 void wxDataViewCtrlInternal::OnInternalIdle()
3506 {
3507     if (m_dirty)
3508     {
3509         GtkWidget *widget = m_owner->GtkGetTreeView();
3510         gtk_widget_queue_draw( widget );
3511         m_dirty = false;
3512     }
3513 }
3514
3515 void wxDataViewCtrlInternal::InitTree()
3516 {
3517     wxDataViewItem item;
3518     m_root = new wxGtkTreeModelNode( NULL, item, this );
3519
3520     BuildBranch( m_root );
3521 }
3522
3523 void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode *node )
3524 {
3525     if (node->GetChildCount() == 0)
3526     {
3527         wxDataViewItemArray children;
3528         unsigned int count = m_wx_model->GetChildren( node->GetItem(), children );
3529
3530         unsigned int pos;
3531         for (pos = 0; pos < count; pos++)
3532         {
3533             wxDataViewItem child = children[pos];
3534
3535             if (m_wx_model->IsContainer( child ))
3536                 node->AddNode( new wxGtkTreeModelNode( node, child, this ) );
3537             else
3538                 node->AddLeave( child.GetID() );
3539
3540             // Don't send any events here
3541         }
3542     }
3543 }
3544
3545 // GTK+ dnd iface
3546
3547 bool wxDataViewCtrlInternal::EnableDragSource( const wxDataFormat &format )
3548 {
3549     wxGtkString atom_str( gdk_atom_name( format  ) );
3550     m_dragSourceTargetEntryTarget = wxCharBuffer( atom_str );
3551
3552     m_dragSourceTargetEntry.target =  m_dragSourceTargetEntryTarget.data();
3553     m_dragSourceTargetEntry.flags = 0;
3554     m_dragSourceTargetEntry.info = static_cast<guint>(-1);
3555
3556     gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner->GtkGetTreeView() ),
3557        GDK_BUTTON1_MASK, &m_dragSourceTargetEntry, 1, (GdkDragAction) GDK_ACTION_COPY );
3558
3559     return true;
3560 }
3561
3562 bool wxDataViewCtrlInternal::EnableDropTarget( const wxDataFormat &format )
3563 {
3564     wxGtkString atom_str( gdk_atom_name( format  ) );
3565     m_dropTargetTargetEntryTarget = wxCharBuffer( atom_str );
3566
3567     m_dropTargetTargetEntry.target =  m_dropTargetTargetEntryTarget.data();
3568     m_dropTargetTargetEntry.flags = 0;
3569     m_dropTargetTargetEntry.info = static_cast<guint>(-1);
3570
3571     gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner->GtkGetTreeView() ),
3572        &m_dropTargetTargetEntry, 1, (GdkDragAction) GDK_ACTION_COPY );
3573
3574     return true;
3575 }
3576
3577 gboolean wxDataViewCtrlInternal::row_draggable( GtkTreeDragSource *WXUNUSED(drag_source),
3578     GtkTreePath *path )
3579 {
3580     delete m_dragDataObject;
3581     m_dragDataObject = NULL;
3582
3583     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3584     if ( !item )
3585         return FALSE;
3586
3587     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() );
3588     event.SetEventObject( m_owner );
3589     event.SetItem( item );
3590     event.SetModel( m_wx_model );
3591     gint x, y;
3592     gtk_widget_get_pointer(m_owner->GtkGetTreeView(), &x, &y);
3593     event.SetPosition(x, y);
3594     if (!m_owner->HandleWindowEvent( event ))
3595         return FALSE;
3596
3597     if (!event.IsAllowed())
3598         return FALSE;
3599
3600     wxDataObject *obj = event.GetDataObject();
3601     if (!obj)
3602         return FALSE;
3603
3604     m_dragDataObject = obj;
3605
3606     return TRUE;
3607 }
3608
3609 gboolean
3610 wxDataViewCtrlInternal::drag_data_delete(GtkTreeDragSource *WXUNUSED(drag_source),
3611                                          GtkTreePath *WXUNUSED(path))
3612 {
3613     return FALSE;
3614 }
3615
3616 gboolean wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource *WXUNUSED(drag_source),
3617     GtkTreePath *path, GtkSelectionData *selection_data )
3618 {
3619     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3620     if ( !item )
3621         return FALSE;
3622
3623     GdkAtom target = gtk_selection_data_get_target(selection_data);
3624     if (!m_dragDataObject->IsSupported(target))
3625         return FALSE;
3626
3627     size_t size = m_dragDataObject->GetDataSize(target);
3628     if (size == 0)
3629         return FALSE;
3630
3631     void *buf = malloc( size );
3632
3633     gboolean res = FALSE;
3634     if (m_dragDataObject->GetDataHere(target, buf))
3635     {
3636         res = TRUE;
3637
3638         gtk_selection_data_set(selection_data, target,
3639             8, (const guchar*) buf, size );
3640     }
3641
3642     free( buf );
3643
3644     return res;
3645 }
3646
3647 gboolean
3648 wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest *WXUNUSED(drag_dest),
3649                                            GtkTreePath *path,
3650                                            GtkSelectionData *selection_data)
3651 {
3652     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3653     if ( !item )
3654         return FALSE;
3655
3656     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, m_owner->GetId() );
3657     event.SetEventObject( m_owner );
3658     event.SetItem( item );
3659     event.SetModel( m_wx_model );
3660     event.SetDataFormat(gtk_selection_data_get_target(selection_data));
3661     event.SetDataSize(gtk_selection_data_get_length(selection_data));
3662     event.SetDataBuffer(const_cast<guchar*>(gtk_selection_data_get_data(selection_data)));
3663     if (!m_owner->HandleWindowEvent( event ))
3664         return FALSE;
3665
3666     if (!event.IsAllowed())
3667         return FALSE;
3668
3669     return TRUE;
3670 }
3671
3672 gboolean
3673 wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest *WXUNUSED(drag_dest),
3674                                           GtkTreePath *path,
3675                                           GtkSelectionData *selection_data)
3676 {
3677     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3678     if ( !item )
3679         return FALSE;
3680
3681     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() );
3682     event.SetEventObject( m_owner );
3683     event.SetItem( item );
3684     event.SetModel( m_wx_model );
3685     event.SetDataFormat(gtk_selection_data_get_target(selection_data));
3686     if (!m_owner->HandleWindowEvent( event ))
3687         return FALSE;
3688
3689     if (!event.IsAllowed())
3690         return FALSE;
3691
3692     return TRUE;
3693 }
3694
3695 // notifications from wxDataViewModel
3696
3697 bool wxDataViewCtrlInternal::Cleared()
3698 {
3699     if (m_root)
3700     {
3701         delete m_root;
3702         m_root = NULL;
3703     }
3704
3705     InitTree();
3706
3707     ScheduleRefresh();
3708
3709     return true;
3710 }
3711
3712 void wxDataViewCtrlInternal::Resort()
3713 {
3714     if (!m_wx_model->IsVirtualListModel())
3715         m_root->Resort();
3716
3717     ScheduleRefresh();
3718 }
3719
3720 bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
3721 {
3722     if (!m_wx_model->IsVirtualListModel())
3723     {
3724         wxGtkTreeModelNode *parent_node = FindNode( parent );
3725         wxASSERT_MSG(parent_node,
3726             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3727
3728         if (m_wx_model->IsContainer( item ))
3729             parent_node->AddNode( new wxGtkTreeModelNode( parent_node, item, this ) );
3730         else
3731             parent_node->AddLeave( item.GetID() );
3732     }
3733
3734     ScheduleRefresh();
3735
3736     return true;
3737 }
3738
3739 bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
3740 {
3741     if (!m_wx_model->IsVirtualListModel())
3742     {
3743         wxGtkTreeModelNode *parent_node = FindNode( parent );
3744         wxASSERT_MSG(parent_node,
3745             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3746
3747         parent_node->DeleteChild( item.GetID() );
3748     }
3749
3750     ScheduleRefresh();
3751
3752     return true;
3753 }
3754
3755 bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem &item )
3756 {
3757     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
3758     event.SetEventObject( m_owner );
3759     event.SetModel( m_owner->GetModel() );
3760     event.SetItem( item );
3761     m_owner->HandleWindowEvent( event );
3762
3763     return true;
3764 }
3765
3766 bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem &item, unsigned int view_column )
3767 {
3768     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
3769     event.SetEventObject( m_owner );
3770     event.SetModel( m_owner->GetModel() );
3771     event.SetColumn( view_column );
3772     event.SetDataViewColumn( GetOwner()->GetColumn(view_column) );
3773     event.SetItem( item );
3774     m_owner->HandleWindowEvent( event );
3775
3776     return true;
3777 }
3778
3779 // GTK+ model iface
3780
3781 GtkTreeModelFlags wxDataViewCtrlInternal::get_flags()
3782 {
3783     int flags = 0;
3784
3785     if ( m_wx_model->IsListModel() )
3786         flags |= GTK_TREE_MODEL_LIST_ONLY;
3787
3788     if ( !m_wx_model->IsVirtualListModel() )
3789         flags |= GTK_TREE_MODEL_ITERS_PERSIST;
3790
3791     return GtkTreeModelFlags(flags);
3792 }
3793
3794 gboolean wxDataViewCtrlInternal::get_iter( GtkTreeIter *iter, GtkTreePath *path )
3795 {
3796
3797     if (m_wx_model->IsVirtualListModel())
3798     {
3799         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3800
3801         unsigned int i = (unsigned int)gtk_tree_path_get_indices (path)[0];
3802
3803         if (i >= wx_model->GetCount())
3804             return FALSE;
3805
3806         iter->stamp = m_gtk_model->stamp;
3807         // user_data is just the index +1
3808         iter->user_data = (gpointer) (i+1);
3809
3810         return TRUE;
3811     }
3812     else
3813     {
3814         int depth = gtk_tree_path_get_depth( path );
3815
3816         wxGtkTreeModelNode *node = m_root;
3817
3818         int i;
3819         for (i = 0; i < depth; i++)
3820         {
3821             BuildBranch( node );
3822
3823             gint pos = gtk_tree_path_get_indices (path)[i];
3824             if (pos < 0) return FALSE;
3825             if ((size_t)pos >= node->GetChildCount()) return FALSE;
3826
3827             void* id = node->GetChildren().Item( (size_t) pos );
3828
3829             if (i == depth-1)
3830             {
3831                 iter->stamp = m_gtk_model->stamp;
3832                 iter->user_data = id;
3833                 return TRUE;
3834             }
3835
3836             size_t count = node->GetNodes().GetCount();
3837             size_t pos2;
3838             for (pos2 = 0; pos2 < count; pos2++)
3839             {
3840                 wxGtkTreeModelNode *child_node = node->GetNodes().Item( pos2 );
3841                 if (child_node->GetItem().GetID() == id)
3842                 {
3843                     node = child_node;
3844                     break;
3845                 }
3846             }
3847         }
3848     }
3849
3850     return FALSE;
3851 }
3852
3853 GtkTreePath *wxDataViewCtrlInternal::get_path( GtkTreeIter *iter )
3854 {
3855     // When this is called from ItemDeleted(), the item is already
3856     // deleted in the model.
3857
3858     GtkTreePath *retval = gtk_tree_path_new ();
3859
3860     if (m_wx_model->IsVirtualListModel())
3861     {
3862         // iter is root, add nothing
3863         if (!iter->user_data)
3864            return retval;
3865
3866         // user_data is just the index +1
3867         int i = ( (wxUIntPtr) iter->user_data ) -1;
3868         gtk_tree_path_append_index (retval, i);
3869     }
3870     else
3871     {
3872         void *id = iter->user_data;
3873
3874         wxGtkTreeModelNode *node = FindParentNode( iter );
3875         while (node)
3876         {
3877             int pos = node->GetChildren().Index( id );
3878
3879             gtk_tree_path_prepend_index( retval, pos );
3880
3881             id = node->GetItem().GetID();
3882             node = node->GetParent();
3883         }
3884     }
3885
3886     return retval;
3887 }
3888
3889 gboolean wxDataViewCtrlInternal::iter_next( GtkTreeIter *iter )
3890 {
3891     if (m_wx_model->IsVirtualListModel())
3892     {
3893         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3894
3895         // user_data is just the index +1
3896         int n = ( (wxUIntPtr) iter->user_data ) -1;
3897
3898         if (n == -1)
3899         {
3900             iter->user_data = NULL;
3901             return FALSE;
3902         }
3903
3904         if (n >= (int) wx_model->GetCount()-1)
3905         {
3906             iter->user_data = NULL;
3907             return FALSE;
3908         }
3909
3910         // user_data is just the index +1 (+2 because we need the next)
3911         iter->user_data = (gpointer) (n+2);
3912     }
3913     else
3914     {
3915         wxGtkTreeModelNode *parent = FindParentNode( iter );
3916         if( parent == NULL )
3917         {
3918             iter->user_data = NULL;
3919             return FALSE;
3920         }
3921
3922         int pos = parent->GetChildren().Index( iter->user_data );
3923
3924         if (pos == (int) parent->GetChildCount()-1)
3925         {
3926             iter->user_data = NULL;
3927             return FALSE;
3928         }
3929
3930         iter->user_data = parent->GetChildren().Item( pos+1 );
3931     }
3932
3933     return TRUE;
3934 }
3935
3936 gboolean wxDataViewCtrlInternal::iter_children( GtkTreeIter *iter, GtkTreeIter *parent )
3937 {
3938     if (m_wx_model->IsVirtualListModel())
3939     {
3940         // this is a list, nodes have no children
3941         if (parent)
3942             return FALSE;
3943
3944         iter->stamp = m_gtk_model->stamp;
3945         iter->user_data = (gpointer) 1;
3946
3947         return TRUE;
3948     }
3949     else
3950     {
3951         if (iter == NULL)
3952         {
3953             if (m_root->GetChildCount() == 0) return FALSE;
3954             iter->stamp = m_gtk_model->stamp;
3955             iter->user_data = (gpointer) m_root->GetChildren().Item( 0 );
3956             return TRUE;
3957         }
3958
3959
3960         wxDataViewItem item;
3961         if (parent)
3962             item = wxDataViewItem( (void*) parent->user_data );
3963
3964         if (!m_wx_model->IsContainer( item ))
3965             return FALSE;
3966
3967         wxGtkTreeModelNode *parent_node = FindNode( parent );
3968         wxASSERT_MSG(parent_node,
3969             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3970
3971         BuildBranch( parent_node );
3972
3973         if (parent_node->GetChildCount() == 0)
3974             return FALSE;
3975
3976         iter->stamp = m_gtk_model->stamp;
3977         iter->user_data = (gpointer) parent_node->GetChildren().Item( 0 );
3978     }
3979
3980     return TRUE;
3981 }
3982
3983 gboolean wxDataViewCtrlInternal::iter_has_child( GtkTreeIter *iter )
3984 {
3985     if (m_wx_model->IsVirtualListModel())
3986     {
3987         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3988
3989         if (iter == NULL)
3990             return (wx_model->GetCount() > 0);
3991
3992         // this is a list, nodes have no children
3993         return FALSE;
3994     }
3995     else
3996     {
3997         if (iter == NULL)
3998             return (m_root->GetChildCount() > 0);
3999
4000         wxDataViewItem item( (void*) iter->user_data );
4001
4002         bool is_container = m_wx_model->IsContainer( item );
4003
4004         if (!is_container)
4005             return FALSE;
4006
4007         wxGtkTreeModelNode *node = FindNode( iter );
4008         wxASSERT_MSG(node,
4009             "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
4010
4011         BuildBranch( node );
4012
4013         return (node->GetChildCount() > 0);
4014     }
4015 }
4016
4017 gint wxDataViewCtrlInternal::iter_n_children( GtkTreeIter *iter )
4018 {
4019     if (m_wx_model->IsVirtualListModel())
4020     {
4021         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
4022
4023         if (iter == NULL)
4024             return (gint) wx_model->GetCount();
4025
4026         return 0;
4027     }
4028     else
4029     {
4030         if (iter == NULL)
4031             return m_root->GetChildCount();
4032
4033         wxDataViewItem item( (void*) iter->user_data );
4034
4035         if (!m_wx_model->IsContainer( item ))
4036             return 0;
4037
4038         wxGtkTreeModelNode *parent_node = FindNode( iter );
4039         wxASSERT_MSG(parent_node,
4040             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
4041
4042         BuildBranch( parent_node );
4043
4044         return parent_node->GetChildCount();
4045     }
4046 }
4047
4048 gboolean wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n )
4049 {
4050     if (m_wx_model->IsVirtualListModel())
4051     {
4052         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
4053
4054         if (parent)
4055             return FALSE;
4056
4057         if (n < 0)
4058             return FALSE;
4059
4060         if (n >= (gint) wx_model->GetCount())
4061             return FALSE;
4062
4063         iter->stamp = m_gtk_model->stamp;
4064         // user_data is just the index +1
4065         iter->user_data = (gpointer) (n+1);
4066
4067         return TRUE;
4068     }
4069     else
4070     {
4071         void* id = NULL;
4072         if (parent) id = (void*) parent->user_data;
4073         wxDataViewItem item( id );
4074
4075         if (!m_wx_model->IsContainer( item ))
4076             return FALSE;
4077
4078         wxGtkTreeModelNode *parent_node = FindNode( parent );
4079         wxASSERT_MSG(parent_node,
4080             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
4081
4082         BuildBranch( parent_node );
4083
4084         iter->stamp = m_gtk_model->stamp;
4085         iter->user_data = parent_node->GetChildren().Item( n );
4086
4087         return TRUE;
4088     }
4089 }
4090
4091 gboolean wxDataViewCtrlInternal::iter_parent( GtkTreeIter *iter, GtkTreeIter *child )
4092 {
4093     if (m_wx_model->IsVirtualListModel())
4094     {
4095         return FALSE;
4096     }
4097     else
4098     {
4099         wxGtkTreeModelNode *node = FindParentNode( child );
4100         if (!node)
4101             return FALSE;
4102
4103         iter->stamp = m_gtk_model->stamp;
4104         iter->user_data = (gpointer) node->GetItem().GetID();
4105
4106         return TRUE;
4107     }
4108 }
4109
4110 // item can be deleted already in the model
4111 int wxDataViewCtrlInternal::GetIndexOf( const wxDataViewItem &parent, const wxDataViewItem &item )
4112 {
4113     if (m_wx_model->IsVirtualListModel())
4114     {
4115         return wxPtrToUInt(item.GetID()) - 1;
4116     }
4117     else
4118     {
4119         wxGtkTreeModelNode *parent_node = FindNode( parent );
4120         wxGtkTreeModelChildren &children = parent_node->GetChildren();
4121         size_t j;
4122         for (j = 0; j < children.GetCount(); j++)
4123         {
4124             if (children[j] == item.GetID())
4125                return j;
4126         }
4127     }
4128     return -1;
4129 }
4130
4131
4132 static wxGtkTreeModelNode*
4133 wxDataViewCtrlInternal_FindNode( wxDataViewModel * model, wxGtkTreeModelNode *treeNode, const wxDataViewItem &item )
4134 {
4135     if( model == NULL )
4136         return NULL;
4137
4138     ItemList list;
4139     list.DeleteContents( true );
4140     wxDataViewItem it( item );
4141
4142     while( it.IsOk() )
4143     {
4144         wxDataViewItem * pItem = new wxDataViewItem( it );
4145         list.Insert( pItem );
4146         it = model->GetParent( it );
4147     }
4148
4149     wxGtkTreeModelNode * node = treeNode;
4150     for( ItemList::compatibility_iterator n = list.GetFirst(); n; n = n->GetNext() )
4151     {
4152         if( node && node->GetNodes().GetCount() != 0 )
4153         {
4154             int len = node->GetNodes().GetCount();
4155             wxGtkTreeModelNodes &nodes = node->GetNodes();
4156             int j = 0;
4157             for( ; j < len; j ++)
4158             {
4159                 if( nodes[j]->GetItem() == *(n->GetData()))
4160                 {
4161                     node = nodes[j];
4162                     break;
4163                 }
4164             }
4165
4166             if( j == len )
4167             {
4168                 return NULL;
4169             }
4170         }
4171         else
4172             return NULL;
4173     }
4174     return node;
4175
4176 }
4177
4178 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( GtkTreeIter *iter )
4179 {
4180     if (!iter)
4181         return m_root;
4182
4183     wxDataViewItem item( (void*) iter->user_data );
4184     if (!item.IsOk())
4185         return m_root;
4186
4187     wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_wx_model, m_root, item );
4188
4189 /*
4190     if (!result)
4191     {
4192         wxLogDebug( "Not found %p", iter->user_data );
4193         char *crash = NULL;
4194         *crash = 0;
4195     }
4196     // TODO: remove this code
4197 */
4198
4199     return result;
4200 }
4201
4202 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( const wxDataViewItem &item )
4203 {
4204     if (!item.IsOk())
4205         return m_root;
4206
4207     wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_wx_model, m_root, item );
4208
4209 /*
4210     if (!result)
4211     {
4212         wxLogDebug( "Not found %p", item.GetID() );
4213         char *crash = NULL;
4214         *crash = 0;
4215     }
4216     // TODO: remove this code
4217 */
4218
4219     return result;
4220 }
4221
4222 static wxGtkTreeModelNode*
4223 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel * model, wxGtkTreeModelNode *treeNode, const wxDataViewItem &item )
4224 {
4225     if( model == NULL )
4226         return NULL;
4227
4228     ItemList list;
4229     list.DeleteContents( true );
4230     if( !item.IsOk() )
4231         return NULL;
4232
4233     wxDataViewItem it( model->GetParent( item ) );
4234     while( it.IsOk() )
4235     {
4236         wxDataViewItem * pItem = new wxDataViewItem( it );
4237         list.Insert( pItem );
4238         it = model->GetParent( it );
4239     }
4240
4241     wxGtkTreeModelNode * node = treeNode;
4242     for( ItemList::compatibility_iterator n = list.GetFirst(); n; n = n->GetNext() )
4243     {
4244         if( node && node->GetNodes().GetCount() != 0 )
4245         {
4246             int len = node->GetNodes().GetCount();
4247             wxGtkTreeModelNodes nodes = node->GetNodes();
4248             int j = 0;
4249             for( ; j < len; j ++)
4250             {
4251                 if( nodes[j]->GetItem() == *(n->GetData()))
4252                 {
4253                     node = nodes[j];
4254                     break;
4255                 }
4256             }
4257
4258             if( j == len )
4259             {
4260                 return NULL;
4261             }
4262         }
4263         else
4264             return NULL;
4265     }
4266     //Examine whether the node is item's parent node
4267     int len = node->GetChildCount();
4268     for( int i = 0; i < len ; i ++ )
4269     {
4270         if( node->GetChildren().Item( i ) == item.GetID() )
4271             return node;
4272     }
4273     return NULL;
4274 }
4275
4276 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindParentNode( GtkTreeIter *iter )
4277 {
4278     if (!iter)
4279         return NULL;
4280
4281     wxDataViewItem item( (void*) iter->user_data );
4282     if (!item.IsOk())
4283         return NULL;
4284
4285     return wxDataViewCtrlInternal_FindParentNode( m_wx_model, m_root, item );
4286 }
4287
4288 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindParentNode( const wxDataViewItem &item )
4289 {
4290     if (!item.IsOk())
4291         return NULL;
4292
4293     return wxDataViewCtrlInternal_FindParentNode( m_wx_model, m_root, item );
4294 }
4295
4296 //-----------------------------------------------------------------------------
4297 // wxDataViewCtrl signal callbacks
4298 //-----------------------------------------------------------------------------
4299
4300 static void
4301 wxdataview_selection_changed_callback( GtkTreeSelection* WXUNUSED(selection), wxDataViewCtrl *dv )
4302 {
4303     if (!gtk_widget_get_realized(dv->m_widget))
4304         return;
4305
4306     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, dv->GetId() );
4307     event.SetItem( dv->GetSelection() );
4308     event.SetModel( dv->GetModel() );
4309     dv->HandleWindowEvent( event );
4310 }
4311
4312 static void
4313 wxdataview_row_activated_callback( GtkTreeView* WXUNUSED(treeview), GtkTreePath *path,
4314                                    GtkTreeViewColumn *WXUNUSED(column), wxDataViewCtrl *dv )
4315 {
4316     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, dv->GetId() );
4317
4318     wxDataViewItem item(dv->GTKPathToItem(path));
4319     event.SetItem( item );
4320     event.SetModel( dv->GetModel() );
4321     dv->HandleWindowEvent( event );
4322 }
4323
4324 static gboolean
4325 wxdataview_test_expand_row_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4326                                      GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4327 {
4328     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, dv->GetId() );
4329
4330     wxDataViewItem item( (void*) iter->user_data );;
4331     event.SetItem( item );
4332     event.SetModel( dv->GetModel() );
4333     dv->HandleWindowEvent( event );
4334
4335     return !event.IsAllowed();
4336 }
4337
4338 static void
4339 wxdataview_row_expanded_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4340                                   GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4341 {
4342     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, dv->GetId() );
4343
4344     wxDataViewItem item( (void*) iter->user_data );;
4345     event.SetItem( item );
4346     event.SetModel( dv->GetModel() );
4347     dv->HandleWindowEvent( event );
4348 }
4349
4350 static gboolean
4351 wxdataview_test_collapse_row_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4352                                        GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4353 {
4354     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, dv->GetId() );
4355
4356     wxDataViewItem item( (void*) iter->user_data );;
4357     event.SetItem( item );
4358     event.SetModel( dv->GetModel() );
4359     dv->HandleWindowEvent( event );
4360
4361     return !event.IsAllowed();
4362 }
4363
4364 static void
4365 wxdataview_row_collapsed_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4366                                    GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4367 {
4368     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, dv->GetId() );
4369
4370     wxDataViewItem item( (void*) iter->user_data );;
4371     event.SetItem( item );
4372     event.SetModel( dv->GetModel() );
4373     dv->HandleWindowEvent( event );
4374 }
4375
4376 //-----------------------------------------------------------------------------
4377     // wxDataViewCtrl
4378 //-----------------------------------------------------------------------------
4379
4380 void wxDataViewCtrl::AddChildGTK(wxWindowGTK* child)
4381 {
4382     GtkWidget* treeview = GtkGetTreeView();
4383
4384     // Insert widget in GtkTreeView
4385     if (gtk_widget_get_realized(treeview))
4386         gtk_widget_set_parent_window( child->m_widget,
4387           gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview) ) );
4388     gtk_widget_set_parent( child->m_widget, treeview );
4389 }
4390
4391 static
4392 void gtk_dataviewctrl_size_callback( GtkWidget *WXUNUSED(widget),
4393                                      GtkAllocation *WXUNUSED(gtk_alloc),
4394                                      wxDataViewCtrl *win )
4395 {
4396     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
4397     while (node)
4398     {
4399         wxWindow *child = node->GetData();
4400
4401         GtkRequisition req;
4402         gtk_widget_size_request( child->m_widget, &req );
4403
4404         GtkAllocation alloc;
4405         alloc.x = child->m_x;
4406         alloc.y = child->m_y;
4407         alloc.width = child->m_width;
4408         alloc.height = child->m_height;
4409         gtk_widget_size_allocate( child->m_widget, &alloc );
4410
4411         node = node->GetNext();
4412     }
4413 }
4414
4415
4416 //-----------------------------------------------------------------------------
4417 // "motion_notify_event"
4418 //-----------------------------------------------------------------------------
4419
4420 static gboolean
4421 gtk_dataview_motion_notify_callback( GtkWidget *WXUNUSED(widget),
4422                                      GdkEventMotion *gdk_event,
4423                                      wxDataViewCtrl *dv )
4424 {
4425     if (gdk_event->is_hint)
4426     {
4427         int x = 0;
4428         int y = 0;
4429         GdkModifierType state;
4430         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
4431         gdk_event->x = x;
4432         gdk_event->y = y;
4433     }
4434
4435     wxGtkTreePath path;
4436     GtkTreeViewColumn *column = NULL;
4437     gint cell_x = 0;
4438     gint cell_y = 0;
4439     if (gtk_tree_view_get_path_at_pos(
4440         GTK_TREE_VIEW(dv->GtkGetTreeView()),
4441         (int) gdk_event->x, (int) gdk_event->y,
4442         path.ByRef(),
4443         &column,
4444         &cell_x,
4445         &cell_y))
4446     {
4447         if (path)
4448         {
4449             GtkTreeIter iter;
4450             dv->GtkGetInternal()->get_iter( &iter, path );
4451         }
4452     }
4453
4454
4455     return FALSE;
4456 }
4457
4458 //-----------------------------------------------------------------------------
4459 // "button_press_event"
4460 //-----------------------------------------------------------------------------
4461
4462 static gboolean
4463 gtk_dataview_button_press_callback( GtkWidget *WXUNUSED(widget),
4464                                     GdkEventButton *gdk_event,
4465                                     wxDataViewCtrl *dv )
4466 {
4467     if ((gdk_event->button == 3) && (gdk_event->type == GDK_BUTTON_PRESS))
4468     {
4469         wxGtkTreePath path;
4470         GtkTreeViewColumn *column = NULL;
4471         gint cell_x = 0;
4472         gint cell_y = 0;
4473         if (gtk_tree_view_get_path_at_pos(
4474             GTK_TREE_VIEW(dv->GtkGetTreeView()),
4475             (int) gdk_event->x, (int) gdk_event->y,
4476             path.ByRef(),
4477             &column,
4478             &cell_x,
4479             &cell_y))
4480         {
4481             if (path)
4482             {
4483                 wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, dv->GetId() );
4484                 event.SetItem(dv->GTKPathToItem(path));
4485                 event.SetModel( dv->GetModel() );
4486                 return dv->HandleWindowEvent( event );
4487              }
4488         }
4489     }
4490
4491     return FALSE;
4492 }
4493
4494 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
4495
4496 wxDataViewCtrl::~wxDataViewCtrl()
4497 {
4498     // Stop editing before destroying the control to remove any event handlers
4499     // which are added when editing started: if we didn't do this, the base
4500     // class dtor would assert as it checks for any leftover handlers.
4501     if ( m_treeview )
4502     {
4503         GtkTreeViewColumn *col;
4504         gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), NULL, &col);
4505
4506         wxDataViewColumn * const wxcol = FromGTKColumn(col);
4507         if ( wxcol )
4508         {
4509             // This won't do anything if we're not editing it
4510             wxcol->GetRenderer()->CancelEditing();
4511         }
4512     }
4513
4514     m_cols.Clear();
4515
4516     delete m_internal;
4517 }
4518
4519 void wxDataViewCtrl::Init()
4520 {
4521     m_internal = NULL;
4522
4523     m_cols.DeleteContents( true );
4524
4525     m_uniformRowHeight = -1;
4526 }
4527
4528 bool wxDataViewCtrl::Create(wxWindow *parent,
4529                             wxWindowID id,
4530                             const wxPoint& pos,
4531                             const wxSize& size,
4532                             long style,
4533                             const wxValidator& validator,
4534                             const wxString& name)
4535 {
4536     if (!PreCreation( parent, pos, size ) ||
4537         !CreateBase( parent, id, pos, size, style, validator, name ))
4538     {
4539         wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
4540         return false;
4541     }
4542
4543     m_widget = gtk_scrolled_window_new (NULL, NULL);
4544     g_object_ref(m_widget);
4545
4546     GTKScrolledWindowSetBorder(m_widget, style);
4547
4548     m_treeview = gtk_tree_view_new();
4549     gtk_container_add (GTK_CONTAINER (m_widget), m_treeview);
4550
4551     g_signal_connect (m_treeview, "size_allocate",
4552                      G_CALLBACK (gtk_dataviewctrl_size_callback), this);
4553
4554 #ifdef __WXGTK26__
4555     if (!gtk_check_version(2,6,0))
4556     {
4557         bool fixed = (style & wxDV_VARIABLE_LINE_HEIGHT) == 0;
4558         gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), fixed );
4559     }
4560 #endif
4561
4562     if (style & wxDV_MULTIPLE)
4563     {
4564         GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4565         gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
4566     }
4567
4568     gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview), (style & wxDV_NO_HEADER) == 0 );
4569
4570 #ifdef __WXGTK210__
4571     if (!gtk_check_version(2,10,0))
4572     {
4573         GtkTreeViewGridLines grid = GTK_TREE_VIEW_GRID_LINES_NONE;
4574
4575         if ((style & wxDV_HORIZ_RULES) != 0 &&
4576             (style & wxDV_VERT_RULES) != 0)
4577             grid = GTK_TREE_VIEW_GRID_LINES_BOTH;
4578         else if (style & wxDV_VERT_RULES)
4579             grid = GTK_TREE_VIEW_GRID_LINES_VERTICAL;
4580         else if (style & wxDV_HORIZ_RULES)
4581             grid = GTK_TREE_VIEW_GRID_LINES_HORIZONTAL;
4582
4583         if (grid != GTK_TREE_VIEW_GRID_LINES_NONE)
4584             gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview), grid );
4585     }
4586 #endif
4587
4588     gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview), (style & wxDV_ROW_LINES) != 0 );
4589
4590     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget),
4591         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4592     gtk_widget_show (m_treeview);
4593
4594     m_parent->DoAddChild( this );
4595
4596     PostCreation(size);
4597
4598     GtkEnableSelectionEvents();
4599
4600     g_signal_connect_after (m_treeview, "row-activated",
4601                             G_CALLBACK (wxdataview_row_activated_callback), this);
4602
4603     g_signal_connect (m_treeview, "test-collapse-row",
4604                             G_CALLBACK (wxdataview_test_collapse_row_callback), this);
4605
4606     g_signal_connect_after (m_treeview, "row-collapsed",
4607                             G_CALLBACK (wxdataview_row_collapsed_callback), this);
4608
4609     g_signal_connect (m_treeview, "test-expand-row",
4610                             G_CALLBACK (wxdataview_test_expand_row_callback), this);
4611
4612     g_signal_connect_after (m_treeview, "row-expanded",
4613                             G_CALLBACK (wxdataview_row_expanded_callback), this);
4614
4615     g_signal_connect (m_treeview, "motion_notify_event",
4616                       G_CALLBACK (gtk_dataview_motion_notify_callback), this);
4617
4618     g_signal_connect (m_treeview, "button_press_event",
4619                       G_CALLBACK (gtk_dataview_button_press_callback), this);
4620
4621     return true;
4622 }
4623
4624 wxDataViewItem wxDataViewCtrl::GTKPathToItem(GtkTreePath *path) const
4625 {
4626     GtkTreeIter iter;
4627     return wxDataViewItem(path && m_internal->get_iter(&iter, path)
4628                             ? iter.user_data
4629                             : NULL);
4630 }
4631
4632 void wxDataViewCtrl::OnInternalIdle()
4633 {
4634     wxWindow::OnInternalIdle();
4635
4636     m_internal->OnInternalIdle();
4637
4638     unsigned int cols = GetColumnCount();
4639     unsigned int i;
4640     for (i = 0; i < cols; i++)
4641     {
4642         wxDataViewColumn *col = GetColumn( i );
4643         col->OnInternalIdle();
4644     }
4645
4646     if (m_ensureVisibleDefered.IsOk())
4647     {
4648         ExpandAncestors(m_ensureVisibleDefered);
4649         GtkTreeIter iter;
4650         iter.user_data = (gpointer) m_ensureVisibleDefered.GetID();
4651         wxGtkTreePath path(m_internal->get_path( &iter ));
4652         gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview), path, NULL, false, 0.0, 0.0 );
4653         m_ensureVisibleDefered = wxDataViewItem(0);
4654     }
4655 }
4656
4657 bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
4658 {
4659     wxDELETE(m_internal);
4660
4661     if (!wxDataViewCtrlBase::AssociateModel( model ))
4662         return false;
4663
4664 #ifdef __WXGTK26__
4665     if (!gtk_check_version(2,6,0))
4666     {
4667         bool fixed = (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) == 0) || (model->IsVirtualListModel()));
4668         gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), fixed );
4669     }
4670 #endif
4671
4672     m_internal = new wxDataViewCtrlInternal( this, model );
4673
4674     return true;
4675 }
4676
4677 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat &format )
4678 {
4679     return m_internal->EnableDragSource( format );
4680 }
4681
4682 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat &format )
4683 {
4684     return m_internal->EnableDropTarget( format );
4685 }
4686
4687 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
4688 {
4689     if (!wxDataViewCtrlBase::AppendColumn(col))
4690         return false;
4691
4692     m_cols.Append( col );
4693
4694 #ifdef __WXGTK26__
4695     if (!gtk_check_version(2,6,0))
4696     {
4697         if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4698                GTK_TREE_VIEW_COLUMN_FIXED)
4699            gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4700     }
4701 #endif
4702
4703     gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview),
4704                                  GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
4705
4706     return true;
4707 }
4708
4709 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
4710 {
4711     if (!wxDataViewCtrlBase::PrependColumn(col))
4712         return false;
4713
4714     m_cols.Insert( col );
4715
4716 #ifdef __WXGTK26__
4717     if (!gtk_check_version(2,6,0))
4718     {
4719         if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4720                GTK_TREE_VIEW_COLUMN_FIXED)
4721            gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4722     }
4723 #endif
4724
4725     gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
4726                                  GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), 0 );
4727
4728     return true;
4729 }
4730
4731 bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
4732 {
4733     if (!wxDataViewCtrlBase::InsertColumn(pos,col))
4734         return false;
4735
4736     m_cols.Insert( pos, col );
4737
4738 #ifdef __WXGTK26__
4739     if (!gtk_check_version(2,6,0))
4740     {
4741         if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4742                GTK_TREE_VIEW_COLUMN_FIXED)
4743            gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4744     }
4745 #endif
4746
4747     gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
4748                                  GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), pos );
4749
4750     return true;
4751 }
4752
4753 unsigned int wxDataViewCtrl::GetColumnCount() const
4754 {
4755     return m_cols.GetCount();
4756 }
4757
4758 wxDataViewColumn* wxDataViewCtrl::FromGTKColumn(GtkTreeViewColumn *gtk_col) const
4759 {
4760     if ( !gtk_col )
4761         return NULL;
4762
4763     wxDataViewColumnList::const_iterator iter;
4764     for (iter = m_cols.begin(); iter != m_cols.end(); ++iter)
4765     {
4766         wxDataViewColumn *col = *iter;
4767         if (GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == gtk_col)
4768         {
4769             return col;
4770         }
4771     }
4772
4773     wxFAIL_MSG( "No matching column?" );
4774
4775     return NULL;
4776 }
4777
4778 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int pos ) const
4779 {
4780     GtkTreeViewColumn *gtk_col = gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview), pos );
4781
4782     return FromGTKColumn(gtk_col);
4783 }
4784
4785 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
4786 {
4787     gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
4788                                  GTK_TREE_VIEW_COLUMN(column->GetGtkHandle()) );
4789
4790     m_cols.DeleteObject( column );
4791
4792     return true;
4793 }
4794
4795 bool wxDataViewCtrl::ClearColumns()
4796 {
4797     wxDataViewColumnList::iterator iter;
4798     for (iter = m_cols.begin(); iter != m_cols.end(); ++iter)
4799     {
4800         wxDataViewColumn *col = *iter;
4801         gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
4802                                      GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
4803     }
4804
4805     m_cols.Clear();
4806
4807     return true;
4808 }
4809
4810 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
4811 {
4812     GtkTreeViewColumn *gtk_column = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
4813
4814     GList *list = gtk_tree_view_get_columns( GTK_TREE_VIEW(m_treeview) );
4815
4816     gint pos = g_list_index( list, (gconstpointer)  gtk_column );
4817
4818     g_list_free( list );
4819
4820     return pos;
4821 }
4822
4823 wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
4824 {
4825     return m_internal->GetDataViewSortColumn();
4826 }
4827
4828 void wxDataViewCtrl::Expand( const wxDataViewItem & item )
4829 {
4830     GtkTreeIter iter;
4831     iter.user_data = item.GetID();
4832     wxGtkTreePath path(m_internal->get_path( &iter ));
4833     gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview), path, false );
4834 }
4835
4836 void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
4837 {
4838     GtkTreeIter iter;
4839     iter.user_data = item.GetID();
4840     wxGtkTreePath path(m_internal->get_path( &iter ));
4841     gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview), path );
4842 }
4843
4844 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const
4845 {
4846     GtkTreeIter iter;
4847     iter.user_data = item.GetID();
4848     wxGtkTreePath path(m_internal->get_path( &iter ));
4849     return gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview), path );
4850 }
4851
4852 wxDataViewItem wxDataViewCtrl::DoGetCurrentItem() const
4853 {
4854     // The tree doesn't have any current item if it hadn't been created yet but
4855     // it's arguably not an error to call this function in this case so just
4856     // return an invalid item without asserting.
4857     if ( !m_treeview )
4858         return wxDataViewItem();
4859
4860     wxGtkTreePath path;
4861     gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), path.ByRef(), NULL);
4862
4863     return GTKPathToItem(path);
4864 }
4865
4866 void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem& item)
4867 {
4868     wxCHECK_RET( m_treeview,
4869                  "Current item can't be set before creating the control." );
4870
4871     // We need to make sure the model knows about this item or the path would
4872     // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4873     ExpandAncestors(item);
4874
4875     // We also need to preserve the existing selection from changing.
4876     // Unfortunately the only way to do it seems to use our own selection
4877     // function and forbid any selection changes during set cursor call.
4878     wxGtkTreeSelectionLock
4879         lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview)));
4880
4881     // Do move the cursor now.
4882     GtkTreeIter iter;
4883     iter.user_data = item.GetID();
4884     wxGtkTreePath path(m_internal->get_path( &iter ));
4885
4886     gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview), path, NULL, FALSE);
4887 }
4888
4889 void wxDataViewCtrl::StartEditor(const wxDataViewItem& item, unsigned int column)
4890 {
4891     wxCHECK_RET( m_treeview,
4892                  "Current item can't be set before creating the control." );
4893
4894     // We need to make sure the model knows about this item or the path would
4895     // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4896     ExpandAncestors(item);
4897
4898     wxDataViewColumn *dvcolumn = GetColumn(column);
4899     wxASSERT_MSG(dvcolumn, "Could not retrieve column");
4900     GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(dvcolumn->GetGtkHandle());
4901
4902     // We also need to preserve the existing selection from changing.
4903     // Unfortunately the only way to do it seems to use our own selection
4904     // function and forbid any selection changes during set cursor call.
4905     wxGtkTreeSelectionLock
4906         lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview)));
4907
4908     // Do move the cursor now.
4909     GtkTreeIter iter;
4910     iter.user_data = item.GetID();
4911     wxGtkTreePath path(m_internal->get_path( &iter ));
4912
4913     gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview), path, gcolumn, TRUE);
4914 }
4915
4916 wxDataViewItem wxDataViewCtrl::GetSelection() const
4917 {
4918     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4919
4920     if (m_windowStyle & wxDV_MULTIPLE)
4921     {
4922         // Report the first one
4923         GtkTreeModel *model;
4924         GList *list = gtk_tree_selection_get_selected_rows( selection, &model );
4925
4926         if (list)
4927         {
4928             GtkTreePath *path = (GtkTreePath*) list->data;
4929             wxDataViewItem item(GTKPathToItem(path));
4930
4931             // delete list
4932             g_list_foreach( list, (GFunc) gtk_tree_path_free, NULL );
4933             g_list_free( list );
4934
4935             return item;
4936         }
4937     }
4938     else
4939     {
4940         GtkTreeIter iter;
4941         if (gtk_tree_selection_get_selected( selection, NULL, &iter ))
4942         {
4943             wxDataViewItem item( iter.user_data );
4944             return item;
4945         }
4946     }
4947
4948     return wxDataViewItem(0);
4949 }
4950
4951 int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const
4952 {
4953     sel.Clear();
4954
4955     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4956     if (HasFlag(wxDV_MULTIPLE))
4957     {
4958         GtkTreeModel *model;
4959         GList *list = gtk_tree_selection_get_selected_rows( selection, &model );
4960
4961         int count = 0;
4962         while (list)
4963         {
4964             GtkTreePath *path = (GtkTreePath*) list->data;
4965
4966             sel.Add(GTKPathToItem(path));
4967
4968             list = g_list_next( list );
4969             count++;
4970         }
4971
4972         // delete list
4973         g_list_foreach( list, (GFunc) gtk_tree_path_free, NULL );
4974         g_list_free( list );
4975
4976         return count;
4977     }
4978     else
4979     {
4980         GtkTreeModel *model;
4981         GtkTreeIter iter;
4982         gboolean has_selection = gtk_tree_selection_get_selected( selection, &model, &iter );
4983         if (has_selection)
4984         {
4985             sel.Add( wxDataViewItem( (void*) iter.user_data) );
4986             return 1;
4987         }
4988     }
4989
4990     return 0;
4991 }
4992
4993 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel )
4994 {
4995     GtkDisableSelectionEvents();
4996
4997     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4998
4999     gtk_tree_selection_unselect_all( selection );
5000
5001     wxDataViewItem last_parent;
5002
5003     size_t i;
5004     for (i = 0; i < sel.GetCount(); i++)
5005     {
5006         wxDataViewItem item = sel[i];
5007         wxDataViewItem parent = GetModel()->GetParent( item );
5008         if (parent)
5009         {
5010             if (parent != last_parent)
5011                 ExpandAncestors(item);
5012         }
5013         last_parent = parent;
5014
5015         GtkTreeIter iter;
5016         iter.stamp = m_internal->GetGtkModel()->stamp;
5017         iter.user_data = (gpointer) item.GetID();
5018         gtk_tree_selection_select_iter( selection, &iter );
5019     }
5020
5021     GtkEnableSelectionEvents();
5022 }
5023
5024 void wxDataViewCtrl::Select( const wxDataViewItem & item )
5025 {
5026     ExpandAncestors(item);
5027
5028     GtkDisableSelectionEvents();
5029
5030     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5031
5032     GtkTreeIter iter;
5033     iter.stamp = m_internal->GetGtkModel()->stamp;
5034     iter.user_data = (gpointer) item.GetID();
5035     gtk_tree_selection_select_iter( selection, &iter );
5036
5037     GtkEnableSelectionEvents();
5038 }
5039
5040 void wxDataViewCtrl::Unselect( const wxDataViewItem & item )
5041 {
5042     GtkDisableSelectionEvents();
5043
5044     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5045
5046     GtkTreeIter iter;
5047     iter.stamp = m_internal->GetGtkModel()->stamp;
5048     iter.user_data = (gpointer) item.GetID();
5049     gtk_tree_selection_unselect_iter( selection, &iter );
5050
5051     GtkEnableSelectionEvents();
5052 }
5053
5054 bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const
5055 {
5056     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5057
5058     GtkTreeIter iter;
5059     iter.stamp = m_internal->GetGtkModel()->stamp;
5060     iter.user_data = (gpointer) item.GetID();
5061
5062     return gtk_tree_selection_iter_is_selected( selection, &iter );
5063 }
5064
5065 void wxDataViewCtrl::SelectAll()
5066 {
5067     GtkDisableSelectionEvents();
5068
5069     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5070
5071     gtk_tree_selection_select_all( selection );
5072
5073     GtkEnableSelectionEvents();
5074 }
5075
5076 void wxDataViewCtrl::UnselectAll()
5077 {
5078     GtkDisableSelectionEvents();
5079
5080     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5081
5082     gtk_tree_selection_unselect_all( selection );
5083
5084     GtkEnableSelectionEvents();
5085 }
5086
5087 void wxDataViewCtrl::EnsureVisible(const wxDataViewItem& item,
5088                                    const wxDataViewColumn *WXUNUSED(column))
5089 {
5090     m_ensureVisibleDefered = item;
5091     ExpandAncestors(item);
5092
5093     GtkTreeIter iter;
5094     iter.user_data = (gpointer) item.GetID();
5095     wxGtkTreePath path(m_internal->get_path( &iter ));
5096     gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview), path, NULL, false, 0.0, 0.0 );
5097 }
5098
5099 void wxDataViewCtrl::HitTest(const wxPoint& point,
5100                              wxDataViewItem& item,
5101                              wxDataViewColumn *& column) const
5102 {
5103     // gtk_tree_view_get_dest_row_at_pos() is the right one. But it does not tell the column.
5104     // gtk_tree_view_get_path_at_pos() is the wrong function. It doesn't mind the header but returns column.
5105     // See http://mail.gnome.org/archives/gtkmm-list/2005-January/msg00080.html
5106     // So we have to use both of them.
5107     // Friedrich Haase 2010-9-20
5108     wxGtkTreePath path, pathScratch;
5109     GtkTreeViewColumn* GtkColumn = NULL;
5110     GtkTreeViewDropPosition pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
5111     gint cell_x = 0;
5112     gint cell_y = 0;
5113
5114     // cannot directly call GtkGetTreeView(), HitTest is const and so is this pointer
5115     wxDataViewCtrl* ctrl = (wxDataViewCtrl*)this; // ugly workaround, ctrl is NOT const
5116     GtkTreeView* treeView = GTK_TREE_VIEW(ctrl->GtkGetTreeView());
5117
5118     // is there possibly a better suited function to get the column?
5119     gtk_tree_view_get_path_at_pos(                // and this is the wrong call but it delivers the column
5120       treeView,
5121       (int) point.x, (int) point.y,
5122       pathScratch.ByRef(),
5123       &GtkColumn,                                 // here we get the GtkColumn
5124       &cell_x,
5125       &cell_y );
5126
5127     if ( GtkColumn != NULL )
5128     {
5129         // we got GTK column
5130         // the right call now which takes the header into account
5131         gtk_tree_view_get_dest_row_at_pos( treeView, (int) point.x, (int) point.y, path.ByRef(), &pos);
5132
5133         if (path)
5134             item = wxDataViewItem(GTKPathToItem(path));
5135         // else we got a GTK column but the position is not over an item, e.g. below last item
5136         for ( unsigned int i=0, cols=GetColumnCount(); i<cols; ++i )  // search the wx column
5137         {
5138             wxDataViewColumn* col = GetColumn(i);
5139             if ( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == GtkColumn )
5140             {
5141                 column = col;                      // here we get the wx column
5142                 break;
5143             }
5144         }
5145     }
5146     // else no column and thus no item, both null
5147 }
5148
5149 wxRect
5150 wxDataViewCtrl::GetItemRect(const wxDataViewItem& WXUNUSED(item),
5151                             const wxDataViewColumn *WXUNUSED(column)) const
5152 {
5153     return wxRect();
5154 }
5155
5156 bool wxDataViewCtrl::SetRowHeight(int rowHeight)
5157 {
5158     m_uniformRowHeight = rowHeight;
5159     return true;
5160 }
5161
5162 void wxDataViewCtrl::DoSetExpanderColumn()
5163 {
5164     gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview),
5165         GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
5166 }
5167
5168 void wxDataViewCtrl::DoSetIndent()
5169 {
5170 }
5171
5172 void wxDataViewCtrl::GtkDisableSelectionEvents()
5173 {
5174     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5175     g_signal_handlers_disconnect_by_func( selection,
5176                             (gpointer) (wxdataview_selection_changed_callback), this);
5177 }
5178
5179 void wxDataViewCtrl::GtkEnableSelectionEvents()
5180 {
5181     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5182     g_signal_connect_after (selection, "changed",
5183                             G_CALLBACK (wxdataview_selection_changed_callback), this);
5184 }
5185
5186 // ----------------------------------------------------------------------------
5187 // visual attributes stuff
5188 // ----------------------------------------------------------------------------
5189
5190 // static
5191 wxVisualAttributes
5192 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
5193 {
5194     return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new);
5195 }
5196
5197 void wxDataViewCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
5198 {
5199     wxDataViewCtrlBase::DoApplyWidgetStyle(style);
5200     gtk_widget_modify_style(m_treeview, style);
5201 }
5202
5203 #endif // !wxUSE_GENERICDATAVIEWCTRL
5204
5205 #endif // wxUSE_DATAVIEWCTRL