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