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()                             { 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 static void
1375 gtk_wx_cell_renderer_render (GtkCellRenderer      *renderer,
1376                              GdkWindow            *window,
1377                              GtkWidget            *widget,
1378                              GdkRectangle         *background_area,
1379                              GdkRectangle         *cell_area,
1380                              GdkRectangle         *expose_area,
1381                              GtkCellRendererState  flags)
1382
1383 {
1384     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1385     wxDataViewCustomRenderer *cell = wxrenderer->cell;
1386
1387     cell->GTKStashRenderParams(window, widget,
1388                                background_area, expose_area, flags);
1389
1390     wxRect rect(wxRectFromGDKRect(cell_area));
1391     int xpad, ypad;
1392     gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1393     rect = rect.Deflate(xpad, ypad);
1394
1395     wxWindowDC* dc = (wxWindowDC*) cell->GetDC();
1396     wxWindowDCImpl *impl = (wxWindowDCImpl *) dc->GetImpl();
1397
1398     // Reinitialize wxWindowDC's GDK window if drawing occurs into a different
1399     // window such as a DnD drop window.
1400     if (window != impl->m_gdkwindow)
1401     {
1402         impl->Destroy();
1403         impl->m_gdkwindow = window;
1404         impl->SetUpDC();
1405     }
1406
1407     int state = 0;
1408     if (flags & GTK_CELL_RENDERER_SELECTED)
1409         state |= wxDATAVIEW_CELL_SELECTED;
1410     if (flags & GTK_CELL_RENDERER_PRELIT)
1411         state |= wxDATAVIEW_CELL_PRELIT;
1412     if (flags & GTK_CELL_RENDERER_INSENSITIVE)
1413         state |= wxDATAVIEW_CELL_INSENSITIVE;
1414     if (flags & GTK_CELL_RENDERER_INSENSITIVE)
1415         state |= wxDATAVIEW_CELL_INSENSITIVE;
1416     if (flags & GTK_CELL_RENDERER_FOCUSED)
1417         state |= wxDATAVIEW_CELL_FOCUSED;
1418     cell->WXCallRender( rect, dc, state );
1419 }
1420
1421 static gboolean
1422 gtk_wx_cell_renderer_activate(
1423                         GtkCellRenderer         *renderer,
1424                         GdkEvent                *event,
1425                         GtkWidget               *widget,
1426                         const gchar             *path,
1427                         GdkRectangle            *WXUNUSED(background_area),
1428                         GdkRectangle            *cell_area,
1429                         GtkCellRendererState     WXUNUSED(flags) )
1430 {
1431     GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
1432     wxDataViewCustomRenderer *cell = wxrenderer->cell;
1433
1434     GdkRectangle rect;
1435     gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
1436                                    &rect.x,
1437                                    &rect.y,
1438                                    &rect.width,
1439                                    &rect.height);
1440
1441     rect.x += cell_area->x;
1442     rect.y += cell_area->y;
1443     int xpad, ypad;
1444     gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
1445     rect.width  -= xpad * 2;
1446     rect.height -= ypad * 2;
1447
1448     wxRect renderrect(wxRectFromGDKRect(&rect));
1449
1450     wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
1451     wxDataViewModel *model = ctrl->GetModel();
1452
1453     wxDataViewItem item(ctrl->GTKPathToItem(wxGtkTreePath(path)));
1454
1455     unsigned int model_col = cell->GetOwner()->GetModelColumn();
1456
1457     if ( !event )
1458     {
1459         // activated by <ENTER>
1460         return cell->ActivateCell(renderrect, model, item, model_col, NULL);
1461     }
1462     else if ( event->type == GDK_BUTTON_PRESS )
1463     {
1464         GdkEventButton *button_event = (GdkEventButton*)event;
1465         if ( button_event->button == 1 )
1466         {
1467             wxMouseEvent mouse_event(wxEVT_LEFT_DOWN);
1468             InitMouseEvent(ctrl, mouse_event, button_event);
1469
1470             mouse_event.m_x -= renderrect.x;
1471             mouse_event.m_y -= renderrect.y;
1472
1473             return cell->ActivateCell(renderrect, model, item, model_col, &mouse_event);
1474         }
1475     }
1476
1477     wxLogDebug("unexpected event type in gtk_wx_cell_renderer_activate()");
1478     return false;
1479 }
1480
1481 // ---------------------------------------------------------
1482 // wxGtkDataViewModelNotifier
1483 // ---------------------------------------------------------
1484
1485 class wxGtkDataViewModelNotifier: public wxDataViewModelNotifier
1486 {
1487 public:
1488     wxGtkDataViewModelNotifier( wxDataViewModel *wx_model, wxDataViewCtrlInternal *internal );
1489     ~wxGtkDataViewModelNotifier();
1490
1491     virtual bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
1492     virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
1493     virtual bool ItemChanged( const wxDataViewItem &item );
1494     virtual bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );
1495     virtual bool Cleared();
1496     virtual void Resort();
1497     virtual bool BeforeReset();
1498     virtual bool AfterReset();
1499
1500     void UpdateLastCount();
1501
1502 private:
1503     wxDataViewModel         *m_wx_model;
1504     wxDataViewCtrlInternal  *m_internal;
1505 };
1506
1507 // ---------------------------------------------------------
1508 // wxGtkDataViewListModelNotifier
1509 // ---------------------------------------------------------
1510
1511 wxGtkDataViewModelNotifier::wxGtkDataViewModelNotifier(
1512     wxDataViewModel *wx_model, wxDataViewCtrlInternal *internal )
1513 {
1514     m_wx_model = wx_model;
1515     m_internal = internal;
1516 }
1517
1518 wxGtkDataViewModelNotifier::~wxGtkDataViewModelNotifier()
1519 {
1520     m_wx_model = NULL;
1521     m_internal = NULL;
1522 }
1523
1524 bool wxGtkDataViewModelNotifier::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
1525 {
1526     m_internal->ItemAdded( parent, item );
1527     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1528
1529     GtkTreeIter iter;
1530     iter.stamp = wxgtk_model->stamp;
1531     iter.user_data = item.GetID();
1532
1533     wxGtkTreePath path(wxgtk_tree_model_get_path(
1534         GTK_TREE_MODEL(wxgtk_model), &iter ));
1535     gtk_tree_model_row_inserted(
1536         GTK_TREE_MODEL(wxgtk_model), path, &iter);
1537
1538     return true;
1539 }
1540
1541 bool wxGtkDataViewModelNotifier::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
1542 {
1543     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1544 #if 0
1545     // using _get_path for a deleted item cannot be
1546     // a good idea
1547     GtkTreeIter iter;
1548     iter.stamp = wxgtk_model->stamp;
1549     iter.user_data = (gpointer) item.GetID();
1550     wxGtkTreePath path(wxgtk_tree_model_get_path(
1551         GTK_TREE_MODEL(wxgtk_model), &iter ));
1552 #else
1553     // so get the path from the parent
1554     GtkTreeIter parentIter;
1555     parentIter.stamp = wxgtk_model->stamp;
1556     parentIter.user_data = (gpointer) parent.GetID();
1557     wxGtkTreePath parentPath(wxgtk_tree_model_get_path(
1558         GTK_TREE_MODEL(wxgtk_model), &parentIter ));
1559
1560     // and add the final index ourselves
1561     wxGtkTreePath path(gtk_tree_path_copy(parentPath));
1562     int index = m_internal->GetIndexOf( parent, item );
1563     gtk_tree_path_append_index( path, index );
1564 #endif
1565
1566     gtk_tree_model_row_deleted(
1567         GTK_TREE_MODEL(wxgtk_model), path );
1568
1569     m_internal->ItemDeleted( parent, item );
1570
1571     // Did we remove the last child, causing 'parent' to become a leaf?
1572     if ( !m_wx_model->IsContainer(parent) )
1573     {
1574         gtk_tree_model_row_has_child_toggled
1575         (
1576             GTK_TREE_MODEL(wxgtk_model),
1577             parentPath,
1578             &parentIter
1579         );
1580     }
1581
1582     return true;
1583 }
1584
1585 void wxGtkDataViewModelNotifier::Resort()
1586 {
1587     m_internal->Resort();
1588 }
1589
1590 bool wxGtkDataViewModelNotifier::ItemChanged( const wxDataViewItem &item )
1591 {
1592     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1593
1594     GtkTreeIter iter;
1595     iter.stamp = wxgtk_model->stamp;
1596     iter.user_data = (gpointer) item.GetID();
1597
1598     wxGtkTreePath path(wxgtk_tree_model_get_path(
1599         GTK_TREE_MODEL(wxgtk_model), &iter ));
1600     gtk_tree_model_row_changed(
1601         GTK_TREE_MODEL(wxgtk_model), path, &iter );
1602
1603     m_internal->ItemChanged( item );
1604
1605     return true;
1606 }
1607
1608 bool wxGtkDataViewModelNotifier::ValueChanged( const wxDataViewItem &item, unsigned int model_column )
1609 {
1610     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1611     wxDataViewCtrl *ctrl = m_internal->GetOwner();
1612
1613     // This adds GTK+'s missing MVC logic for ValueChanged
1614     unsigned int index;
1615     for (index = 0; index < ctrl->GetColumnCount(); index++)
1616     {
1617         wxDataViewColumn *column = ctrl->GetColumn( index );
1618         if (column->GetModelColumn() == model_column)
1619         {
1620             GtkTreeView *widget = GTK_TREE_VIEW(ctrl->GtkGetTreeView());
1621             GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
1622
1623             // Don't attempt to refresh not yet realized tree, it is useless
1624             // and results in GTK errors.
1625             if ( gtk_widget_get_realized(ctrl->GtkGetTreeView()) )
1626             {
1627                 // Get cell area
1628                 GtkTreeIter iter;
1629                 iter.stamp = wxgtk_model->stamp;
1630                 iter.user_data = (gpointer) item.GetID();
1631                 wxGtkTreePath path(wxgtk_tree_model_get_path(
1632                     GTK_TREE_MODEL(wxgtk_model), &iter ));
1633                 GdkRectangle cell_area;
1634                 gtk_tree_view_get_cell_area( widget, path, gcolumn, &cell_area );
1635
1636                 GtkAdjustment* hadjust = gtk_tree_view_get_hadjustment( widget );
1637                 double d = gtk_adjustment_get_value( hadjust );
1638                 int xdiff = (int) d;
1639
1640                 int ydiff = gcolumn->button->allocation.height;
1641                 // Redraw
1642                 gtk_widget_queue_draw_area( GTK_WIDGET(widget),
1643                     cell_area.x - xdiff, ydiff + cell_area.y, cell_area.width, cell_area.height );
1644             }
1645
1646             m_internal->ValueChanged( item, model_column );
1647
1648             return true;
1649         }
1650     }
1651
1652     return false;
1653 }
1654
1655 bool wxGtkDataViewModelNotifier::BeforeReset()
1656 {
1657     GtkWidget *treeview = m_internal->GetOwner()->GtkGetTreeView();
1658     gtk_tree_view_set_model( GTK_TREE_VIEW(treeview), NULL );
1659
1660     return true;
1661 }
1662
1663 bool wxGtkDataViewModelNotifier::AfterReset()
1664 {
1665     GtkWidget *treeview = m_internal->GetOwner()->GtkGetTreeView();
1666     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1667
1668     m_internal->Cleared();
1669
1670     gtk_tree_view_set_model( GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(wxgtk_model) );
1671
1672     return true;
1673 }
1674
1675 bool wxGtkDataViewModelNotifier::Cleared()
1676 {
1677     GtkWxTreeModel *wxgtk_model = m_internal->GetGtkModel();
1678
1679     // There is no call to tell the model that everything
1680     // has been deleted so call row_deleted() for every
1681     // child of root...
1682
1683     int count = m_internal->iter_n_children( NULL ); // number of children of root
1684
1685     GtkTreePath *path = gtk_tree_path_new_first();  // points to root
1686
1687     int i;
1688     for (i = 0; i < count; i++)
1689         gtk_tree_model_row_deleted( GTK_TREE_MODEL(wxgtk_model), path );
1690
1691     gtk_tree_path_free( path );
1692
1693     m_internal->Cleared();
1694
1695     return true;
1696 }
1697
1698 // ---------------------------------------------------------
1699 // wxDataViewRenderer
1700 // ---------------------------------------------------------
1701
1702 static gpointer s_user_data = NULL;
1703
1704 static void
1705 wxgtk_cell_editable_editing_done( GtkCellEditable *WXUNUSED(editable),
1706                                   wxDataViewRenderer *wxrenderer )
1707 {
1708     wxDataViewColumn *column = wxrenderer->GetOwner();
1709     wxDataViewCtrl *dv = column->GetOwner();
1710     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv->GetId() );
1711     event.SetDataViewColumn( column );
1712     event.SetModel( dv->GetModel() );
1713     wxDataViewItem item( s_user_data );
1714     event.SetItem( item );
1715     dv->HandleWindowEvent( event );
1716 }
1717
1718 static void
1719 wxgtk_renderer_editing_started( GtkCellRenderer *WXUNUSED(cell), GtkCellEditable *editable,
1720                                 gchar *path, wxDataViewRenderer *wxrenderer )
1721 {
1722     if (!editable)
1723        return;
1724
1725     wxDataViewColumn *column = wxrenderer->GetOwner();
1726     wxDataViewCtrl *dv = column->GetOwner();
1727     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, dv->GetId() );
1728     event.SetDataViewColumn( column );
1729     event.SetModel( dv->GetModel() );
1730     wxDataViewItem item(dv->GTKPathToItem(wxGtkTreePath(path)));
1731     event.SetItem( item );
1732     dv->HandleWindowEvent( event );
1733
1734     if (GTK_IS_CELL_EDITABLE(editable))
1735     {
1736         s_user_data = item.GetID();
1737
1738         g_signal_connect (GTK_CELL_EDITABLE (editable), "editing_done",
1739             G_CALLBACK (wxgtk_cell_editable_editing_done),
1740             (gpointer) wxrenderer );
1741
1742     }
1743 }
1744
1745
1746 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
1747
1748 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode,
1749                                         int align ) :
1750     wxDataViewRendererBase( varianttype, mode, align )
1751 {
1752     m_renderer = NULL;
1753     m_mode = mode;
1754
1755     // we haven't changed them yet
1756     m_usingDefaultAttrs = true;
1757
1758     // NOTE: SetMode() and SetAlignment() needs to be called in the renderer's ctor,
1759     //       after the m_renderer pointer has been initialized
1760 }
1761
1762 void wxDataViewRenderer::GtkPackIntoColumn(GtkTreeViewColumn *column)
1763 {
1764     gtk_tree_view_column_pack_end( column, m_renderer, TRUE /* expand */);
1765 }
1766
1767 void wxDataViewRenderer::GtkInitHandlers()
1768 {
1769     if (!gtk_check_version(2,6,0))
1770     {
1771         g_signal_connect (GTK_CELL_RENDERER(m_renderer), "editing_started",
1772             G_CALLBACK (wxgtk_renderer_editing_started),
1773             this);
1774     }
1775 }
1776
1777 void wxDataViewRenderer::SetMode( wxDataViewCellMode mode )
1778 {
1779     GtkCellRendererMode gtkMode;
1780     switch (mode)
1781     {
1782         case wxDATAVIEW_CELL_INERT:
1783             gtkMode = GTK_CELL_RENDERER_MODE_INERT;
1784             break;
1785
1786         case wxDATAVIEW_CELL_ACTIVATABLE:
1787             gtkMode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
1788             break;
1789
1790         case wxDATAVIEW_CELL_EDITABLE:
1791             gtkMode = GTK_CELL_RENDERER_MODE_EDITABLE;
1792             break;
1793
1794         default:
1795             wxFAIL_MSG( "unknown wxDataViewCellMode value" );
1796             return;
1797     }
1798
1799     m_mode = mode;
1800
1801     // This value is most often ignored in GtkTreeView
1802     GValue gvalue = { 0, };
1803     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
1804     g_value_set_enum( &gvalue, gtkMode );
1805     g_object_set_property( G_OBJECT(m_renderer), "mode", &gvalue );
1806     g_value_unset( &gvalue );
1807 }
1808
1809 wxDataViewCellMode wxDataViewRenderer::GetMode() const
1810 {
1811     wxDataViewCellMode ret;
1812
1813     GValue gvalue;
1814     g_object_get( G_OBJECT(m_renderer), "mode", &gvalue, NULL);
1815
1816     switch (g_value_get_enum(&gvalue))
1817     {
1818         default:
1819             wxFAIL_MSG( "unknown GtkCellRendererMode value" );
1820             // fall through (we have to return something)
1821
1822         case GTK_CELL_RENDERER_MODE_INERT:
1823             ret = wxDATAVIEW_CELL_INERT;
1824             break;
1825
1826         case GTK_CELL_RENDERER_MODE_ACTIVATABLE:
1827             ret = wxDATAVIEW_CELL_ACTIVATABLE;
1828             break;
1829
1830         case GTK_CELL_RENDERER_MODE_EDITABLE:
1831             ret = wxDATAVIEW_CELL_EDITABLE;
1832             break;
1833     }
1834
1835     g_value_unset( &gvalue );
1836
1837     return ret;
1838 }
1839
1840 void wxDataViewRenderer::GtkApplyAlignment(GtkCellRenderer *renderer)
1841 {
1842     int align = m_alignment;
1843
1844     // query alignment from column ?
1845     if (align == -1)
1846     {
1847         // None there yet
1848         if (GetOwner() == NULL)
1849             return;
1850
1851         align = GetOwner()->GetAlignment();
1852         align |= wxALIGN_CENTRE_VERTICAL;
1853     }
1854
1855     // horizontal alignment:
1856
1857     gfloat xalign = 0.0;
1858     if (align & wxALIGN_RIGHT)
1859         xalign = 1.0;
1860     else if (align & wxALIGN_CENTER_HORIZONTAL)
1861         xalign = 0.5;
1862
1863     GValue gvalue = { 0, };
1864     g_value_init( &gvalue, G_TYPE_FLOAT );
1865     g_value_set_float( &gvalue, xalign );
1866     g_object_set_property( G_OBJECT(renderer), "xalign", &gvalue );
1867     g_value_unset( &gvalue );
1868
1869     // vertical alignment:
1870
1871     gfloat yalign = 0.0;
1872     if (align & wxALIGN_BOTTOM)
1873         yalign = 1.0;
1874     else if (align & wxALIGN_CENTER_VERTICAL)
1875         yalign = 0.5;
1876
1877     GValue gvalue2 = { 0, };
1878     g_value_init( &gvalue2, G_TYPE_FLOAT );
1879     g_value_set_float( &gvalue2, yalign );
1880     g_object_set_property( G_OBJECT(renderer), "yalign", &gvalue2 );
1881     g_value_unset( &gvalue2 );
1882 }
1883
1884 void wxDataViewRenderer::SetAlignment( int align )
1885 {
1886     m_alignment = align;
1887     GtkUpdateAlignment();
1888 }
1889
1890 int wxDataViewRenderer::GetAlignment() const
1891 {
1892     return m_alignment;
1893 }
1894
1895 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode)
1896 {
1897 #ifdef __WXGTK26__
1898     if ( gtk_check_version(2, 6, 0) != NULL )
1899         return;
1900
1901     GtkCellRendererText * const rend = GtkGetTextRenderer();
1902     if ( !rend )
1903         return;
1904
1905     // we use the same values in wxEllipsizeMode as PangoEllipsizeMode so we
1906     // can just cast between them
1907     GValue gvalue = { 0, };
1908     g_value_init( &gvalue, PANGO_TYPE_ELLIPSIZE_MODE );
1909     g_value_set_enum( &gvalue, static_cast<PangoEllipsizeMode>(mode) );
1910     g_object_set_property( G_OBJECT(rend), "ellipsize", &gvalue );
1911     g_value_unset( &gvalue );
1912 #else // GTK < 2.6
1913     wxUnusedVar(mode);
1914 #endif // GTK 2.6/before
1915 }
1916
1917 wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const
1918 {
1919 #ifdef __WXGTK26__
1920     if ( gtk_check_version(2, 6, 0) != NULL )
1921         return wxELLIPSIZE_NONE;
1922
1923     GtkCellRendererText * const rend = GtkGetTextRenderer();
1924     if ( !rend )
1925         return wxELLIPSIZE_NONE;
1926
1927     GValue gvalue = { 0, };
1928     g_value_init( &gvalue, PANGO_TYPE_ELLIPSIZE_MODE );
1929     g_object_get_property( G_OBJECT(rend), "ellipsize", &gvalue );
1930     wxEllipsizeMode
1931         mode = static_cast<wxEllipsizeMode>(g_value_get_enum( &gvalue ));
1932     g_value_unset( &gvalue );
1933
1934     return mode;
1935 #else // GTK < 2.6
1936     return wxELLIPSIZE_NONE;
1937 #endif // GTK 2.6/before
1938 }
1939
1940 void
1941 wxDataViewRenderer::GtkOnTextEdited(const char *itempath, const wxString& str)
1942 {
1943     wxVariant value(str);
1944     if (!Validate( value ))
1945         return;
1946
1947     wxDataViewItem
1948         item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath)));
1949
1950     GtkOnCellChanged(value, item, GetOwner()->GetModelColumn());
1951 }
1952
1953 void
1954 wxDataViewRenderer::GtkOnCellChanged(const wxVariant& value,
1955                                      const wxDataViewItem& item,
1956                                      unsigned col)
1957 {
1958     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
1959     model->ChangeValue( value, item, col );
1960 }
1961
1962 // ---------------------------------------------------------
1963 // wxDataViewTextRenderer
1964 // ---------------------------------------------------------
1965
1966 extern "C"
1967 {
1968
1969 static void wxGtkTextRendererEditedCallback( GtkCellRendererText *WXUNUSED(renderer),
1970     gchar *arg1, gchar *arg2, gpointer user_data )
1971 {
1972     wxDataViewRenderer *cell = (wxDataViewRenderer*) user_data;
1973
1974     cell->GtkOnTextEdited(arg1, wxGTK_CONV_BACK_FONT(
1975                 arg2, cell->GetOwner()->GetOwner()->GetFont()));
1976 }
1977
1978 }
1979
1980 namespace
1981 {
1982
1983 // helper function used by wxDataViewTextRenderer and
1984 // wxDataViewCustomRenderer::RenderText(): it applies the attributes to the
1985 // given text renderer and returns true if anything was done
1986 bool GtkApplyAttr(GtkCellRendererText *renderer, const wxDataViewItemAttr& attr)
1987 {
1988     bool usingDefaultAttrs = true;
1989     if (attr.HasColour())
1990     {
1991         const GdkColor * const gcol = attr.GetColour().GetColor();
1992
1993         GValue gvalue = { 0, };
1994         g_value_init( &gvalue, GDK_TYPE_COLOR );
1995         g_value_set_boxed( &gvalue, gcol );
1996         g_object_set_property( G_OBJECT(renderer), "foreground_gdk", &gvalue );
1997         g_value_unset( &gvalue );
1998
1999         usingDefaultAttrs = false;
2000     }
2001     else
2002     {
2003         GValue gvalue = { 0, };
2004         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2005         g_value_set_boolean( &gvalue, FALSE );
2006         g_object_set_property( G_OBJECT(renderer), "foreground-set", &gvalue );
2007         g_value_unset( &gvalue );
2008     }
2009
2010     if (attr.GetItalic())
2011     {
2012         GValue gvalue = { 0, };
2013         g_value_init( &gvalue, PANGO_TYPE_STYLE );
2014         g_value_set_enum( &gvalue, PANGO_STYLE_ITALIC );
2015         g_object_set_property( G_OBJECT(renderer), "style", &gvalue );
2016         g_value_unset( &gvalue );
2017
2018         usingDefaultAttrs = false;
2019     }
2020     else
2021     {
2022         GValue gvalue = { 0, };
2023         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2024         g_value_set_boolean( &gvalue, FALSE );
2025         g_object_set_property( G_OBJECT(renderer), "style-set", &gvalue );
2026         g_value_unset( &gvalue );
2027     }
2028
2029
2030     if (attr.GetBold())
2031     {
2032         GValue gvalue = { 0, };
2033         g_value_init( &gvalue, PANGO_TYPE_WEIGHT );
2034         g_value_set_enum( &gvalue, PANGO_WEIGHT_BOLD );
2035         g_object_set_property( G_OBJECT(renderer), "weight", &gvalue );
2036         g_value_unset( &gvalue );
2037
2038         usingDefaultAttrs = false;
2039     }
2040     else
2041     {
2042         GValue gvalue = { 0, };
2043         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2044         g_value_set_boolean( &gvalue, FALSE );
2045         g_object_set_property( G_OBJECT(renderer), "weight-set", &gvalue );
2046         g_value_unset( &gvalue );
2047     }
2048
2049 #if 0
2050     if (attr.HasBackgroundColour())
2051     {
2052         wxColour colour = attr.GetBackgroundColour();
2053         const GdkColor * const gcol = colour.GetColor();
2054
2055         GValue gvalue = { 0, };
2056         g_value_init( &gvalue, GDK_TYPE_COLOR );
2057         g_value_set_boxed( &gvalue, gcol );
2058         g_object_set_property( G_OBJECT(renderer), "cell-background_gdk", &gvalue );
2059         g_value_unset( &gvalue );
2060     }
2061     else
2062     {
2063         GValue gvalue = { 0, };
2064         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2065         g_value_set_boolean( &gvalue, FALSE );
2066         g_object_set_property( G_OBJECT(renderer), "cell-background-set", &gvalue );
2067         g_value_unset( &gvalue );
2068     }
2069 #endif
2070
2071     return !usingDefaultAttrs;
2072 }
2073
2074 } // anonymous namespace
2075
2076 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer)
2077
2078 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode,
2079                                                 int align ) :
2080     wxDataViewRenderer( varianttype, mode, align )
2081 {
2082     GtkWxCellRendererText *text_renderer = gtk_wx_cell_renderer_text_new();
2083     text_renderer->wx_renderer = this;
2084     m_renderer = (GtkCellRenderer*) text_renderer;
2085
2086     if (mode & wxDATAVIEW_CELL_EDITABLE)
2087     {
2088         GValue gvalue = { 0, };
2089         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2090         g_value_set_boolean( &gvalue, true );
2091         g_object_set_property( G_OBJECT(m_renderer), "editable", &gvalue );
2092         g_value_unset( &gvalue );
2093
2094         g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
2095
2096         GtkInitHandlers();
2097     }
2098
2099     SetMode(mode);
2100     SetAlignment(align);
2101 }
2102
2103 bool wxDataViewTextRenderer::SetTextValue(const wxString& str)
2104 {
2105     GValue gvalue = { 0, };
2106     g_value_init( &gvalue, G_TYPE_STRING );
2107     g_value_set_string( &gvalue, wxGTK_CONV_FONT( str, GetOwner()->GetOwner()->GetFont() ) );
2108     g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2109     g_value_unset( &gvalue );
2110
2111     return true;
2112 }
2113
2114 bool wxDataViewTextRenderer::GetTextValue(wxString& str) const
2115 {
2116     GValue gvalue = { 0, };
2117     g_value_init( &gvalue, G_TYPE_STRING );
2118     g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
2119     str = wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue ), const_cast<wxDataViewTextRenderer*>(this)->GetOwner()->GetOwner()->GetFont() );
2120     g_value_unset( &gvalue );
2121
2122     return true;
2123 }
2124
2125 void wxDataViewTextRenderer::SetAlignment( int align )
2126 {
2127     wxDataViewRenderer::SetAlignment(align);
2128
2129     if (gtk_check_version(2,10,0))
2130         return;
2131
2132     // horizontal alignment:
2133     PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
2134     if (align & wxALIGN_RIGHT)
2135         pangoAlign = PANGO_ALIGN_RIGHT;
2136     else if (align & wxALIGN_CENTER_HORIZONTAL)
2137         pangoAlign = PANGO_ALIGN_CENTER;
2138
2139     GValue gvalue = { 0, };
2140     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
2141     g_value_set_enum( &gvalue, pangoAlign );
2142     g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
2143     g_value_unset( &gvalue );
2144 }
2145
2146 bool wxDataViewTextRenderer::GtkSetAttr(const wxDataViewItemAttr& attr)
2147 {
2148     return GtkApplyAttr(GtkGetTextRenderer(), attr);
2149 }
2150
2151 GtkCellRendererText *wxDataViewTextRenderer::GtkGetTextRenderer() const
2152 {
2153     return GTK_CELL_RENDERER_TEXT(m_renderer);
2154 }
2155
2156 // ---------------------------------------------------------
2157 // wxDataViewBitmapRenderer
2158 // ---------------------------------------------------------
2159
2160 namespace
2161 {
2162
2163 // set "pixbuf" property on the given renderer
2164 void SetPixbufProp(GtkCellRenderer *renderer, GdkPixbuf *pixbuf)
2165 {
2166     GValue gvalue = { 0, };
2167     g_value_init( &gvalue, G_TYPE_OBJECT );
2168     g_value_set_object( &gvalue, pixbuf );
2169     g_object_set_property( G_OBJECT(renderer), "pixbuf", &gvalue );
2170     g_value_unset( &gvalue );
2171 }
2172
2173 } // anonymous namespace
2174
2175 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer)
2176
2177 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode,
2178                                                     int align ) :
2179     wxDataViewRenderer( varianttype, mode, align )
2180 {
2181     m_renderer = gtk_cell_renderer_pixbuf_new();
2182
2183     SetMode(mode);
2184     SetAlignment(align);
2185 }
2186
2187 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
2188 {
2189     if (value.GetType() == wxT("wxBitmap"))
2190     {
2191         wxBitmap bitmap;
2192         bitmap << value;
2193
2194         // GetPixbuf() may create a Pixbuf representation in the wxBitmap
2195         // object (and it will stay there and remain owned by wxBitmap)
2196         SetPixbufProp(m_renderer, bitmap.GetPixbuf());
2197     }
2198     else if (value.GetType() == wxT("wxIcon"))
2199     {
2200         wxIcon icon;
2201         icon << value;
2202
2203         SetPixbufProp(m_renderer, icon.GetPixbuf());
2204     }
2205     else
2206     {
2207         return false;
2208     }
2209
2210     return true;
2211 }
2212
2213 bool wxDataViewBitmapRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2214 {
2215     return false;
2216 }
2217
2218 // ---------------------------------------------------------
2219 // wxDataViewToggleRenderer
2220 // ---------------------------------------------------------
2221
2222 extern "C" {
2223 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
2224     gchar *path, gpointer user_data );
2225 }
2226
2227 static void wxGtkToggleRendererToggledCallback( GtkCellRendererToggle *renderer,
2228     gchar *path, gpointer user_data )
2229 {
2230     wxDataViewToggleRenderer *cell = (wxDataViewToggleRenderer*) user_data;
2231
2232     // get old value
2233     GValue gvalue = { 0, };
2234     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2235     g_object_get_property( G_OBJECT(renderer), "active", &gvalue );
2236     bool tmp = g_value_get_boolean( &gvalue );
2237     g_value_unset( &gvalue );
2238     // invert it
2239     tmp = !tmp;
2240
2241     wxVariant value = tmp;
2242     if (!cell->Validate( value ))
2243         return;
2244
2245     wxDataViewCtrl * const ctrl = cell->GetOwner()->GetOwner();
2246     wxDataViewModel *model = ctrl->GetModel();
2247
2248     wxDataViewItem item(ctrl->GTKPathToItem(wxGtkTreePath(path)));
2249
2250     unsigned int model_col = cell->GetOwner()->GetModelColumn();
2251
2252     model->ChangeValue( value, item, model_col );
2253 }
2254
2255 IMPLEMENT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer)
2256
2257 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
2258                                                     wxDataViewCellMode mode, int align ) :
2259     wxDataViewRenderer( varianttype, mode, align )
2260 {
2261     m_renderer = (GtkCellRenderer*) gtk_cell_renderer_toggle_new();
2262
2263     if (mode & wxDATAVIEW_CELL_ACTIVATABLE)
2264     {
2265         g_signal_connect_after( m_renderer, "toggled",
2266                                 G_CALLBACK(wxGtkToggleRendererToggledCallback), this );
2267     }
2268     else
2269     {
2270         GValue gvalue = { 0, };
2271         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2272         g_value_set_boolean( &gvalue, false );
2273         g_object_set_property( G_OBJECT(m_renderer), "activatable", &gvalue );
2274         g_value_unset( &gvalue );
2275     }
2276
2277     SetMode(mode);
2278     SetAlignment(align);
2279 }
2280
2281 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
2282 {
2283     bool tmp = value;
2284
2285     GValue gvalue = { 0, };
2286     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2287     g_value_set_boolean( &gvalue, tmp );
2288     g_object_set_property( G_OBJECT(m_renderer), "active", &gvalue );
2289     g_value_unset( &gvalue );
2290
2291     return true;
2292 }
2293
2294 bool wxDataViewToggleRenderer::GetValue( wxVariant &value ) const
2295 {
2296     GValue gvalue = { 0, };
2297     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2298     g_object_get_property( G_OBJECT(m_renderer), "active", &gvalue );
2299     bool tmp = g_value_get_boolean( &gvalue );
2300     g_value_unset( &gvalue );
2301
2302     value = tmp;
2303
2304     return true;
2305 }
2306
2307 // ---------------------------------------------------------
2308 // wxDataViewCustomRenderer
2309 // ---------------------------------------------------------
2310
2311 class wxDataViewCtrlDCImpl: public wxWindowDCImpl
2312 {
2313 public:
2314    wxDataViewCtrlDCImpl( wxDC *owner, wxDataViewCtrl *window ) :
2315        wxWindowDCImpl( owner )
2316    {
2317         GtkWidget *widget = window->m_treeview;
2318         // Set later
2319         m_gdkwindow = NULL;
2320
2321         m_window = window;
2322
2323         m_context = window->GTKGetPangoDefaultContext();
2324         m_layout = pango_layout_new( m_context );
2325         m_fontdesc = pango_font_description_copy(gtk_widget_get_style(widget)->font_desc);
2326
2327         m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
2328
2329         // Set m_gdkwindow later
2330         // SetUpDC();
2331     }
2332 };
2333
2334 class wxDataViewCtrlDC: public wxWindowDC
2335 {
2336 public:
2337     wxDataViewCtrlDC( wxDataViewCtrl *window ) :
2338         wxWindowDC( new wxDataViewCtrlDCImpl( this, window ) )
2339         { }
2340 };
2341
2342
2343 // ---------------------------------------------------------
2344 // wxDataViewCustomRenderer
2345 // ---------------------------------------------------------
2346
2347 IMPLEMENT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
2348
2349 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
2350                                                     wxDataViewCellMode mode,
2351                                                     int align,
2352                                                     bool no_init )
2353     : wxDataViewCustomRendererBase( varianttype, mode, align )
2354 {
2355     m_dc = NULL;
2356     m_text_renderer = NULL;
2357
2358     if (no_init)
2359         m_renderer = NULL;
2360     else
2361         Init(mode, align);
2362 }
2363
2364 void wxDataViewCustomRenderer::GtkInitTextRenderer()
2365 {
2366     m_text_renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
2367     g_object_ref_sink(m_text_renderer);
2368
2369     GtkApplyAlignment(GTK_CELL_RENDERER(m_text_renderer));
2370 }
2371
2372 GtkCellRendererText *wxDataViewCustomRenderer::GtkGetTextRenderer() const
2373 {
2374     if ( !m_text_renderer )
2375     {
2376         // we create it on demand so need to do it even from a const function
2377         const_cast<wxDataViewCustomRenderer *>(this)->GtkInitTextRenderer();
2378     }
2379
2380     return m_text_renderer;
2381 }
2382
2383 void wxDataViewCustomRenderer::RenderText( const wxString &text,
2384                                            int xoffset,
2385                                            wxRect cell,
2386                                            wxDC *WXUNUSED(dc),
2387                                            int WXUNUSED(state) )
2388 {
2389
2390     GtkCellRendererText * const textRenderer = GtkGetTextRenderer();
2391
2392     GValue gvalue = { 0, };
2393     g_value_init( &gvalue, G_TYPE_STRING );
2394     g_value_set_string( &gvalue, wxGTK_CONV_FONT( text, GetOwner()->GetOwner()->GetFont() ) );
2395     g_object_set_property( G_OBJECT(textRenderer), "text", &gvalue );
2396     g_value_unset( &gvalue );
2397
2398     GtkApplyAttr(textRenderer, GetAttr());
2399
2400     GdkRectangle cell_area;
2401     wxRectToGDKRect(cell, cell_area);
2402     cell_area.x += xoffset;
2403     cell_area.width -= xoffset;
2404
2405     gtk_cell_renderer_render( GTK_CELL_RENDERER(textRenderer),
2406         m_renderParams.window,
2407         m_renderParams.widget,
2408         m_renderParams.background_area,
2409         &cell_area,
2410         m_renderParams.expose_area,
2411         (GtkCellRendererState) m_renderParams.flags );
2412 }
2413
2414 bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode, int align)
2415 {
2416     GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
2417     renderer->cell = this;
2418
2419     m_renderer = (GtkCellRenderer*) renderer;
2420
2421     SetMode(mode);
2422     SetAlignment(align);
2423
2424     GtkInitHandlers();
2425
2426     return true;
2427 }
2428
2429 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
2430 {
2431     if (m_dc)
2432         delete m_dc;
2433
2434     if (m_text_renderer)
2435         g_object_unref(m_text_renderer);
2436 }
2437
2438 wxDC *wxDataViewCustomRenderer::GetDC()
2439 {
2440     if (m_dc == NULL)
2441     {
2442         if (GetOwner() == NULL)
2443             return NULL;
2444         if (GetOwner()->GetOwner() == NULL)
2445             return NULL;
2446         m_dc = new wxDataViewCtrlDC( GetOwner()->GetOwner() );
2447     }
2448
2449     return m_dc;
2450 }
2451
2452 // ---------------------------------------------------------
2453 // wxDataViewProgressRenderer
2454 // ---------------------------------------------------------
2455
2456 IMPLEMENT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
2457
2458 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
2459     const wxString &varianttype, wxDataViewCellMode mode, int align ) :
2460     wxDataViewCustomRenderer( varianttype, mode, align, true )
2461 {
2462     m_label = label;
2463     m_value = 0;
2464
2465 #ifdef __WXGTK26__
2466     if (!gtk_check_version(2,6,0))
2467     {
2468         m_renderer = (GtkCellRenderer*) gtk_cell_renderer_progress_new();
2469
2470         SetMode(mode);
2471         SetAlignment(align);
2472
2473 #if !wxUSE_UNICODE
2474         // We can't initialize the renderer just yet because we don't have the
2475         // pointer to the column that uses this renderer yet and so attempt to
2476         // dereference GetOwner() to get the font that is used as a source of
2477         // encoding in multibyte-to-Unicode conversion in GTKSetLabel() in
2478         // non-Unicode builds would crash. So simply remember to do it later.
2479         if ( !m_label.empty() )
2480             m_needsToSetLabel = true;
2481         else
2482 #endif // !wxUSE_UNICODE
2483             GTKSetLabel();
2484     }
2485     else
2486 #endif
2487     {
2488         // Use custom cell code
2489         wxDataViewCustomRenderer::Init(mode, align);
2490     }
2491 }
2492
2493 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
2494 {
2495 }
2496
2497 void wxDataViewProgressRenderer::GTKSetLabel()
2498 {
2499     GValue gvalue = { 0, };
2500     g_value_init( &gvalue, G_TYPE_STRING );
2501
2502     // Take care to not use GetOwner() here if the label is empty, we can be
2503     // called from ctor when GetOwner() is still NULL in this case.
2504     wxScopedCharBuffer buf;
2505     if ( m_label.empty() )
2506         buf = wxScopedCharBuffer::CreateNonOwned("");
2507     else
2508         buf = wxGTK_CONV_FONT(m_label, GetOwner()->GetOwner()->GetFont());
2509
2510     g_value_set_string( &gvalue, buf);
2511     g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2512     g_value_unset( &gvalue );
2513
2514 #if !wxUSE_UNICODE
2515     m_needsToSetLabel = false;
2516 #endif // !wxUSE_UNICODE
2517 }
2518
2519 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
2520 {
2521 #ifdef __WXGTK26__
2522     if (!gtk_check_version(2,6,0))
2523     {
2524 #if !wxUSE_UNICODE
2525         if ( m_needsToSetLabel )
2526             GTKSetLabel();
2527 #endif // !wxUSE_UNICODE
2528
2529         gint tmp = (long) value;
2530         GValue gvalue = { 0, };
2531         g_value_init( &gvalue, G_TYPE_INT );
2532         g_value_set_int( &gvalue, tmp );
2533         g_object_set_property( G_OBJECT(m_renderer), "value", &gvalue );
2534         g_value_unset( &gvalue );
2535     }
2536     else
2537 #endif
2538     {
2539         m_value = (long) value;
2540
2541         if (m_value < 0) m_value = 0;
2542         if (m_value > 100) m_value = 100;
2543     }
2544
2545     return true;
2546 }
2547
2548 bool wxDataViewProgressRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
2549 {
2550     return false;
2551 }
2552
2553 bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
2554 {
2555     double pct = (double)m_value / 100.0;
2556     wxRect bar = cell;
2557     bar.width = (int)(cell.width * pct);
2558     dc->SetPen( *wxTRANSPARENT_PEN );
2559     dc->SetBrush( *wxBLUE_BRUSH );
2560     dc->DrawRectangle( bar );
2561
2562     dc->SetBrush( *wxTRANSPARENT_BRUSH );
2563     dc->SetPen( *wxBLACK_PEN );
2564     dc->DrawRectangle( cell );
2565
2566     return true;
2567 }
2568
2569 wxSize wxDataViewProgressRenderer::GetSize() const
2570 {
2571     return wxSize(40,12);
2572 }
2573
2574 // -------------------------------------
2575 // wxDataViewChoiceRenderer
2576 // -------------------------------------
2577
2578 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString &choices,
2579                             wxDataViewCellMode mode, int alignment  ) :
2580     wxDataViewCustomRenderer( "string", mode, alignment, true )
2581 {
2582    m_choices = choices;
2583
2584 #ifdef __WXGTK26__
2585     if (!gtk_check_version(2,6,0))
2586     {
2587         m_renderer = (GtkCellRenderer*) gtk_cell_renderer_combo_new();
2588
2589         GtkListStore *store = gtk_list_store_new( 1, G_TYPE_STRING );
2590         for (size_t n = 0; n < m_choices.GetCount(); n++)
2591         {
2592             gtk_list_store_insert_with_values(
2593                 store, NULL, n, 0,
2594                 static_cast<const char *>(m_choices[n].utf8_str()), -1 );
2595         }
2596
2597         g_object_set (m_renderer,
2598                 "model", store,
2599                 "text-column", 0,
2600                 "has-entry", FALSE,
2601                 NULL);
2602
2603         bool editable = (mode & wxDATAVIEW_CELL_EDITABLE);
2604         g_object_set (m_renderer, "editable", editable, NULL);
2605
2606         SetAlignment(alignment);
2607
2608         g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
2609
2610         GtkInitHandlers();
2611     }
2612     else
2613 #endif
2614     {
2615         // Use custom cell code
2616         wxDataViewCustomRenderer::Init(mode, alignment);
2617     }
2618 }
2619
2620 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
2621 {
2622     RenderText( m_data, 0, rect, dc, state );
2623     return true;
2624 }
2625
2626 wxSize wxDataViewChoiceRenderer::GetSize() const
2627 {
2628     return wxSize(70,20);
2629 }
2630
2631 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
2632 {
2633
2634 #ifdef __WXGTK26__
2635     if (!gtk_check_version(2,6,0))
2636     {
2637         GValue gvalue = { 0, };
2638         g_value_init( &gvalue, G_TYPE_STRING );
2639         g_value_set_string(&gvalue,
2640                            wxGTK_CONV_FONT(value.GetString(),
2641                                            GetOwner()->GetOwner()->GetFont()));
2642         g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
2643         g_value_unset( &gvalue );
2644     }
2645     else
2646 #endif
2647         m_data = value.GetString();
2648
2649     return true;
2650 }
2651
2652 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
2653 {
2654 #ifdef __WXGTK26__
2655     if (!gtk_check_version(2,6,0))
2656     {
2657         GValue gvalue = { 0, };
2658         g_value_init( &gvalue, G_TYPE_STRING );
2659         g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
2660         wxString temp = wxGTK_CONV_BACK_FONT(g_value_get_string(&gvalue),
2661                                              GetOwner()->GetOwner()->GetFont());
2662         g_value_unset( &gvalue );
2663         value = temp;
2664
2665         //wxPrintf( "temp %s\n", temp );
2666         // TODO: remove this code
2667     }
2668     else
2669 #endif
2670         value = m_data;
2671
2672     return true;
2673 }
2674
2675 void wxDataViewChoiceRenderer::SetAlignment( int align )
2676 {
2677     wxDataViewCustomRenderer::SetAlignment(align);
2678
2679     if (gtk_check_version(2,10,0))
2680         return;
2681
2682     // horizontal alignment:
2683     PangoAlignment pangoAlign = PANGO_ALIGN_LEFT;
2684     if (align & wxALIGN_RIGHT)
2685         pangoAlign = PANGO_ALIGN_RIGHT;
2686     else if (align & wxALIGN_CENTER_HORIZONTAL)
2687         pangoAlign = PANGO_ALIGN_CENTER;
2688
2689     GValue gvalue = { 0, };
2690     g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
2691     g_value_set_enum( &gvalue, pangoAlign );
2692     g_object_set_property( G_OBJECT(m_renderer), "alignment", &gvalue );
2693     g_value_unset( &gvalue );
2694 }
2695
2696 // ----------------------------------------------------------------------------
2697 // wxDataViewChoiceByIndexRenderer
2698 // ----------------------------------------------------------------------------
2699
2700 wxDataViewChoiceByIndexRenderer::wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
2701                               wxDataViewCellMode mode, int alignment ) :
2702       wxDataViewChoiceRenderer( choices, mode, alignment )
2703 {
2704 }
2705
2706 void wxDataViewChoiceByIndexRenderer::GtkOnTextEdited(const char *itempath, const wxString& str)
2707 {
2708     wxVariant value( (long) GetChoices().Index( str ) );
2709
2710     if (!Validate( value ))
2711         return;
2712
2713     wxDataViewItem
2714         item(GetOwner()->GetOwner()->GTKPathToItem(wxGtkTreePath(itempath)));
2715
2716     GtkOnCellChanged(value, item, GetOwner()->GetModelColumn());
2717 }
2718
2719 bool wxDataViewChoiceByIndexRenderer::SetValue( const wxVariant &value )
2720 {
2721     wxVariant string_value = GetChoice( value.GetLong() );
2722     return wxDataViewChoiceRenderer::SetValue( string_value );
2723 }
2724
2725 bool wxDataViewChoiceByIndexRenderer::GetValue( wxVariant &value ) const
2726 {
2727     wxVariant string_value;
2728     if (!wxDataViewChoiceRenderer::GetValue( string_value ))
2729          return false;
2730
2731     value = (long) GetChoices().Index( string_value.GetString() );
2732     return true;
2733 }
2734
2735 // ---------------------------------------------------------
2736 // wxDataViewIconTextRenderer
2737 // ---------------------------------------------------------
2738
2739 IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewCustomRenderer)
2740
2741 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer
2742                             (
2743                              const wxString &varianttype,
2744                              wxDataViewCellMode mode,
2745                              int align
2746                             )
2747     : wxDataViewTextRenderer(varianttype, mode, align)
2748 {
2749     m_rendererIcon = gtk_cell_renderer_pixbuf_new();
2750 }
2751
2752 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
2753 {
2754 }
2755
2756 void wxDataViewIconTextRenderer::GtkPackIntoColumn(GtkTreeViewColumn *column)
2757 {
2758     // add the icon renderer first
2759     gtk_tree_view_column_pack_start(column, m_rendererIcon, FALSE /* !expand */);
2760
2761     // add the text renderer too
2762     wxDataViewRenderer::GtkPackIntoColumn(column);
2763 }
2764
2765 bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value )
2766 {
2767     m_value << value;
2768
2769     SetTextValue(m_value.GetText());
2770     SetPixbufProp(m_rendererIcon, m_value.GetIcon().GetPixbuf());
2771
2772     return true;
2773 }
2774
2775 bool wxDataViewIconTextRenderer::GetValue(wxVariant& value) const
2776 {
2777     wxString str;
2778     if ( !GetTextValue(str) )
2779         return false;
2780
2781     // user doesn't have any way to edit the icon so leave it unchanged
2782     value << wxDataViewIconText(str, m_value.GetIcon());
2783
2784     return true;
2785 }
2786
2787 void
2788 wxDataViewIconTextRenderer::GtkOnCellChanged(const wxVariant& value,
2789                                              const wxDataViewItem& item,
2790                                              unsigned col)
2791 {
2792     // we receive just the text part of our value as it's the only one which
2793     // can be edited, but we need the full wxDataViewIconText value for the
2794     // model
2795     wxVariant valueIconText;
2796     valueIconText << wxDataViewIconText(value.GetString(), m_value.GetIcon());
2797     wxDataViewTextRenderer::GtkOnCellChanged(valueIconText, item, col);
2798 }
2799
2800 // ---------------------------------------------------------
2801 // wxDataViewColumn
2802 // ---------------------------------------------------------
2803
2804
2805 static gboolean
2806 gtk_dataview_header_button_press_callback( GtkWidget *WXUNUSED(widget),
2807                                            GdkEventButton *gdk_event,
2808                                            wxDataViewColumn *column )
2809 {
2810     if (gdk_event->type != GDK_BUTTON_PRESS)
2811         return FALSE;
2812
2813     if (gdk_event->button == 1)
2814     {
2815         gs_lastLeftClickHeader = column;
2816
2817         wxDataViewCtrl *dv = column->GetOwner();
2818         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
2819         event.SetDataViewColumn( column );
2820         event.SetModel( dv->GetModel() );
2821         if (dv->HandleWindowEvent( event ))
2822             return FALSE;
2823     }
2824
2825     if (gdk_event->button == 3)
2826     {
2827         wxDataViewCtrl *dv = column->GetOwner();
2828         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, dv->GetId() );
2829         event.SetDataViewColumn( column );
2830         event.SetModel( dv->GetModel() );
2831         if (dv->HandleWindowEvent( event ))
2832             return FALSE;
2833     }
2834
2835     return FALSE;
2836 }
2837
2838 extern "C"
2839 {
2840
2841 static void wxGtkTreeCellDataFunc( GtkTreeViewColumn *WXUNUSED(column),
2842                             GtkCellRenderer *renderer,
2843                             GtkTreeModel *model,
2844                             GtkTreeIter *iter,
2845                             gpointer data )
2846 {
2847     g_return_if_fail (GTK_IS_WX_TREE_MODEL (model));
2848     GtkWxTreeModel *tree_model = (GtkWxTreeModel *) model;
2849
2850     wxDataViewRenderer *cell = (wxDataViewRenderer*) data;
2851
2852     wxDataViewItem item( (void*) iter->user_data );
2853
2854     wxDataViewModel *wx_model = tree_model->internal->GetDataViewModel();
2855
2856     if (!wx_model->IsVirtualListModel())
2857     {
2858         gboolean visible;
2859         if (wx_model->IsContainer( item ))
2860         {
2861             visible = wx_model->HasContainerColumns( item ) ||
2862                         (cell->GetOwner()->GetModelColumn() == 0);
2863         }
2864         else
2865         {
2866             visible = true;
2867         }
2868
2869         GValue gvalue = { 0, };
2870         g_value_init( &gvalue, G_TYPE_BOOLEAN );
2871         g_value_set_boolean( &gvalue, visible );
2872         g_object_set_property( G_OBJECT(renderer), "visible", &gvalue );
2873         g_value_unset( &gvalue );
2874
2875         if ( !visible )
2876             return;
2877     }
2878
2879     wxVariant value;
2880     wx_model->GetValue( value, item, cell->GetOwner()->GetModelColumn() );
2881
2882     if (value.GetType() != cell->GetVariantType())
2883     {
2884         wxLogError( wxT("Wrong type, required: %s but: %s"),
2885                     value.GetType().c_str(),
2886                     cell->GetVariantType().c_str() );
2887     }
2888
2889     cell->SetValue( value );
2890
2891     // deal with disabled items
2892     bool enabled = wx_model->IsEnabled( item, cell->GetOwner()->GetModelColumn() );
2893
2894     // a) this sets the appearance to disabled grey
2895     GValue gvalue = { 0, };
2896     g_value_init( &gvalue, G_TYPE_BOOLEAN );
2897     g_value_set_boolean( &gvalue, enabled );
2898     g_object_set_property( G_OBJECT(renderer), "sensitive", &gvalue );
2899     g_value_unset( &gvalue );
2900
2901     // b) this actually disables the control/renderer
2902     if (enabled)
2903         cell->SetMode( cell->GtkGetMode() );
2904     else
2905         cell->SetMode( wxDATAVIEW_CELL_INERT );
2906
2907
2908     // deal with attributes: if the renderer doesn't support them at all, we
2909     // don't even need to query the model for them
2910     if ( !cell->GtkSupportsAttrs() )
2911         return;
2912
2913     // it can support attributes so check if this item has any
2914     wxDataViewItemAttr attr;
2915     if ( wx_model->GetAttr( item, cell->GetOwner()->GetModelColumn(), attr )
2916             || !cell->GtkIsUsingDefaultAttrs() )
2917     {
2918         bool usingDefaultAttrs = !cell->GtkSetAttr(attr);
2919         cell->GtkSetUsingDefaultAttrs(usingDefaultAttrs);
2920     }
2921     // else: no custom attributes specified and we're already using the default
2922     //       ones -- nothing to do
2923
2924 }
2925
2926 } // extern "C"
2927
2928 #include <wx/listimpl.cpp>
2929 WX_DEFINE_LIST(wxDataViewColumnList)
2930
2931 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell,
2932                                     unsigned int model_column, int width,
2933                                     wxAlignment align, int flags )
2934     : wxDataViewColumnBase( cell, model_column )
2935 {
2936     Init( align, flags, width );
2937
2938     SetTitle( title );
2939 }
2940
2941 wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell,
2942                                     unsigned int model_column, int width,
2943                                     wxAlignment align, int flags )
2944     : wxDataViewColumnBase( bitmap, cell, model_column )
2945 {
2946     Init( align, flags, width );
2947
2948     SetBitmap( bitmap );
2949 }
2950
2951 void wxDataViewColumn::Init(wxAlignment align, int flags, int width)
2952 {
2953     m_isConnected = false;
2954
2955     GtkTreeViewColumn *column = gtk_tree_view_column_new();
2956     m_column = (GtkWidget*) column;
2957
2958     SetFlags( flags );
2959     SetAlignment( align );
2960
2961     SetWidth( width );
2962
2963     // Create container for icon and label
2964     GtkWidget *box = gtk_hbox_new( FALSE, 1 );
2965     gtk_widget_show( box );
2966     // gtk_container_set_border_width((GtkContainer*)box, 2);
2967     m_image = gtk_image_new();
2968     gtk_box_pack_start(GTK_BOX(box), m_image, FALSE, FALSE, 1);
2969     m_label = gtk_label_new("");
2970     gtk_box_pack_end( GTK_BOX(box), GTK_WIDGET(m_label), FALSE, FALSE, 1 );
2971     gtk_tree_view_column_set_widget( column, box );
2972
2973     wxDataViewRenderer * const colRenderer = GetRenderer();
2974     GtkCellRenderer * const cellRenderer = colRenderer->GetGtkHandle();
2975
2976     colRenderer->GtkPackIntoColumn(column);
2977
2978     gtk_tree_view_column_set_cell_data_func( column, cellRenderer,
2979         wxGtkTreeCellDataFunc, (gpointer) colRenderer, NULL );
2980 }
2981
2982 void wxDataViewColumn::OnInternalIdle()
2983 {
2984     if (m_isConnected)
2985         return;
2986
2987     if (gtk_widget_get_realized(GetOwner()->m_treeview))
2988     {
2989         GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
2990         if (column->button)
2991         {
2992             g_signal_connect(column->button, "button_press_event",
2993                       G_CALLBACK (gtk_dataview_header_button_press_callback), this);
2994
2995             // otherwise the event will be blocked by GTK+
2996             gtk_tree_view_column_set_clickable( column, TRUE );
2997
2998             m_isConnected = true;
2999         }
3000     }
3001 }
3002
3003 void wxDataViewColumn::SetOwner( wxDataViewCtrl *owner )
3004 {
3005     wxDataViewColumnBase::SetOwner( owner );
3006
3007     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3008
3009     gtk_tree_view_column_set_title( column, wxGTK_CONV_FONT(GetTitle(), GetOwner()->GetFont() ) );
3010 }
3011
3012 void wxDataViewColumn::SetTitle( const wxString &title )
3013 {
3014     wxDataViewCtrl *ctrl = GetOwner();
3015     gtk_label_set_text( GTK_LABEL(m_label), ctrl ? wxGTK_CONV_FONT(title, ctrl->GetFont())
3016                                                  : wxGTK_CONV_SYS(title) );
3017     if (title.empty())
3018         gtk_widget_hide( m_label );
3019     else
3020         gtk_widget_show( m_label );
3021 }
3022
3023 wxString wxDataViewColumn::GetTitle() const
3024 {
3025     return wxGTK_CONV_BACK_FONT(
3026             gtk_label_get_text( GTK_LABEL(m_label) ),
3027             GetOwner()->GetFont()
3028            );
3029 }
3030
3031 void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
3032 {
3033     wxDataViewColumnBase::SetBitmap( bitmap );
3034
3035     if (bitmap.IsOk())
3036     {
3037         GtkImage *gtk_image = GTK_IMAGE(m_image);
3038
3039         GdkBitmap *mask = NULL;
3040         if (bitmap.GetMask())
3041             mask = bitmap.GetMask()->GetBitmap();
3042
3043         if (bitmap.HasPixbuf())
3044         {
3045             gtk_image_set_from_pixbuf(GTK_IMAGE(gtk_image),
3046                                       bitmap.GetPixbuf());
3047         }
3048         else
3049         {
3050             gtk_image_set_from_pixmap(GTK_IMAGE(gtk_image),
3051                                       bitmap.GetPixmap(), mask);
3052         }
3053         gtk_widget_show( m_image );
3054     }
3055     else
3056     {
3057         gtk_widget_hide( m_image );
3058     }
3059 }
3060
3061 void wxDataViewColumn::SetHidden( bool hidden )
3062 {
3063     gtk_tree_view_column_set_visible( GTK_TREE_VIEW_COLUMN(m_column), !hidden );
3064 }
3065
3066 void wxDataViewColumn::SetResizeable( bool resizable )
3067 {
3068     gtk_tree_view_column_set_resizable( GTK_TREE_VIEW_COLUMN(m_column), resizable );
3069 }
3070
3071 void wxDataViewColumn::SetAlignment( wxAlignment align )
3072 {
3073     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3074
3075     gfloat xalign = 0.0;
3076     if (align == wxALIGN_RIGHT)
3077         xalign = 1.0;
3078     if (align == wxALIGN_CENTER_HORIZONTAL ||
3079         align == wxALIGN_CENTER)
3080         xalign = 0.5;
3081
3082     gtk_tree_view_column_set_alignment( column, xalign );
3083
3084     if (m_renderer && m_renderer->GetAlignment() == -1)
3085         m_renderer->GtkUpdateAlignment();
3086 }
3087
3088 wxAlignment wxDataViewColumn::GetAlignment() const
3089 {
3090     gfloat xalign = gtk_tree_view_column_get_alignment( GTK_TREE_VIEW_COLUMN(m_column) );
3091
3092     if (xalign == 1.0)
3093         return wxALIGN_RIGHT;
3094     if (xalign == 0.5)
3095         return wxALIGN_CENTER_HORIZONTAL;
3096
3097     return wxALIGN_LEFT;
3098 }
3099
3100 void wxDataViewColumn::SetSortable( bool sortable )
3101 {
3102     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3103
3104     if ( sortable )
3105     {
3106         gtk_tree_view_column_set_sort_column_id( column, GetModelColumn() );
3107     }
3108     else
3109     {
3110         gtk_tree_view_column_set_sort_column_id( column, -1 );
3111         gtk_tree_view_column_set_sort_indicator( column, FALSE );
3112         gtk_tree_view_column_set_clickable( column, FALSE );
3113     }
3114 }
3115
3116 bool wxDataViewColumn::IsSortable() const
3117 {
3118     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3119     return gtk_tree_view_column_get_clickable( column );
3120 }
3121
3122 bool wxDataViewColumn::IsSortKey() const
3123 {
3124     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3125     return gtk_tree_view_column_get_sort_indicator( column );
3126 }
3127
3128 bool wxDataViewColumn::IsResizeable() const
3129 {
3130     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3131     return gtk_tree_view_column_get_resizable( column );
3132 }
3133
3134 bool wxDataViewColumn::IsHidden() const
3135 {
3136     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3137     return !gtk_tree_view_column_get_visible( column );
3138 }
3139
3140 void wxDataViewColumn::SetSortOrder( bool ascending )
3141 {
3142     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3143
3144     if (ascending)
3145         gtk_tree_view_column_set_sort_order( column, GTK_SORT_ASCENDING );
3146     else
3147         gtk_tree_view_column_set_sort_order( column, GTK_SORT_DESCENDING );
3148
3149     gtk_tree_view_column_set_sort_indicator( column, TRUE );
3150 }
3151
3152 bool wxDataViewColumn::IsSortOrderAscending() const
3153 {
3154     GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
3155
3156     return (gtk_tree_view_column_get_sort_order( column ) != GTK_SORT_DESCENDING);
3157 }
3158
3159 void wxDataViewColumn::SetMinWidth( int width )
3160 {
3161     gtk_tree_view_column_set_min_width( GTK_TREE_VIEW_COLUMN(m_column), width );
3162 }
3163
3164 int wxDataViewColumn::GetMinWidth() const
3165 {
3166     return gtk_tree_view_column_get_min_width( GTK_TREE_VIEW_COLUMN(m_column) );
3167 }
3168
3169 int wxDataViewColumn::GetWidth() const
3170 {
3171     return gtk_tree_view_column_get_width( GTK_TREE_VIEW_COLUMN(m_column) );
3172 }
3173
3174 void wxDataViewColumn::SetWidth( int width )
3175 {
3176     if ( width == wxCOL_WIDTH_AUTOSIZE )
3177     {
3178         // NB: this disables user resizing
3179         gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column), GTK_TREE_VIEW_COLUMN_AUTOSIZE );
3180     }
3181     else
3182     {
3183         if ( width == wxCOL_WIDTH_DEFAULT )
3184         {
3185             // TODO find a better calculation
3186             width = wxDVC_DEFAULT_WIDTH;
3187         }
3188
3189         gtk_tree_view_column_set_sizing( GTK_TREE_VIEW_COLUMN(m_column), GTK_TREE_VIEW_COLUMN_FIXED );
3190         gtk_tree_view_column_set_fixed_width( GTK_TREE_VIEW_COLUMN(m_column), width );
3191     }
3192 }
3193
3194 void wxDataViewColumn::SetReorderable( bool reorderable )
3195 {
3196     gtk_tree_view_column_set_reorderable( GTK_TREE_VIEW_COLUMN(m_column), reorderable );
3197 }
3198
3199 bool wxDataViewColumn::IsReorderable() const
3200 {
3201     return gtk_tree_view_column_get_reorderable( GTK_TREE_VIEW_COLUMN(m_column) );
3202 }
3203
3204 //-----------------------------------------------------------------------------
3205 // wxGtkTreeModelNode
3206 //-----------------------------------------------------------------------------
3207
3208 #if 0
3209 class wxGtkTreeModelChildWithPos
3210 {
3211 public:
3212     unsigned int pos;
3213     void        *id;
3214 };
3215
3216 static
3217 int wxGtkTreeModelChildWithPosCmp( const void* data1, const void* data2, const void* user_data )
3218 {
3219     const wxGtkTreeModelChildWithPos* child1 = (const wxGtkTreeModelChildWithPos*) data1;
3220     const wxGtkTreeModelChildWithPos* child2 = (const wxGtkTreeModelChildWithPos*) data2;
3221     const wxDataViewCtrlInternal *internal = (const wxDataViewCtrlInternal *) user_data;
3222     int ret = internal->GetDataViewModel()->Compare( child1->id, child2->id,
3223         internal->GetSortColumn(), (internal->GetSortOrder() == GTK_SORT_DESCENDING) );
3224
3225     return ret;
3226 }
3227 #else
3228 static
3229 int LINKAGEMODE wxGtkTreeModelChildPtrCmp( void*** data1, void*** data2 )
3230 {
3231     return gs_internal->GetDataViewModel()->Compare( wxDataViewItem(**data1), wxDataViewItem(**data2),
3232         gs_internal->GetSortColumn(), (gs_internal->GetSortOrder() == GTK_SORT_ASCENDING) );
3233 }
3234
3235 WX_DEFINE_ARRAY_PTR( void**, wxGtkTreeModelChildrenPtr );
3236 #endif
3237
3238 void wxGtkTreeModelNode::Resort()
3239 {
3240     size_t child_count = GetChildCount();
3241     if (child_count == 0)
3242         return;
3243
3244     size_t node_count = GetNodesCount();
3245
3246     if (child_count == 1)
3247     {
3248         if (node_count == 1)
3249         {
3250             wxGtkTreeModelNode *node = m_nodes.Item( 0 );
3251             node->Resort();
3252         }
3253         return;
3254     }
3255
3256     gint *new_order = new gint[child_count];
3257
3258 #if 1
3259     // m_children has the original *void
3260     // ptrs points to these
3261     wxGtkTreeModelChildrenPtr ptrs;
3262     size_t i;
3263     for (i = 0; i < child_count; i++)
3264        ptrs.Add( &(m_children[i]) );
3265     // Sort the ptrs
3266     gs_internal = m_internal;
3267     ptrs.Sort( &wxGtkTreeModelChildPtrCmp );
3268
3269     wxGtkTreeModelChildren temp;
3270     void** base_ptr = &(m_children[0]);
3271     // Transfer positions to new_order array and
3272     // IDs to temp
3273     for (i = 0; i < child_count; i++)
3274     {
3275         new_order[i] = ptrs[i] - base_ptr;
3276         temp.Add( *ptrs[i] );
3277     }
3278
3279     // Transfer IDs back to m_children
3280     m_children.Clear();
3281     WX_APPEND_ARRAY( temp, m_children );
3282 #endif
3283 #if 0
3284     // Too slow
3285
3286     // Build up array with IDs and original positions
3287     wxGtkTreeModelChildWithPos* temp = new wxGtkTreeModelChildWithPos[child_count];
3288     size_t i;
3289     for (i = 0; i < child_count; i++)
3290     {
3291        temp[i].pos = i;
3292        temp[i].id = m_children[i];
3293     }
3294     // Sort array keeping original positions
3295     wxQsort( temp, child_count, sizeof(wxGtkTreeModelChildWithPos),
3296              &wxGtkTreeModelChildWithPosCmp, m_internal );
3297     // Transfer positions to new_order array and
3298     // IDs to m_children
3299     m_children.Clear();
3300     for (i = 0; i < child_count; i++)
3301     {
3302        new_order[i] = temp[i].pos;
3303        m_children.Add( temp[i].id );
3304     }
3305     // Delete array
3306     delete [] temp;
3307 #endif
3308
3309 #if 0
3310     // Too slow
3311
3312     wxGtkTreeModelChildren temp;
3313     WX_APPEND_ARRAY( temp, m_children );
3314
3315     gs_internal = m_internal;
3316     m_children.Sort( &wxGtkTreeModelChildCmp );
3317
3318     unsigned int pos;
3319     for (pos = 0; pos < child_count; pos++)
3320     {
3321         void *id = m_children.Item( pos );
3322         int old_pos = temp.Index( id );
3323         new_order[pos] = old_pos;
3324     }
3325 #endif
3326
3327     GtkTreeModel *gtk_tree_model = GTK_TREE_MODEL( m_internal->GetGtkModel() );
3328
3329     GtkTreeIter iter;
3330     iter.user_data = GetItem().GetID();
3331     iter.stamp = m_internal->GetGtkModel()->stamp;
3332
3333     gtk_tree_model_rows_reordered( gtk_tree_model,
3334             wxGtkTreePath(m_internal->get_path(&iter)), &iter, new_order );
3335
3336     delete [] new_order;
3337
3338     unsigned int pos;
3339     for (pos = 0; pos < node_count; pos++)
3340     {
3341         wxGtkTreeModelNode *node = m_nodes.Item( pos );
3342         node->Resort();
3343     }
3344 }
3345
3346 //-----------------------------------------------------------------------------
3347 // wxDataViewCtrlInternal
3348 //-----------------------------------------------------------------------------
3349
3350 wxDataViewCtrlInternal::wxDataViewCtrlInternal( wxDataViewCtrl *owner, wxDataViewModel *wx_model )
3351 {
3352     m_owner = owner;
3353     m_wx_model = wx_model;
3354
3355     m_gtk_model = NULL;
3356     m_root = NULL;
3357     m_sort_order = GTK_SORT_ASCENDING;
3358     m_sort_column = -1;
3359     m_dataview_sort_column = NULL;
3360
3361     m_dragDataObject = NULL;
3362     m_dropDataObject = NULL;
3363
3364     m_dirty = false;
3365
3366     m_gtk_model = wxgtk_tree_model_new();
3367     m_gtk_model->internal = this;
3368
3369     m_notifier = new wxGtkDataViewModelNotifier( wx_model, this );
3370
3371     wx_model->AddNotifier( m_notifier );
3372
3373     // g_object_unref( gtk_model ); ???
3374
3375     if (!m_wx_model->IsVirtualListModel())
3376         InitTree();
3377
3378     gtk_tree_view_set_model( GTK_TREE_VIEW(m_owner->GtkGetTreeView()), GTK_TREE_MODEL(m_gtk_model) );
3379 }
3380
3381 wxDataViewCtrlInternal::~wxDataViewCtrlInternal()
3382 {
3383     m_wx_model->RemoveNotifier( m_notifier );
3384
3385     // remove the model from the GtkTreeView before it gets destroyed
3386     gtk_tree_view_set_model( GTK_TREE_VIEW( m_owner->GtkGetTreeView() ), NULL );
3387
3388     g_object_unref( m_gtk_model );
3389
3390     delete m_dragDataObject;
3391     delete m_dropDataObject;
3392 }
3393
3394 void wxDataViewCtrlInternal::ScheduleRefresh()
3395 {
3396     m_dirty = true;
3397 }
3398
3399 void wxDataViewCtrlInternal::OnInternalIdle()
3400 {
3401     if (m_dirty)
3402     {
3403         GtkWidget *widget = m_owner->GtkGetTreeView();
3404         gtk_widget_queue_draw( widget );
3405         m_dirty = false;
3406     }
3407 }
3408
3409 void wxDataViewCtrlInternal::InitTree()
3410 {
3411     wxDataViewItem item;
3412     m_root = new wxGtkTreeModelNode( NULL, item, this );
3413
3414     BuildBranch( m_root );
3415 }
3416
3417 void wxDataViewCtrlInternal::BuildBranch( wxGtkTreeModelNode *node )
3418 {
3419     if (node->GetChildCount() == 0)
3420     {
3421         wxDataViewItemArray children;
3422         unsigned int count = m_wx_model->GetChildren( node->GetItem(), children );
3423
3424         unsigned int pos;
3425         for (pos = 0; pos < count; pos++)
3426         {
3427             wxDataViewItem child = children[pos];
3428
3429             if (m_wx_model->IsContainer( child ))
3430                 node->AddNode( new wxGtkTreeModelNode( node, child, this ) );
3431             else
3432                 node->AddLeaf( child.GetID() );
3433
3434             // Don't send any events here
3435         }
3436     }
3437 }
3438
3439 // GTK+ dnd iface
3440
3441 bool wxDataViewCtrlInternal::EnableDragSource( const wxDataFormat &format )
3442 {
3443     wxGtkString atom_str( gdk_atom_name( format  ) );
3444     m_dragSourceTargetEntryTarget = wxCharBuffer( atom_str );
3445
3446     m_dragSourceTargetEntry.target =  m_dragSourceTargetEntryTarget.data();
3447     m_dragSourceTargetEntry.flags = 0;
3448     m_dragSourceTargetEntry.info = static_cast<guint>(-1);
3449
3450     gtk_tree_view_enable_model_drag_source( GTK_TREE_VIEW(m_owner->GtkGetTreeView() ),
3451        GDK_BUTTON1_MASK, &m_dragSourceTargetEntry, 1, (GdkDragAction) GDK_ACTION_COPY );
3452
3453     return true;
3454 }
3455
3456 bool wxDataViewCtrlInternal::EnableDropTarget( const wxDataFormat &format )
3457 {
3458     wxGtkString atom_str( gdk_atom_name( format  ) );
3459     m_dropTargetTargetEntryTarget = wxCharBuffer( atom_str );
3460
3461     m_dropTargetTargetEntry.target =  m_dropTargetTargetEntryTarget.data();
3462     m_dropTargetTargetEntry.flags = 0;
3463     m_dropTargetTargetEntry.info = static_cast<guint>(-1);
3464
3465     gtk_tree_view_enable_model_drag_dest( GTK_TREE_VIEW(m_owner->GtkGetTreeView() ),
3466        &m_dropTargetTargetEntry, 1, (GdkDragAction) GDK_ACTION_COPY );
3467
3468     return true;
3469 }
3470
3471 gboolean wxDataViewCtrlInternal::row_draggable( GtkTreeDragSource *WXUNUSED(drag_source),
3472     GtkTreePath *path )
3473 {
3474     delete m_dragDataObject;
3475     m_dragDataObject = NULL;
3476
3477     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3478     if ( !item )
3479         return FALSE;
3480
3481     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() );
3482     event.SetEventObject( m_owner );
3483     event.SetItem( item );
3484     event.SetModel( m_wx_model );
3485     gint x, y;
3486     gtk_widget_get_pointer(m_owner->GtkGetTreeView(), &x, &y);
3487     event.SetPosition(x, y);
3488     if (!m_owner->HandleWindowEvent( event ))
3489         return FALSE;
3490
3491     if (!event.IsAllowed())
3492         return FALSE;
3493
3494     wxDataObject *obj = event.GetDataObject();
3495     if (!obj)
3496         return FALSE;
3497
3498     m_dragDataObject = obj;
3499
3500     return TRUE;
3501 }
3502
3503 gboolean
3504 wxDataViewCtrlInternal::drag_data_delete(GtkTreeDragSource *WXUNUSED(drag_source),
3505                                          GtkTreePath *WXUNUSED(path))
3506 {
3507     return FALSE;
3508 }
3509
3510 gboolean wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource *WXUNUSED(drag_source),
3511     GtkTreePath *path, GtkSelectionData *selection_data )
3512 {
3513     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3514     if ( !item )
3515         return FALSE;
3516
3517     GdkAtom target = gtk_selection_data_get_target(selection_data);
3518     if (!m_dragDataObject->IsSupported(target))
3519         return FALSE;
3520
3521     size_t size = m_dragDataObject->GetDataSize(target);
3522     if (size == 0)
3523         return FALSE;
3524
3525     void *buf = malloc( size );
3526
3527     gboolean res = FALSE;
3528     if (m_dragDataObject->GetDataHere(target, buf))
3529     {
3530         res = TRUE;
3531
3532         gtk_selection_data_set(selection_data, target,
3533             8, (const guchar*) buf, size );
3534     }
3535
3536     free( buf );
3537
3538     return res;
3539 }
3540
3541 gboolean
3542 wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest *WXUNUSED(drag_dest),
3543                                            GtkTreePath *path,
3544                                            GtkSelectionData *selection_data)
3545 {
3546     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3547     if ( !item )
3548         return FALSE;
3549
3550     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, m_owner->GetId() );
3551     event.SetEventObject( m_owner );
3552     event.SetItem( item );
3553     event.SetModel( m_wx_model );
3554     event.SetDataFormat(gtk_selection_data_get_target(selection_data));
3555     event.SetDataSize(gtk_selection_data_get_length(selection_data));
3556     event.SetDataBuffer(const_cast<guchar*>(gtk_selection_data_get_data(selection_data)));
3557     if (!m_owner->HandleWindowEvent( event ))
3558         return FALSE;
3559
3560     if (!event.IsAllowed())
3561         return FALSE;
3562
3563     return TRUE;
3564 }
3565
3566 gboolean
3567 wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest *WXUNUSED(drag_dest),
3568                                           GtkTreePath *path,
3569                                           GtkSelectionData *selection_data)
3570 {
3571     wxDataViewItem item(GetOwner()->GTKPathToItem(path));
3572     if ( !item )
3573         return FALSE;
3574
3575     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() );
3576     event.SetEventObject( m_owner );
3577     event.SetItem( item );
3578     event.SetModel( m_wx_model );
3579     event.SetDataFormat(gtk_selection_data_get_target(selection_data));
3580     if (!m_owner->HandleWindowEvent( event ))
3581         return FALSE;
3582
3583     if (!event.IsAllowed())
3584         return FALSE;
3585
3586     return TRUE;
3587 }
3588
3589 // notifications from wxDataViewModel
3590
3591 bool wxDataViewCtrlInternal::Cleared()
3592 {
3593     if (m_root)
3594     {
3595         delete m_root;
3596         m_root = NULL;
3597     }
3598
3599     InitTree();
3600
3601     ScheduleRefresh();
3602
3603     return true;
3604 }
3605
3606 void wxDataViewCtrlInternal::Resort()
3607 {
3608     if (!m_wx_model->IsVirtualListModel())
3609         m_root->Resort();
3610
3611     ScheduleRefresh();
3612 }
3613
3614 bool wxDataViewCtrlInternal::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
3615 {
3616     if (!m_wx_model->IsVirtualListModel())
3617     {
3618         wxGtkTreeModelNode *parent_node = FindNode( parent );
3619         wxCHECK_MSG(parent_node, false,
3620             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3621
3622         wxDataViewItemArray modelSiblings;
3623         m_wx_model->GetChildren(parent, modelSiblings);
3624         const int modelSiblingsSize = modelSiblings.size();
3625
3626         int posInModel = modelSiblings.Index(item, /*fromEnd=*/true);
3627         wxCHECK_MSG( posInModel != wxNOT_FOUND, false, "adding non-existent item?" );
3628
3629         const wxGtkTreeModelChildren& nodeSiblings = parent_node->GetChildren();
3630         const int nodeSiblingsSize = nodeSiblings.size();
3631
3632         int nodePos = 0;
3633
3634         if ( posInModel == modelSiblingsSize - 1 )
3635         {
3636             nodePos = nodeSiblingsSize;
3637         }
3638         else if ( modelSiblingsSize == nodeSiblingsSize + 1 )
3639         {
3640             // This is the simple case when our node tree already matches the
3641             // model and only this one item is missing.
3642             nodePos = posInModel;
3643         }
3644         else
3645         {
3646             // It's possible that a larger discrepancy between the model and
3647             // our realization exists. This can happen e.g. when adding a bunch
3648             // of items to the model and then calling ItemsAdded() just once
3649             // afterwards. In this case, we must find the right position by
3650             // looking at sibling items.
3651
3652             // append to the end if we won't find a better position:
3653             nodePos = nodeSiblingsSize;
3654
3655             for ( int nextItemPos = posInModel + 1;
3656                   nextItemPos < modelSiblingsSize;
3657                   nextItemPos++ )
3658             {
3659                 int nextNodePos = parent_node->FindChildByItem(modelSiblings[nextItemPos]);
3660                 if ( nextNodePos != wxNOT_FOUND )
3661                 {
3662                     nodePos = nextNodePos;
3663                     break;
3664                 }
3665             }
3666         }
3667
3668         if (m_wx_model->IsContainer( item ))
3669             parent_node->InsertNode( new wxGtkTreeModelNode( parent_node, item, this ), nodePos );
3670         else
3671             parent_node->InsertLeaf( item.GetID(), nodePos );
3672     }
3673
3674     ScheduleRefresh();
3675
3676     return true;
3677 }
3678
3679 bool wxDataViewCtrlInternal::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
3680 {
3681     if (!m_wx_model->IsVirtualListModel())
3682     {
3683         wxGtkTreeModelNode *parent_node = FindNode( parent );
3684         wxASSERT_MSG(parent_node,
3685             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3686
3687         parent_node->DeleteChild( item.GetID() );
3688     }
3689
3690     ScheduleRefresh();
3691
3692     return true;
3693 }
3694
3695 bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem &item )
3696 {
3697     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
3698     event.SetEventObject( m_owner );
3699     event.SetModel( m_owner->GetModel() );
3700     event.SetItem( item );
3701     m_owner->HandleWindowEvent( event );
3702
3703     return true;
3704 }
3705
3706 bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem &item, unsigned int view_column )
3707 {
3708     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
3709     event.SetEventObject( m_owner );
3710     event.SetModel( m_owner->GetModel() );
3711     event.SetColumn( view_column );
3712     event.SetDataViewColumn( GetOwner()->GetColumn(view_column) );
3713     event.SetItem( item );
3714     m_owner->HandleWindowEvent( event );
3715
3716     return true;
3717 }
3718
3719 // GTK+ model iface
3720
3721 GtkTreeModelFlags wxDataViewCtrlInternal::get_flags()
3722 {
3723     int flags = 0;
3724
3725     if ( m_wx_model->IsListModel() )
3726         flags |= GTK_TREE_MODEL_LIST_ONLY;
3727
3728     if ( !m_wx_model->IsVirtualListModel() )
3729         flags |= GTK_TREE_MODEL_ITERS_PERSIST;
3730
3731     return GtkTreeModelFlags(flags);
3732 }
3733
3734 gboolean wxDataViewCtrlInternal::get_iter( GtkTreeIter *iter, GtkTreePath *path )
3735 {
3736
3737     if (m_wx_model->IsVirtualListModel())
3738     {
3739         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3740
3741         unsigned int i = (unsigned int)gtk_tree_path_get_indices (path)[0];
3742
3743         if (i >= wx_model->GetCount())
3744             return FALSE;
3745
3746         iter->stamp = m_gtk_model->stamp;
3747         // user_data is just the index +1
3748         iter->user_data = wxUIntToPtr(i+1);
3749
3750         return TRUE;
3751     }
3752     else
3753     {
3754         int depth = gtk_tree_path_get_depth( path );
3755
3756         wxGtkTreeModelNode *node = m_root;
3757
3758         int i;
3759         for (i = 0; i < depth; i++)
3760         {
3761             BuildBranch( node );
3762
3763             gint pos = gtk_tree_path_get_indices (path)[i];
3764             if (pos < 0) return FALSE;
3765             if ((size_t)pos >= node->GetChildCount()) return FALSE;
3766
3767             void* id = node->GetChildren().Item( (size_t) pos );
3768
3769             if (i == depth-1)
3770             {
3771                 iter->stamp = m_gtk_model->stamp;
3772                 iter->user_data = id;
3773                 return TRUE;
3774             }
3775
3776             size_t count = node->GetNodes().GetCount();
3777             size_t pos2;
3778             for (pos2 = 0; pos2 < count; pos2++)
3779             {
3780                 wxGtkTreeModelNode *child_node = node->GetNodes().Item( pos2 );
3781                 if (child_node->GetItem().GetID() == id)
3782                 {
3783                     node = child_node;
3784                     break;
3785                 }
3786             }
3787         }
3788     }
3789
3790     return FALSE;
3791 }
3792
3793 GtkTreePath *wxDataViewCtrlInternal::get_path( GtkTreeIter *iter )
3794 {
3795     // When this is called from ItemDeleted(), the item is already
3796     // deleted in the model.
3797
3798     GtkTreePath *retval = gtk_tree_path_new ();
3799
3800     if (m_wx_model->IsVirtualListModel())
3801     {
3802         // iter is root, add nothing
3803         if (!iter->user_data)
3804            return retval;
3805
3806         // user_data is just the index +1
3807         int i = ( (wxUIntPtr) iter->user_data ) -1;
3808         gtk_tree_path_append_index (retval, i);
3809     }
3810     else
3811     {
3812         void *id = iter->user_data;
3813
3814         wxGtkTreeModelNode *node = FindParentNode( iter );
3815         while (node)
3816         {
3817             int pos = node->GetChildren().Index( id );
3818
3819             gtk_tree_path_prepend_index( retval, pos );
3820
3821             id = node->GetItem().GetID();
3822             node = node->GetParent();
3823         }
3824     }
3825
3826     return retval;
3827 }
3828
3829 gboolean wxDataViewCtrlInternal::iter_next( GtkTreeIter *iter )
3830 {
3831     if (m_wx_model->IsVirtualListModel())
3832     {
3833         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3834
3835         // user_data is just the index +1
3836         int n = ( (wxUIntPtr) iter->user_data ) -1;
3837
3838         if (n == -1)
3839         {
3840             iter->user_data = NULL;
3841             return FALSE;
3842         }
3843
3844         if (n >= (int) wx_model->GetCount()-1)
3845         {
3846             iter->user_data = NULL;
3847             return FALSE;
3848         }
3849
3850         // user_data is just the index +1 (+2 because we need the next)
3851         iter->user_data = wxUIntToPtr(n+2);
3852     }
3853     else
3854     {
3855         wxGtkTreeModelNode *parent = FindParentNode( iter );
3856         if( parent == NULL )
3857         {
3858             iter->user_data = NULL;
3859             return FALSE;
3860         }
3861
3862         int pos = parent->GetChildren().Index( iter->user_data );
3863
3864         if (pos == (int) parent->GetChildCount()-1)
3865         {
3866             iter->user_data = NULL;
3867             return FALSE;
3868         }
3869
3870         iter->user_data = parent->GetChildren().Item( pos+1 );
3871     }
3872
3873     return TRUE;
3874 }
3875
3876 gboolean wxDataViewCtrlInternal::iter_children( GtkTreeIter *iter, GtkTreeIter *parent )
3877 {
3878     if (m_wx_model->IsVirtualListModel())
3879     {
3880         // this is a list, nodes have no children
3881         if (parent)
3882             return FALSE;
3883
3884         iter->stamp = m_gtk_model->stamp;
3885         iter->user_data = (gpointer) 1;
3886
3887         return TRUE;
3888     }
3889     else
3890     {
3891         if (iter == NULL)
3892         {
3893             if (m_root->GetChildCount() == 0) return FALSE;
3894             iter->stamp = m_gtk_model->stamp;
3895             iter->user_data = (gpointer) m_root->GetChildren().Item( 0 );
3896             return TRUE;
3897         }
3898
3899
3900         wxDataViewItem item;
3901         if (parent)
3902             item = wxDataViewItem( (void*) parent->user_data );
3903
3904         if (!m_wx_model->IsContainer( item ))
3905             return FALSE;
3906
3907         wxGtkTreeModelNode *parent_node = FindNode( parent );
3908         wxASSERT_MSG(parent_node,
3909             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3910
3911         BuildBranch( parent_node );
3912
3913         if (parent_node->GetChildCount() == 0)
3914             return FALSE;
3915
3916         iter->stamp = m_gtk_model->stamp;
3917         iter->user_data = (gpointer) parent_node->GetChildren().Item( 0 );
3918     }
3919
3920     return TRUE;
3921 }
3922
3923 gboolean wxDataViewCtrlInternal::iter_has_child( GtkTreeIter *iter )
3924 {
3925     if (m_wx_model->IsVirtualListModel())
3926     {
3927         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3928
3929         if (iter == NULL)
3930             return (wx_model->GetCount() > 0);
3931
3932         // this is a list, nodes have no children
3933         return FALSE;
3934     }
3935     else
3936     {
3937         if (iter == NULL)
3938             return (m_root->GetChildCount() > 0);
3939
3940         wxDataViewItem item( (void*) iter->user_data );
3941
3942         bool is_container = m_wx_model->IsContainer( item );
3943
3944         if (!is_container)
3945             return FALSE;
3946
3947         wxGtkTreeModelNode *node = FindNode( iter );
3948         wxASSERT_MSG(node,
3949             "Did you forget a call to ItemAdded()? The iterator is unknown to the wxGtkTreeModel");
3950
3951         BuildBranch( node );
3952
3953         return (node->GetChildCount() > 0);
3954     }
3955 }
3956
3957 gint wxDataViewCtrlInternal::iter_n_children( GtkTreeIter *iter )
3958 {
3959     if (m_wx_model->IsVirtualListModel())
3960     {
3961         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3962
3963         if (iter == NULL)
3964             return (gint) wx_model->GetCount();
3965
3966         return 0;
3967     }
3968     else
3969     {
3970         if (iter == NULL)
3971             return m_root->GetChildCount();
3972
3973         wxDataViewItem item( (void*) iter->user_data );
3974
3975         if (!m_wx_model->IsContainer( item ))
3976             return 0;
3977
3978         wxGtkTreeModelNode *parent_node = FindNode( iter );
3979         wxASSERT_MSG(parent_node,
3980             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
3981
3982         BuildBranch( parent_node );
3983
3984         return parent_node->GetChildCount();
3985     }
3986 }
3987
3988 gboolean wxDataViewCtrlInternal::iter_nth_child( GtkTreeIter *iter, GtkTreeIter *parent, gint n )
3989 {
3990     if (m_wx_model->IsVirtualListModel())
3991     {
3992         wxDataViewVirtualListModel *wx_model = (wxDataViewVirtualListModel*) m_wx_model;
3993
3994         if (parent)
3995             return FALSE;
3996
3997         if (n < 0)
3998             return FALSE;
3999
4000         if (n >= (gint) wx_model->GetCount())
4001             return FALSE;
4002
4003         iter->stamp = m_gtk_model->stamp;
4004         // user_data is just the index +1
4005         iter->user_data = wxUIntToPtr(n+1);
4006
4007         return TRUE;
4008     }
4009     else
4010     {
4011         void* id = NULL;
4012         if (parent) id = (void*) parent->user_data;
4013         wxDataViewItem item( id );
4014
4015         if (!m_wx_model->IsContainer( item ))
4016             return FALSE;
4017
4018         wxGtkTreeModelNode *parent_node = FindNode( parent );
4019         wxASSERT_MSG(parent_node,
4020             "Did you forget a call to ItemAdded()? The parent node is unknown to the wxGtkTreeModel");
4021
4022         BuildBranch( parent_node );
4023
4024         iter->stamp = m_gtk_model->stamp;
4025         iter->user_data = parent_node->GetChildren().Item( n );
4026
4027         return TRUE;
4028     }
4029 }
4030
4031 gboolean wxDataViewCtrlInternal::iter_parent( GtkTreeIter *iter, GtkTreeIter *child )
4032 {
4033     if (m_wx_model->IsVirtualListModel())
4034     {
4035         return FALSE;
4036     }
4037     else
4038     {
4039         wxGtkTreeModelNode *node = FindParentNode( child );
4040         if (!node)
4041             return FALSE;
4042
4043         iter->stamp = m_gtk_model->stamp;
4044         iter->user_data = (gpointer) node->GetItem().GetID();
4045
4046         return TRUE;
4047     }
4048 }
4049
4050 // item can be deleted already in the model
4051 int wxDataViewCtrlInternal::GetIndexOf( const wxDataViewItem &parent, const wxDataViewItem &item )
4052 {
4053     if (m_wx_model->IsVirtualListModel())
4054     {
4055         return wxPtrToUInt(item.GetID()) - 1;
4056     }
4057     else
4058     {
4059         wxGtkTreeModelNode *parent_node = FindNode( parent );
4060         wxGtkTreeModelChildren &children = parent_node->GetChildren();
4061         size_t j;
4062         for (j = 0; j < children.GetCount(); j++)
4063         {
4064             if (children[j] == item.GetID())
4065                return j;
4066         }
4067     }
4068     return -1;
4069 }
4070
4071
4072 static wxGtkTreeModelNode*
4073 wxDataViewCtrlInternal_FindNode( wxDataViewModel * model, wxGtkTreeModelNode *treeNode, const wxDataViewItem &item )
4074 {
4075     if( model == NULL )
4076         return NULL;
4077
4078     ItemList list;
4079     list.DeleteContents( true );
4080     wxDataViewItem it( item );
4081
4082     while( it.IsOk() )
4083     {
4084         wxDataViewItem * pItem = new wxDataViewItem( it );
4085         list.Insert( pItem );
4086         it = model->GetParent( it );
4087     }
4088
4089     wxGtkTreeModelNode * node = treeNode;
4090     for( ItemList::compatibility_iterator n = list.GetFirst(); n; n = n->GetNext() )
4091     {
4092         if( node && node->GetNodes().GetCount() != 0 )
4093         {
4094             int len = node->GetNodes().GetCount();
4095             wxGtkTreeModelNodes &nodes = node->GetNodes();
4096             int j = 0;
4097             for( ; j < len; j ++)
4098             {
4099                 if( nodes[j]->GetItem() == *(n->GetData()))
4100                 {
4101                     node = nodes[j];
4102                     break;
4103                 }
4104             }
4105
4106             if( j == len )
4107             {
4108                 return NULL;
4109             }
4110         }
4111         else
4112             return NULL;
4113     }
4114     return node;
4115
4116 }
4117
4118 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( GtkTreeIter *iter )
4119 {
4120     if (!iter)
4121         return m_root;
4122
4123     wxDataViewItem item( (void*) iter->user_data );
4124     if (!item.IsOk())
4125         return m_root;
4126
4127     wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_wx_model, m_root, item );
4128
4129 /*
4130     if (!result)
4131     {
4132         wxLogDebug( "Not found %p", iter->user_data );
4133         char *crash = NULL;
4134         *crash = 0;
4135     }
4136     // TODO: remove this code
4137 */
4138
4139     return result;
4140 }
4141
4142 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindNode( const wxDataViewItem &item )
4143 {
4144     if (!item.IsOk())
4145         return m_root;
4146
4147     wxGtkTreeModelNode *result = wxDataViewCtrlInternal_FindNode( m_wx_model, m_root, item );
4148
4149 /*
4150     if (!result)
4151     {
4152         wxLogDebug( "Not found %p", item.GetID() );
4153         char *crash = NULL;
4154         *crash = 0;
4155     }
4156     // TODO: remove this code
4157 */
4158
4159     return result;
4160 }
4161
4162 static wxGtkTreeModelNode*
4163 wxDataViewCtrlInternal_FindParentNode( wxDataViewModel * model, wxGtkTreeModelNode *treeNode, const wxDataViewItem &item )
4164 {
4165     if( model == NULL )
4166         return NULL;
4167
4168     ItemList list;
4169     list.DeleteContents( true );
4170     if( !item.IsOk() )
4171         return NULL;
4172
4173     wxDataViewItem it( model->GetParent( item ) );
4174     while( it.IsOk() )
4175     {
4176         wxDataViewItem * pItem = new wxDataViewItem( it );
4177         list.Insert( pItem );
4178         it = model->GetParent( it );
4179     }
4180
4181     wxGtkTreeModelNode * node = treeNode;
4182     for( ItemList::compatibility_iterator n = list.GetFirst(); n; n = n->GetNext() )
4183     {
4184         if( node && node->GetNodes().GetCount() != 0 )
4185         {
4186             int len = node->GetNodes().GetCount();
4187             wxGtkTreeModelNodes nodes = node->GetNodes();
4188             int j = 0;
4189             for( ; j < len; j ++)
4190             {
4191                 if( nodes[j]->GetItem() == *(n->GetData()))
4192                 {
4193                     node = nodes[j];
4194                     break;
4195                 }
4196             }
4197
4198             if( j == len )
4199             {
4200                 return NULL;
4201             }
4202         }
4203         else
4204             return NULL;
4205     }
4206     //Examine whether the node is item's parent node
4207     int len = node->GetChildCount();
4208     for( int i = 0; i < len ; i ++ )
4209     {
4210         if( node->GetChildren().Item( i ) == item.GetID() )
4211             return node;
4212     }
4213     return NULL;
4214 }
4215
4216 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindParentNode( GtkTreeIter *iter )
4217 {
4218     if (!iter)
4219         return NULL;
4220
4221     wxDataViewItem item( (void*) iter->user_data );
4222     if (!item.IsOk())
4223         return NULL;
4224
4225     return wxDataViewCtrlInternal_FindParentNode( m_wx_model, m_root, item );
4226 }
4227
4228 wxGtkTreeModelNode *wxDataViewCtrlInternal::FindParentNode( const wxDataViewItem &item )
4229 {
4230     if (!item.IsOk())
4231         return NULL;
4232
4233     return wxDataViewCtrlInternal_FindParentNode( m_wx_model, m_root, item );
4234 }
4235
4236 //-----------------------------------------------------------------------------
4237 // wxDataViewCtrl signal callbacks
4238 //-----------------------------------------------------------------------------
4239
4240 static void
4241 wxdataview_selection_changed_callback( GtkTreeSelection* WXUNUSED(selection), wxDataViewCtrl *dv )
4242 {
4243     if (!gtk_widget_get_realized(dv->m_widget))
4244         return;
4245
4246     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, dv->GetId() );
4247     event.SetItem( dv->GetSelection() );
4248     event.SetModel( dv->GetModel() );
4249     dv->HandleWindowEvent( event );
4250 }
4251
4252 static void
4253 wxdataview_row_activated_callback( GtkTreeView* WXUNUSED(treeview), GtkTreePath *path,
4254                                    GtkTreeViewColumn *WXUNUSED(column), wxDataViewCtrl *dv )
4255 {
4256     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, dv->GetId() );
4257
4258     wxDataViewItem item(dv->GTKPathToItem(path));
4259     event.SetItem( item );
4260     event.SetModel( dv->GetModel() );
4261     dv->HandleWindowEvent( event );
4262 }
4263
4264 static gboolean
4265 wxdataview_test_expand_row_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4266                                      GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4267 {
4268     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, dv->GetId() );
4269
4270     wxDataViewItem item( (void*) iter->user_data );;
4271     event.SetItem( item );
4272     event.SetModel( dv->GetModel() );
4273     dv->HandleWindowEvent( event );
4274
4275     return !event.IsAllowed();
4276 }
4277
4278 static void
4279 wxdataview_row_expanded_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4280                                   GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4281 {
4282     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, dv->GetId() );
4283
4284     wxDataViewItem item( (void*) iter->user_data );;
4285     event.SetItem( item );
4286     event.SetModel( dv->GetModel() );
4287     dv->HandleWindowEvent( event );
4288 }
4289
4290 static gboolean
4291 wxdataview_test_collapse_row_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4292                                        GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4293 {
4294     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, dv->GetId() );
4295
4296     wxDataViewItem item( (void*) iter->user_data );;
4297     event.SetItem( item );
4298     event.SetModel( dv->GetModel() );
4299     dv->HandleWindowEvent( event );
4300
4301     return !event.IsAllowed();
4302 }
4303
4304 static void
4305 wxdataview_row_collapsed_callback( GtkTreeView* WXUNUSED(treeview), GtkTreeIter* iter,
4306                                    GtkTreePath *WXUNUSED(path), wxDataViewCtrl *dv )
4307 {
4308     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, dv->GetId() );
4309
4310     wxDataViewItem item( (void*) iter->user_data );;
4311     event.SetItem( item );
4312     event.SetModel( dv->GetModel() );
4313     dv->HandleWindowEvent( event );
4314 }
4315
4316 //-----------------------------------------------------------------------------
4317     // wxDataViewCtrl
4318 //-----------------------------------------------------------------------------
4319
4320 void wxDataViewCtrl::AddChildGTK(wxWindowGTK* child)
4321 {
4322     GtkWidget* treeview = GtkGetTreeView();
4323
4324     // Insert widget in GtkTreeView
4325     if (gtk_widget_get_realized(treeview))
4326         gtk_widget_set_parent_window( child->m_widget,
4327           gtk_tree_view_get_bin_window( GTK_TREE_VIEW(treeview) ) );
4328     gtk_widget_set_parent( child->m_widget, treeview );
4329 }
4330
4331 static
4332 void gtk_dataviewctrl_size_callback( GtkWidget *WXUNUSED(widget),
4333                                      GtkAllocation *WXUNUSED(gtk_alloc),
4334                                      wxDataViewCtrl *win )
4335 {
4336     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
4337     while (node)
4338     {
4339         wxWindow *child = node->GetData();
4340
4341         GtkRequisition req;
4342         gtk_widget_size_request( child->m_widget, &req );
4343
4344         GtkAllocation alloc;
4345         alloc.x = child->m_x;
4346         alloc.y = child->m_y;
4347         alloc.width = child->m_width;
4348         alloc.height = child->m_height;
4349         gtk_widget_size_allocate( child->m_widget, &alloc );
4350
4351         node = node->GetNext();
4352     }
4353 }
4354
4355
4356 //-----------------------------------------------------------------------------
4357 // "motion_notify_event"
4358 //-----------------------------------------------------------------------------
4359
4360 static gboolean
4361 gtk_dataview_motion_notify_callback( GtkWidget *WXUNUSED(widget),
4362                                      GdkEventMotion *gdk_event,
4363                                      wxDataViewCtrl *dv )
4364 {
4365     if (gdk_event->is_hint)
4366     {
4367         int x = 0;
4368         int y = 0;
4369         GdkModifierType state;
4370         gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
4371         gdk_event->x = x;
4372         gdk_event->y = y;
4373     }
4374
4375     wxGtkTreePath path;
4376     GtkTreeViewColumn *column = NULL;
4377     gint cell_x = 0;
4378     gint cell_y = 0;
4379     if (gtk_tree_view_get_path_at_pos(
4380         GTK_TREE_VIEW(dv->GtkGetTreeView()),
4381         (int) gdk_event->x, (int) gdk_event->y,
4382         path.ByRef(),
4383         &column,
4384         &cell_x,
4385         &cell_y))
4386     {
4387         if (path)
4388         {
4389             GtkTreeIter iter;
4390             dv->GtkGetInternal()->get_iter( &iter, path );
4391         }
4392     }
4393
4394
4395     return FALSE;
4396 }
4397
4398 //-----------------------------------------------------------------------------
4399 // "button_press_event"
4400 //-----------------------------------------------------------------------------
4401
4402 static gboolean
4403 gtk_dataview_button_press_callback( GtkWidget *WXUNUSED(widget),
4404                                     GdkEventButton *gdk_event,
4405                                     wxDataViewCtrl *dv )
4406 {
4407     if ((gdk_event->button == 3) && (gdk_event->type == GDK_BUTTON_PRESS))
4408     {
4409         wxGtkTreePath path;
4410         GtkTreeViewColumn *column = NULL;
4411         gint cell_x = 0;
4412         gint cell_y = 0;
4413         gtk_tree_view_get_path_at_pos
4414         (
4415             GTK_TREE_VIEW(dv->GtkGetTreeView()),
4416             (int) gdk_event->x, (int) gdk_event->y,
4417             path.ByRef(),
4418             &column,
4419             &cell_x,
4420             &cell_y
4421         );
4422
4423         wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, dv->GetId() );
4424         if (path)
4425             event.SetItem(dv->GTKPathToItem(path));
4426         event.SetModel( dv->GetModel() );
4427         return dv->HandleWindowEvent( event );
4428     }
4429
4430     return FALSE;
4431 }
4432
4433 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
4434
4435 wxDataViewCtrl::~wxDataViewCtrl()
4436 {
4437     // Stop editing before destroying the control to remove any event handlers
4438     // which are added when editing started: if we didn't do this, the base
4439     // class dtor would assert as it checks for any leftover handlers.
4440     if ( m_treeview )
4441     {
4442         GtkTreeViewColumn *col;
4443         gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), NULL, &col);
4444
4445         wxDataViewColumn * const wxcol = FromGTKColumn(col);
4446         if ( wxcol )
4447         {
4448             // This won't do anything if we're not editing it
4449             wxcol->GetRenderer()->CancelEditing();
4450         }
4451     }
4452
4453     m_cols.Clear();
4454
4455     delete m_internal;
4456 }
4457
4458 void wxDataViewCtrl::Init()
4459 {
4460     m_internal = NULL;
4461
4462     m_cols.DeleteContents( true );
4463
4464     m_uniformRowHeight = -1;
4465 }
4466
4467 bool wxDataViewCtrl::Create(wxWindow *parent,
4468                             wxWindowID id,
4469                             const wxPoint& pos,
4470                             const wxSize& size,
4471                             long style,
4472                             const wxValidator& validator,
4473                             const wxString& name)
4474 {
4475     if (!PreCreation( parent, pos, size ) ||
4476         !CreateBase( parent, id, pos, size, style, validator, name ))
4477     {
4478         wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
4479         return false;
4480     }
4481
4482     m_widget = gtk_scrolled_window_new (NULL, NULL);
4483     g_object_ref(m_widget);
4484
4485     GTKScrolledWindowSetBorder(m_widget, style);
4486
4487     m_treeview = gtk_tree_view_new();
4488     gtk_container_add (GTK_CONTAINER (m_widget), m_treeview);
4489
4490     m_focusWidget = GTK_WIDGET(m_treeview);
4491
4492     g_signal_connect (m_treeview, "size_allocate",
4493                      G_CALLBACK (gtk_dataviewctrl_size_callback), this);
4494
4495 #ifdef __WXGTK26__
4496     if (!gtk_check_version(2,6,0))
4497     {
4498         bool fixed = (style & wxDV_VARIABLE_LINE_HEIGHT) == 0;
4499         gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), fixed );
4500     }
4501 #endif
4502
4503     if (style & wxDV_MULTIPLE)
4504     {
4505         GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4506         gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
4507     }
4508
4509     gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(m_treeview), (style & wxDV_NO_HEADER) == 0 );
4510
4511 #ifdef __WXGTK210__
4512     if (!gtk_check_version(2,10,0))
4513     {
4514         GtkTreeViewGridLines grid = GTK_TREE_VIEW_GRID_LINES_NONE;
4515
4516         if ((style & wxDV_HORIZ_RULES) != 0 &&
4517             (style & wxDV_VERT_RULES) != 0)
4518             grid = GTK_TREE_VIEW_GRID_LINES_BOTH;
4519         else if (style & wxDV_VERT_RULES)
4520             grid = GTK_TREE_VIEW_GRID_LINES_VERTICAL;
4521         else if (style & wxDV_HORIZ_RULES)
4522             grid = GTK_TREE_VIEW_GRID_LINES_HORIZONTAL;
4523
4524         if (grid != GTK_TREE_VIEW_GRID_LINES_NONE)
4525             gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(m_treeview), grid );
4526     }
4527 #endif
4528
4529     gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(m_treeview), (style & wxDV_ROW_LINES) != 0 );
4530
4531     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (m_widget),
4532         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
4533     gtk_widget_show (m_treeview);
4534
4535     m_parent->DoAddChild( this );
4536
4537     PostCreation(size);
4538
4539     GtkEnableSelectionEvents();
4540
4541     g_signal_connect_after (m_treeview, "row-activated",
4542                             G_CALLBACK (wxdataview_row_activated_callback), this);
4543
4544     g_signal_connect (m_treeview, "test-collapse-row",
4545                             G_CALLBACK (wxdataview_test_collapse_row_callback), this);
4546
4547     g_signal_connect_after (m_treeview, "row-collapsed",
4548                             G_CALLBACK (wxdataview_row_collapsed_callback), this);
4549
4550     g_signal_connect (m_treeview, "test-expand-row",
4551                             G_CALLBACK (wxdataview_test_expand_row_callback), this);
4552
4553     g_signal_connect_after (m_treeview, "row-expanded",
4554                             G_CALLBACK (wxdataview_row_expanded_callback), this);
4555
4556     g_signal_connect (m_treeview, "motion_notify_event",
4557                       G_CALLBACK (gtk_dataview_motion_notify_callback), this);
4558
4559     g_signal_connect (m_treeview, "button_press_event",
4560                       G_CALLBACK (gtk_dataview_button_press_callback), this);
4561
4562     return true;
4563 }
4564
4565 wxDataViewItem wxDataViewCtrl::GTKPathToItem(GtkTreePath *path) const
4566 {
4567     GtkTreeIter iter;
4568     return wxDataViewItem(path && m_internal->get_iter(&iter, path)
4569                             ? iter.user_data
4570                             : NULL);
4571 }
4572
4573 void wxDataViewCtrl::OnInternalIdle()
4574 {
4575     wxWindow::OnInternalIdle();
4576
4577     m_internal->OnInternalIdle();
4578
4579     unsigned int cols = GetColumnCount();
4580     unsigned int i;
4581     for (i = 0; i < cols; i++)
4582     {
4583         wxDataViewColumn *col = GetColumn( i );
4584         col->OnInternalIdle();
4585     }
4586
4587     if (m_ensureVisibleDefered.IsOk())
4588     {
4589         ExpandAncestors(m_ensureVisibleDefered);
4590         GtkTreeIter iter;
4591         iter.user_data = (gpointer) m_ensureVisibleDefered.GetID();
4592         wxGtkTreePath path(m_internal->get_path( &iter ));
4593         gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview), path, NULL, false, 0.0, 0.0 );
4594         m_ensureVisibleDefered = wxDataViewItem(0);
4595     }
4596 }
4597
4598 bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
4599 {
4600     wxDELETE(m_internal);
4601
4602     if (!wxDataViewCtrlBase::AssociateModel( model ))
4603         return false;
4604
4605 #ifdef __WXGTK26__
4606     if (!gtk_check_version(2,6,0))
4607     {
4608         bool fixed = (((GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) == 0) || (model->IsVirtualListModel()));
4609         gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), fixed );
4610     }
4611 #endif
4612
4613     m_internal = new wxDataViewCtrlInternal( this, model );
4614
4615     return true;
4616 }
4617
4618 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat &format )
4619 {
4620     return m_internal->EnableDragSource( format );
4621 }
4622
4623 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat &format )
4624 {
4625     return m_internal->EnableDropTarget( format );
4626 }
4627
4628 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
4629 {
4630     if (!wxDataViewCtrlBase::AppendColumn(col))
4631         return false;
4632
4633     m_cols.Append( col );
4634
4635 #ifdef __WXGTK26__
4636     if (!gtk_check_version(2,6,0))
4637     {
4638         if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4639                GTK_TREE_VIEW_COLUMN_FIXED)
4640            gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4641     }
4642 #endif
4643
4644     gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview),
4645                                  GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
4646
4647     return true;
4648 }
4649
4650 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
4651 {
4652     if (!wxDataViewCtrlBase::PrependColumn(col))
4653         return false;
4654
4655     m_cols.Insert( col );
4656
4657 #ifdef __WXGTK26__
4658     if (!gtk_check_version(2,6,0))
4659     {
4660         if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4661                GTK_TREE_VIEW_COLUMN_FIXED)
4662            gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4663     }
4664 #endif
4665
4666     gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
4667                                  GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), 0 );
4668
4669     return true;
4670 }
4671
4672 bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
4673 {
4674     if (!wxDataViewCtrlBase::InsertColumn(pos,col))
4675         return false;
4676
4677     m_cols.Insert( pos, col );
4678
4679 #ifdef __WXGTK26__
4680     if (!gtk_check_version(2,6,0))
4681     {
4682         if (gtk_tree_view_column_get_sizing( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) ) !=
4683                GTK_TREE_VIEW_COLUMN_FIXED)
4684            gtk_tree_view_set_fixed_height_mode( GTK_TREE_VIEW(m_treeview), FALSE );
4685     }
4686 #endif
4687
4688     gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
4689                                  GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), pos );
4690
4691     return true;
4692 }
4693
4694 unsigned int wxDataViewCtrl::GetColumnCount() const
4695 {
4696     return m_cols.GetCount();
4697 }
4698
4699 wxDataViewColumn* wxDataViewCtrl::FromGTKColumn(GtkTreeViewColumn *gtk_col) const
4700 {
4701     if ( !gtk_col )
4702         return NULL;
4703
4704     wxDataViewColumnList::const_iterator iter;
4705     for (iter = m_cols.begin(); iter != m_cols.end(); ++iter)
4706     {
4707         wxDataViewColumn *col = *iter;
4708         if (GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == gtk_col)
4709         {
4710             return col;
4711         }
4712     }
4713
4714     wxFAIL_MSG( "No matching column?" );
4715
4716     return NULL;
4717 }
4718
4719 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int pos ) const
4720 {
4721     GtkTreeViewColumn *gtk_col = gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview), pos );
4722
4723     return FromGTKColumn(gtk_col);
4724 }
4725
4726 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
4727 {
4728     gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
4729                                  GTK_TREE_VIEW_COLUMN(column->GetGtkHandle()) );
4730
4731     m_cols.DeleteObject( column );
4732
4733     return true;
4734 }
4735
4736 bool wxDataViewCtrl::ClearColumns()
4737 {
4738     wxDataViewColumnList::iterator iter;
4739     for (iter = m_cols.begin(); iter != m_cols.end(); ++iter)
4740     {
4741         wxDataViewColumn *col = *iter;
4742         gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
4743                                      GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
4744     }
4745
4746     m_cols.Clear();
4747
4748     return true;
4749 }
4750
4751 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
4752 {
4753     GtkTreeViewColumn *gtk_column = GTK_TREE_VIEW_COLUMN(column->GetGtkHandle());
4754
4755     wxGtkList list(gtk_tree_view_get_columns(GTK_TREE_VIEW(m_treeview)));
4756
4757     return g_list_index( list, (gconstpointer)  gtk_column );
4758 }
4759
4760 wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
4761 {
4762     return m_internal->GetDataViewSortColumn();
4763 }
4764
4765 void wxDataViewCtrl::Expand( const wxDataViewItem & item )
4766 {
4767     GtkTreeIter iter;
4768     iter.user_data = item.GetID();
4769     wxGtkTreePath path(m_internal->get_path( &iter ));
4770     gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview), path, false );
4771 }
4772
4773 void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
4774 {
4775     GtkTreeIter iter;
4776     iter.user_data = item.GetID();
4777     wxGtkTreePath path(m_internal->get_path( &iter ));
4778     gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview), path );
4779 }
4780
4781 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const
4782 {
4783     GtkTreeIter iter;
4784     iter.user_data = item.GetID();
4785     wxGtkTreePath path(m_internal->get_path( &iter ));
4786     return gtk_tree_view_row_expanded( GTK_TREE_VIEW(m_treeview), path );
4787 }
4788
4789 wxDataViewItem wxDataViewCtrl::DoGetCurrentItem() const
4790 {
4791     // The tree doesn't have any current item if it hadn't been created yet but
4792     // it's arguably not an error to call this function in this case so just
4793     // return an invalid item without asserting.
4794     if ( !m_treeview )
4795         return wxDataViewItem();
4796
4797     wxGtkTreePath path;
4798     gtk_tree_view_get_cursor(GTK_TREE_VIEW(m_treeview), path.ByRef(), NULL);
4799
4800     return GTKPathToItem(path);
4801 }
4802
4803 void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem& item)
4804 {
4805     wxCHECK_RET( m_treeview,
4806                  "Current item can't be set before creating the control." );
4807
4808     // We need to make sure the model knows about this item or the path would
4809     // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4810     ExpandAncestors(item);
4811
4812     // We also need to preserve the existing selection from changing.
4813     // Unfortunately the only way to do it seems to use our own selection
4814     // function and forbid any selection changes during set cursor call.
4815     wxGtkTreeSelectionLock
4816         lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview)));
4817
4818     // Do move the cursor now.
4819     GtkTreeIter iter;
4820     iter.user_data = item.GetID();
4821     wxGtkTreePath path(m_internal->get_path( &iter ));
4822
4823     gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview), path, NULL, FALSE);
4824 }
4825
4826 void wxDataViewCtrl::StartEditor(const wxDataViewItem& item, unsigned int column)
4827 {
4828     wxCHECK_RET( m_treeview,
4829                  "Current item can't be set before creating the control." );
4830
4831     // We need to make sure the model knows about this item or the path would
4832     // be invalid and gtk_tree_view_set_cursor() would silently do nothing.
4833     ExpandAncestors(item);
4834
4835     wxDataViewColumn *dvcolumn = GetColumn(column);
4836     wxASSERT_MSG(dvcolumn, "Could not retrieve column");
4837     GtkTreeViewColumn *gcolumn = GTK_TREE_VIEW_COLUMN(dvcolumn->GetGtkHandle());
4838
4839     // We also need to preserve the existing selection from changing.
4840     // Unfortunately the only way to do it seems to use our own selection
4841     // function and forbid any selection changes during set cursor call.
4842     wxGtkTreeSelectionLock
4843         lock(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_treeview)));
4844
4845     // Do move the cursor now.
4846     GtkTreeIter iter;
4847     iter.user_data = item.GetID();
4848     wxGtkTreePath path(m_internal->get_path( &iter ));
4849
4850     gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_treeview), path, gcolumn, TRUE);
4851 }
4852
4853 int wxDataViewCtrl::GetSelectedItemsCount() const
4854 {
4855     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4856
4857     return gtk_tree_selection_count_selected_rows(selection);
4858 }
4859
4860 int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const
4861 {
4862     sel.Clear();
4863
4864     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4865     if (HasFlag(wxDV_MULTIPLE))
4866     {
4867         GtkTreeModel *model;
4868         wxGtkTreePathList list(gtk_tree_selection_get_selected_rows(selection, &model));
4869
4870         for ( GList* current = list; current; current = g_list_next(current) )
4871         {
4872             GtkTreePath *path = (GtkTreePath*) current->data;
4873
4874             sel.Add(GTKPathToItem(path));
4875         }
4876     }
4877     else
4878     {
4879         GtkTreeIter iter;
4880         if (gtk_tree_selection_get_selected( selection, NULL, &iter ))
4881         {
4882             sel.Add( wxDataViewItem(iter.user_data) );
4883         }
4884     }
4885
4886     return sel.size();
4887 }
4888
4889 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel )
4890 {
4891     GtkDisableSelectionEvents();
4892
4893     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4894
4895     gtk_tree_selection_unselect_all( selection );
4896
4897     wxDataViewItem last_parent;
4898
4899     size_t i;
4900     for (i = 0; i < sel.GetCount(); i++)
4901     {
4902         wxDataViewItem item = sel[i];
4903         wxDataViewItem parent = GetModel()->GetParent( item );
4904         if (parent)
4905         {
4906             if (parent != last_parent)
4907                 ExpandAncestors(item);
4908         }
4909         last_parent = parent;
4910
4911         GtkTreeIter iter;
4912         iter.stamp = m_internal->GetGtkModel()->stamp;
4913         iter.user_data = (gpointer) item.GetID();
4914         gtk_tree_selection_select_iter( selection, &iter );
4915     }
4916
4917     GtkEnableSelectionEvents();
4918 }
4919
4920 void wxDataViewCtrl::Select( const wxDataViewItem & item )
4921 {
4922     ExpandAncestors(item);
4923
4924     GtkDisableSelectionEvents();
4925
4926     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4927
4928     GtkTreeIter iter;
4929     iter.stamp = m_internal->GetGtkModel()->stamp;
4930     iter.user_data = (gpointer) item.GetID();
4931     gtk_tree_selection_select_iter( selection, &iter );
4932
4933     GtkEnableSelectionEvents();
4934 }
4935
4936 void wxDataViewCtrl::Unselect( const wxDataViewItem & item )
4937 {
4938     GtkDisableSelectionEvents();
4939
4940     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4941
4942     GtkTreeIter iter;
4943     iter.stamp = m_internal->GetGtkModel()->stamp;
4944     iter.user_data = (gpointer) item.GetID();
4945     gtk_tree_selection_unselect_iter( selection, &iter );
4946
4947     GtkEnableSelectionEvents();
4948 }
4949
4950 bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const
4951 {
4952     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4953
4954     GtkTreeIter iter;
4955     iter.stamp = m_internal->GetGtkModel()->stamp;
4956     iter.user_data = (gpointer) item.GetID();
4957
4958     return gtk_tree_selection_iter_is_selected( selection, &iter );
4959 }
4960
4961 void wxDataViewCtrl::SelectAll()
4962 {
4963     GtkDisableSelectionEvents();
4964
4965     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4966
4967     gtk_tree_selection_select_all( selection );
4968
4969     GtkEnableSelectionEvents();
4970 }
4971
4972 void wxDataViewCtrl::UnselectAll()
4973 {
4974     GtkDisableSelectionEvents();
4975
4976     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
4977
4978     gtk_tree_selection_unselect_all( selection );
4979
4980     GtkEnableSelectionEvents();
4981 }
4982
4983 void wxDataViewCtrl::EnsureVisible(const wxDataViewItem& item,
4984                                    const wxDataViewColumn *WXUNUSED(column))
4985 {
4986     m_ensureVisibleDefered = item;
4987     ExpandAncestors(item);
4988
4989     GtkTreeIter iter;
4990     iter.user_data = (gpointer) item.GetID();
4991     wxGtkTreePath path(m_internal->get_path( &iter ));
4992     gtk_tree_view_scroll_to_cell( GTK_TREE_VIEW(m_treeview), path, NULL, false, 0.0, 0.0 );
4993 }
4994
4995 void wxDataViewCtrl::HitTest(const wxPoint& point,
4996                              wxDataViewItem& item,
4997                              wxDataViewColumn *& column) const
4998 {
4999     // gtk_tree_view_get_dest_row_at_pos() is the right one. But it does not tell the column.
5000     // gtk_tree_view_get_path_at_pos() is the wrong function. It doesn't mind the header but returns column.
5001     // See http://mail.gnome.org/archives/gtkmm-list/2005-January/msg00080.html
5002     // So we have to use both of them.
5003     // Friedrich Haase 2010-9-20
5004     wxGtkTreePath path, pathScratch;
5005     GtkTreeViewColumn* GtkColumn = NULL;
5006     GtkTreeViewDropPosition pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
5007     gint cell_x = 0;
5008     gint cell_y = 0;
5009
5010     // cannot directly call GtkGetTreeView(), HitTest is const and so is this pointer
5011     wxDataViewCtrl* ctrl = (wxDataViewCtrl*)this; // ugly workaround, ctrl is NOT const
5012     GtkTreeView* treeView = GTK_TREE_VIEW(ctrl->GtkGetTreeView());
5013
5014     // is there possibly a better suited function to get the column?
5015     gtk_tree_view_get_path_at_pos(                // and this is the wrong call but it delivers the column
5016       treeView,
5017       (int) point.x, (int) point.y,
5018       pathScratch.ByRef(),
5019       &GtkColumn,                                 // here we get the GtkColumn
5020       &cell_x,
5021       &cell_y );
5022
5023     if ( GtkColumn != NULL )
5024     {
5025         // we got GTK column
5026         // the right call now which takes the header into account
5027         gtk_tree_view_get_dest_row_at_pos( treeView, (int) point.x, (int) point.y, path.ByRef(), &pos);
5028
5029         if (path)
5030             item = wxDataViewItem(GTKPathToItem(path));
5031         // else we got a GTK column but the position is not over an item, e.g. below last item
5032         for ( unsigned int i=0, cols=GetColumnCount(); i<cols; ++i )  // search the wx column
5033         {
5034             wxDataViewColumn* col = GetColumn(i);
5035             if ( GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == GtkColumn )
5036             {
5037                 column = col;                      // here we get the wx column
5038                 break;
5039             }
5040         }
5041     }
5042     // else no column and thus no item, both null
5043 }
5044
5045 wxRect
5046 wxDataViewCtrl::GetItemRect(const wxDataViewItem& WXUNUSED(item),
5047                             const wxDataViewColumn *WXUNUSED(column)) const
5048 {
5049     return wxRect();
5050 }
5051
5052 bool wxDataViewCtrl::SetRowHeight(int rowHeight)
5053 {
5054     m_uniformRowHeight = rowHeight;
5055     return true;
5056 }
5057
5058 void wxDataViewCtrl::DoSetExpanderColumn()
5059 {
5060     gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview),
5061         GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
5062 }
5063
5064 void wxDataViewCtrl::DoSetIndent()
5065 {
5066 }
5067
5068 void wxDataViewCtrl::GtkDisableSelectionEvents()
5069 {
5070     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5071     g_signal_handlers_disconnect_by_func( selection,
5072                             (gpointer) (wxdataview_selection_changed_callback), this);
5073 }
5074
5075 void wxDataViewCtrl::GtkEnableSelectionEvents()
5076 {
5077     GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
5078     g_signal_connect_after (selection, "changed",
5079                             G_CALLBACK (wxdataview_selection_changed_callback), this);
5080 }
5081
5082 // ----------------------------------------------------------------------------
5083 // visual attributes stuff
5084 // ----------------------------------------------------------------------------
5085
5086 // static
5087 wxVisualAttributes
5088 wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
5089 {
5090     return GetDefaultAttributesFromGTKWidget(gtk_tree_view_new);
5091 }
5092
5093 void wxDataViewCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
5094 {
5095     wxDataViewCtrlBase::DoApplyWidgetStyle(style);
5096     gtk_widget_modify_style(m_treeview, style);
5097 }
5098
5099 #endif // !wxUSE_GENERICDATAVIEWCTRL
5100
5101 #endif // wxUSE_DATAVIEWCTRL