src/gtk/dataview.cpp

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