[wxWidgets.git] / src / gtk / dataview.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dataview.cpp
// Purpose:     wxDataViewCtrl GTK+2 implementation
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/defs.h"

#if wxUSE_DATAVIEWCTRL

#include "wx/dataview.h"
#include "wx/stockitem.h"

#include "wx/gtk/private.h"
#include "wx/gtk/win_gtk.h"

#include <gobject/gvaluecollector.h>
#include <gtk/gtktreemodel.h>
#include <gtk/gtktreednd.h>

//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------

class wxDataViewCtrl;

//-----------------------------------------------------------------------------
// idle system
//-----------------------------------------------------------------------------

extern void wxapp_install_idle_handler();
extern bool g_isIdle;

//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------

extern bool   g_blockEventsOnDrag;

//-----------------------------------------------------------------------------
// define new GTK+ class wxGtkListStore
//-----------------------------------------------------------------------------

extern "C" {

#define GTK_TYPE_WX_LIST_STORE               (gtk_wx_list_store_get_type ())
#define GTK_WX_LIST_STORE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_LIST_STORE, GtkWxListStore))
#define GTK_WX_LIST_STORE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_LIST_STORE, GtkWxListStoreClass))
#define GTK_IS_WX_LIST_STORE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_LIST_STORE))
#define GTK_IS_WX_LIST_STORE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_LIST_STORE))
#define GTK_WX_LIST_STORE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_LIST_STORE, GtkWxListStoreClass))

GType         gtk_wx_list_store_get_type         (void);

typedef struct _GtkWxListStore       GtkWxListStore;
typedef struct _GtkWxListStoreClass  GtkWxListStoreClass;

struct _GtkWxListStore
{
  GObject parent;

  /*< private >*/
  gint stamp;
  wxDataViewListModel *model;
};

struct _GtkWxListStoreClass
{
  GObjectClass parent_class;
  
};

static GtkWxListStore *wxgtk_list_store_new          ();
static void         wxgtk_list_store_init            (GtkWxListStore      *list_store);
static void         wxgtk_list_store_class_init      (GtkWxListStoreClass *klass);
static void         wxgtk_list_store_tree_model_init (GtkTreeModelIface *iface);
static void         wxgtk_list_store_finalize        (GObject           *object);
static GtkTreeModelFlags wxgtk_list_store_get_flags  (GtkTreeModel      *tree_model);
static gint         wxgtk_list_store_get_n_columns   (GtkTreeModel      *tree_model);
static GType        wxgtk_list_store_get_column_type (GtkTreeModel      *tree_model,
						    gint               index);
static gboolean     wxgtk_list_store_get_iter        (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter,
						    GtkTreePath       *path);
static GtkTreePath *wxgtk_list_store_get_path        (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter);
static void         wxgtk_list_store_get_value       (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter,
						    gint               column,
						    GValue            *value);
static gboolean     wxgtk_list_store_iter_next       (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter);
static gboolean     wxgtk_list_store_iter_children   (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter,
						    GtkTreeIter       *parent);
static gboolean     wxgtk_list_store_iter_has_child  (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter);
static gint         wxgtk_list_store_iter_n_children (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter);
static gboolean     wxgtk_list_store_iter_nth_child  (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter,
						    GtkTreeIter       *parent,
						    gint               n);
static gboolean     wxgtk_list_store_iter_parent     (GtkTreeModel      *tree_model,
						    GtkTreeIter       *iter,
						    GtkTreeIter       *child);

static GObjectClass *parent_class = NULL;

GType
gtk_wx_list_store_get_type (void)
{
  static GType list_store_type = 0;

  if (!list_store_type)
    {
      static const GTypeInfo list_store_info =
      {
	sizeof (GtkWxListStoreClass),
	NULL,		/* base_init */
	NULL,		/* base_finalize */
        (GClassInitFunc) wxgtk_list_store_class_init,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
        sizeof (GtkWxListStore),
	0,
        (GInstanceInitFunc) wxgtk_list_store_init,
      };

      static const GInterfaceInfo tree_model_info =
      {
	(GInterfaceInitFunc) wxgtk_list_store_tree_model_init,
	NULL,
	NULL
      };

      list_store_type = g_type_register_static (G_TYPE_OBJECT, "GtkWxListStore",
						&list_store_info, (GTypeFlags)0 );

      g_type_add_interface_static (list_store_type,
				   GTK_TYPE_TREE_MODEL,
				   &tree_model_info);
    }

  return list_store_type;
}

static GtkWxListStore *
wxgtk_list_store_new()
{
  GtkWxListStore *retval = (GtkWxListStore *) g_object_new (GTK_TYPE_WX_LIST_STORE, NULL);
  return retval;
}

static void
wxgtk_list_store_class_init (GtkWxListStoreClass *klass)
{
    GObjectClass *object_class;
    parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
    object_class = (GObjectClass*) klass;
    object_class->finalize = wxgtk_list_store_finalize;
}

static void
wxgtk_list_store_tree_model_init (GtkTreeModelIface *iface)
{
    iface->get_flags = wxgtk_list_store_get_flags;
    iface->get_n_columns = wxgtk_list_store_get_n_columns;
    iface->get_column_type = wxgtk_list_store_get_column_type;
    iface->get_iter = wxgtk_list_store_get_iter;
    iface->get_path = wxgtk_list_store_get_path;
    iface->get_value = wxgtk_list_store_get_value;
    iface->iter_next = wxgtk_list_store_iter_next;
    iface->iter_children = wxgtk_list_store_iter_children;
    iface->iter_has_child = wxgtk_list_store_iter_has_child;
    iface->iter_n_children = wxgtk_list_store_iter_n_children;
    iface->iter_nth_child = wxgtk_list_store_iter_nth_child;
    iface->iter_parent = wxgtk_list_store_iter_parent;
}

static void
wxgtk_list_store_init (GtkWxListStore *list_store)
{
    list_store->model = NULL;
    list_store->stamp = g_random_int();
}

static void
wxgtk_list_store_finalize (GObject *object)
{
    /* GtkWxListStore *list_store = GTK_WX_LIST_STORE (object); */

    /* we need to sort out, which class deletes what */
    /* delete list_store->model; */

    /* must chain up */
    (* parent_class->finalize) (object);
}
                        
} // extern "C"

//-----------------------------------------------------------------------------
// implement callbacks from wxGtkListStore class by letting
// them call the methods of wxWidgets' wxDataViewListModel
//-----------------------------------------------------------------------------

static GtkTreeModelFlags
wxgtk_list_store_get_flags (GtkTreeModel *tree_model)
{
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), (GtkTreeModelFlags)0 );

    // GTK+ list store uses a linked list for storing the
    // items and a pointer to a child is used as the member
    // field of a GtkTreeIter. This means that the iter is
    // valid in the GtkListStore as long as the child exists.
    // We use the index of the row and since the index of a
    // specific row will change if a row above is deleted,
    // the iter does not persist
    return /* GTK_TREE_MODEL_ITERS_PERSIST | */ GTK_TREE_MODEL_LIST_ONLY;
}

static gint
wxgtk_list_store_get_n_columns (GtkTreeModel *tree_model)
{
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), 0);

    return list_store->model->GetNumberOfCols();
}

static GType
wxgtk_list_store_get_column_type (GtkTreeModel *tree_model,
				gint          index)
{
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), G_TYPE_INVALID);

    GType gtype = G_TYPE_INVALID;
    
    wxString wxtype = list_store->model->GetColType( (size_t) index );
    
    if (wxtype == wxT("string"))
        gtype = G_TYPE_STRING;

    return gtype;
}

static gboolean
wxgtk_list_store_get_iter (GtkTreeModel *tree_model,
			 GtkTreeIter  *iter,
			 GtkTreePath  *path)
{
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
    g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);

    size_t i = (size_t)gtk_tree_path_get_indices (path)[0];

    if (i >= list_store->model->GetNumberOfRows())
        return FALSE;

    iter->stamp = list_store->stamp;
    // user_data is just the index
    iter->user_data = (gpointer) i;

    return TRUE;
}

static GtkTreePath *
wxgtk_list_store_get_path (GtkTreeModel *tree_model,
			 GtkTreeIter  *iter)
{
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), NULL);
    g_return_val_if_fail (iter->stamp == GTK_WX_LIST_STORE (tree_model)->stamp, NULL);
  
    GtkTreePath *retval = gtk_tree_path_new ();
    // user_data is just the index
    int i = (int) iter->user_data;
    gtk_tree_path_append_index (retval, i);
    return retval;
}

static void
wxgtk_list_store_get_value (GtkTreeModel *tree_model,
			  GtkTreeIter  *iter,
			  gint          column,
			  GValue       *value)
{
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    g_return_if_fail (GTK_IS_WX_LIST_STORE (tree_model) );

    wxDataViewListModel *model = list_store->model;
    wxString mtype = model->GetColType( (size_t) column );
    if (mtype == wxT("string"))
    {
        g_value_init( value, G_TYPE_STRING );
        wxVariant variant = model->GetValue( (size_t) column, (size_t) iter->user_data );
        g_value_set_string( value, wxGTK_CONV(variant.GetString()) );
    }
    else
    {
    }
    
#if 0
  GtkTreeDataList *list;
  gint tmp_column = column;

  g_return_if_fail (column < GTK_LIST_STORE (tree_model)->n_columns);
  g_return_if_fail (GTK_LIST_STORE (tree_model)->stamp == iter->stamp);

  list = G_SLIST (iter->user_data)->data;

  while (tmp_column-- > 0 && list)
    list = list->next;

  if (list == NULL)
    g_value_init (value, GTK_LIST_STORE (tree_model)->column_headers[column]);
  else
    _gtk_tree_data_list_node_to_value (list,
				       GTK_LIST_STORE (tree_model)->column_headers[column],
				       value);
#endif

}

static gboolean
wxgtk_list_store_iter_next (GtkTreeModel  *tree_model,
			  GtkTreeIter   *iter)
{
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    
    g_return_val_if_fail (list_store->stamp == iter->stamp, FALSE);

    int n = (int) iter->user_data;
    
    if (n == -1)
        return FALSE;
        
    if (n >= (int) list_store->model->GetNumberOfRows())
        return FALSE;
        
    iter->user_data = (gpointer) ++n;

    return TRUE;
}

static gboolean
wxgtk_list_store_iter_children (GtkTreeModel *tree_model,
			      GtkTreeIter  *iter,
			      GtkTreeIter  *parent)
{
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    
    // this is a list, nodes have no children
    if (parent)
        return FALSE;

    iter->stamp = list_store->stamp;
    iter->user_data = (gpointer) -1;
    
    return TRUE;
}

static gboolean
wxgtk_list_store_iter_has_child (GtkTreeModel *tree_model,
			       GtkTreeIter  *iter)
{
    return FALSE;
}

static gint
wxgtk_list_store_iter_n_children (GtkTreeModel *tree_model,
				GtkTreeIter  *iter)
{
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), -1);
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    
    if (iter == NULL)
        return (gint) list_store->model->GetNumberOfRows();

    g_return_val_if_fail (list_store->stamp == iter->stamp, -1);
  
    return 0;
}

static gboolean
wxgtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
			       GtkTreeIter  *iter,
			       GtkTreeIter  *parent,
			       gint          n)
{
    g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
    GtkWxListStore *list_store = (GtkWxListStore *) tree_model;
    
    if (parent)
        return FALSE;

    if (n < 0)
        return FALSE;
        
    if (n >= (gint) list_store->model->GetNumberOfRows())
        return FALSE;

    iter->stamp = list_store->stamp;
    iter->user_data = (gpointer) n;
    
    return TRUE;
}

static gboolean
wxgtk_list_store_iter_parent (GtkTreeModel *tree_model,
			    GtkTreeIter  *iter,
			    GtkTreeIter  *child)
{
    return FALSE;
}

// --------------------------------------------------------- 
// wxGtkDataViewListModelNotifier
// --------------------------------------------------------- 

class wxGtkDataViewListModelNotifier: public wxDataViewListModelNotifier
{
public:
    wxGtkDataViewListModelNotifier( GtkWxListStore* gtk_store, wxDataViewListModel *wx_model );
    
    virtual bool RowAppended();
    virtual bool RowPrepended();
    virtual bool RowInserted( size_t before );
    virtual bool RowDeleted( size_t row );
    virtual bool RowChanged( size_t row );
    virtual bool ValueChanged( size_t row, size_t col );
    virtual bool Cleared();
    
    GtkWxListStore      *m_gtk_store;
    wxDataViewListModel *m_wx_model;
};

// --------------------------------------------------------- 
// wxGtkDataViewListModelNotifier
// --------------------------------------------------------- 

wxGtkDataViewListModelNotifier::wxGtkDataViewListModelNotifier( 
    GtkWxListStore* gtk_store, wxDataViewListModel *wx_model )
{
    m_gtk_store = gtk_store;
    m_wx_model = wx_model;
}
    
bool wxGtkDataViewListModelNotifier::RowAppended()
{
    size_t pos = m_wx_model->GetNumberOfRows()-1;
    
    GtkTreeIter iter;
    iter.stamp = m_gtk_store->stamp;
    iter.user_data = (gpointer) pos;
    
    GtkTreePath *path = gtk_tree_path_new ();
    gtk_tree_path_append_index (path, (gint) pos);
    gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
    gtk_tree_path_free (path);
    
    return true;
}

bool wxGtkDataViewListModelNotifier::RowPrepended()
{
    return false;
}

bool wxGtkDataViewListModelNotifier::RowInserted( size_t before )
{
    return false;
}

bool wxGtkDataViewListModelNotifier::RowDeleted( size_t row )
{
    return false;
}

bool wxGtkDataViewListModelNotifier::RowChanged( size_t row )
{
    return false;
}

bool wxGtkDataViewListModelNotifier::ValueChanged( size_t row, size_t col )
{
    return false;
}

bool wxGtkDataViewListModelNotifier::Cleared()
{
    return false;
}


// --------------------------------------------------------- 
// wxDataViewColumn
// --------------------------------------------------------- 

IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)

wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCtrl *ctrl, 
            wxDataViewColumnType kind, int flags ) :
    wxDataViewColumnBase( title, ctrl, kind, flags )
{
    GtkCellRenderer *renderer = NULL;
    
    if (kind == wxDATAVIEW_COL_TEXT)
    {
        renderer = gtk_cell_renderer_text_new();
    } else
    if (kind == wxDATAVIEW_COL_CHECK)
    {
        renderer = gtk_cell_renderer_toggle_new();
    } else
    if (kind == wxDATAVIEW_COL_ICON)
    {
        renderer = gtk_cell_renderer_pixbuf_new();
    }
    else
        return;

    GtkTreeViewColumn *column = 
        gtk_tree_view_column_new_with_attributes( wxGTK_CONV(title), renderer, "text", 0, NULL );
       
    // bind to data here... not above.
    
    m_column = (void*) column;
}

wxDataViewColumn::~wxDataViewColumn()
{
}

void wxDataViewColumn::SetTitle( const wxString &title )
{
    wxDataViewColumnBase::SetTitle( title );
    
    GtkTreeViewColumn *column = (GtkTreeViewColumn *)m_column;
    gtk_tree_view_column_set_title( column, wxGTK_CONV(title) );
}

//-----------------------------------------------------------------------------
// wxDataViewCtrl
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)

wxDataViewCtrl::~wxDataViewCtrl()
{
}

void wxDataViewCtrl::Init()
{
}

bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
           const wxPoint& pos, const wxSize& size, 
           long style, const wxValidator& validator )
{
    Init();
    
    m_needParent = TRUE;
    m_acceptsFocus = TRUE;

    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, validator ))
    {
        wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
        return FALSE;
    }
    
    m_widget = gtk_tree_view_new();
    
    m_parent->DoAddChild( this );

    PostCreation(size);

    return true;
}

bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
{
    if (!wxDataViewCtrlBase::AssociateModel( model ))
        return false;

    GtkWxListStore *gtk_store = wxgtk_list_store_new();
    gtk_store->model = model;

    wxGtkDataViewListModelNotifier *notifier = 
        new wxGtkDataViewListModelNotifier( gtk_store, model );

    model->SetNotifier( notifier );    

    gtk_tree_view_set_model( GTK_TREE_VIEW(m_widget), GTK_TREE_MODEL(gtk_store) );
    
    return true;
}

bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
{
    if (!wxDataViewCtrlBase::AppendColumn(col))
        return false;
        
    GtkTreeViewColumn *column = (GtkTreeViewColumn *)col->GetGtkHandle();

    gtk_tree_view_append_column( GTK_TREE_VIEW(m_widget), column );

    return true;
}


#endif // wxUSE_DATAVIEWCTRL
Commit	Line	Data
790b137e RR	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: 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	#include "wx/defs.h"
	14
	15	#if wxUSE_DATAVIEWCTRL
	16
	17	#include "wx/dataview.h"
	18	#include "wx/stockitem.h"
	19
	20	#include "wx/gtk/private.h"
	21	#include "wx/gtk/win_gtk.h"
	22
	23	#include <gobject/gvaluecollector.h>
1557c77b RR	24	#include <gtk/gtktreemodel.h>
1557c77b RR	25	#include <gtk/gtktreednd.h>
790b137e RR	26
	27	//-----------------------------------------------------------------------------
	28	// classes
	29	//-----------------------------------------------------------------------------
	30
	31	class wxDataViewCtrl;
	32
	33	//-----------------------------------------------------------------------------
	34	// idle system
	35	//-----------------------------------------------------------------------------
	36
	37	extern void wxapp_install_idle_handler();
	38	extern bool g_isIdle;
	39
	40	//-----------------------------------------------------------------------------
	41	// data
	42	//-----------------------------------------------------------------------------
	43
	44	extern bool g_blockEventsOnDrag;
	45
	46	//-----------------------------------------------------------------------------
	47	// define new GTK+ class wxGtkListStore
	48	//-----------------------------------------------------------------------------
	49
	50	extern "C" {
	51
	52	#define GTK_TYPE_WX_LIST_STORE (gtk_wx_list_store_get_type ())
	53	#define GTK_WX_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WX_LIST_STORE, GtkWxListStore))
	54	#define GTK_WX_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WX_LIST_STORE, GtkWxListStoreClass))
	55	#define GTK_IS_WX_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WX_LIST_STORE))
	56	#define GTK_IS_WX_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WX_LIST_STORE))
	57	#define GTK_WX_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WX_LIST_STORE, GtkWxListStoreClass))
	58
	59	GType gtk_wx_list_store_get_type (void);
	60
	61	typedef struct _GtkWxListStore GtkWxListStore;
	62	typedef struct _GtkWxListStoreClass GtkWxListStoreClass;
	63
	64	struct _GtkWxListStore
	65	{
	66	GObject parent;
	67
	68	/< private >/
	69	gint stamp;
	70	wxDataViewListModel *model;
	71	};
	72
	73	struct _GtkWxListStoreClass
	74	{
	75	GObjectClass parent_class;
	76
	77	};
	78
1557c77b	79	static GtkWxListStore *wxgtk_list_store_new ();
790b137e	80	static void wxgtk_list_store_init (GtkWxListStore *list_store);
1557c77b	81	static void wxgtk_list_store_class_init (GtkWxListStoreClass *klass);
790b137e RR	82	static void wxgtk_list_store_tree_model_init (GtkTreeModelIface *iface);
	83	static void wxgtk_list_store_finalize (GObject *object);
	84	static GtkTreeModelFlags wxgtk_list_store_get_flags (GtkTreeModel *tree_model);
	85	static gint wxgtk_list_store_get_n_columns (GtkTreeModel *tree_model);
	86	static GType wxgtk_list_store_get_column_type (GtkTreeModel *tree_model,
	87	gint index);
	88	static gboolean wxgtk_list_store_get_iter (GtkTreeModel *tree_model,
	89	GtkTreeIter *iter,
	90	GtkTreePath *path);
	91	static GtkTreePath wxgtk_list_store_get_path (GtkTreeModel tree_model,
	92	GtkTreeIter *iter);
	93	static void wxgtk_list_store_get_value (GtkTreeModel *tree_model,
	94	GtkTreeIter *iter,
	95	gint column,
	96	GValue *value);
	97	static gboolean wxgtk_list_store_iter_next (GtkTreeModel *tree_model,
	98	GtkTreeIter *iter);
	99	static gboolean wxgtk_list_store_iter_children (GtkTreeModel *tree_model,
	100	GtkTreeIter *iter,
	101	GtkTreeIter *parent);
	102	static gboolean wxgtk_list_store_iter_has_child (GtkTreeModel *tree_model,
	103	GtkTreeIter *iter);
	104	static gint wxgtk_list_store_iter_n_children (GtkTreeModel *tree_model,
	105	GtkTreeIter *iter);
	106	static gboolean wxgtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
	107	GtkTreeIter *iter,
	108	GtkTreeIter *parent,
	109	gint n);
	110	static gboolean wxgtk_list_store_iter_parent (GtkTreeModel *tree_model,
	111	GtkTreeIter *iter,
	112	GtkTreeIter *child);
	113
790b137e RR	114	static GObjectClass *parent_class = NULL;
	115
	116	GType
111f83c4	117	gtk_wx_list_store_get_type (void)
790b137e RR	118	{
	119	static GType list_store_type = 0;
	120
	121	if (!list_store_type)
	122	{
	123	static const GTypeInfo list_store_info =
	124	{
	125	sizeof (GtkWxListStoreClass),
	126	NULL, /* base_init */
	127	NULL, /* base_finalize */
	128	(GClassInitFunc) wxgtk_list_store_class_init,
	129	NULL, /* class_finalize */
	130	NULL, /* class_data */
	131	sizeof (GtkWxListStore),
	132	0,
	133	(GInstanceInitFunc) wxgtk_list_store_init,
	134	};
	135
	136	static const GInterfaceInfo tree_model_info =
	137	{
	138	(GInterfaceInitFunc) wxgtk_list_store_tree_model_init,
	139	NULL,
	140	NULL
	141	};
	142
	143	list_store_type = g_type_register_static (G_TYPE_OBJECT, "GtkWxListStore",
1557c77b	144	&list_store_info, (GTypeFlags)0 );
790b137e RR	145
	146	g_type_add_interface_static (list_store_type,
	147	GTK_TYPE_TREE_MODEL,
	148	&tree_model_info);
	149	}
	150
	151	return list_store_type;
	152	}
	153
1557c77b RR	154	static GtkWxListStore *
	155	wxgtk_list_store_new()
	156	{
	157	GtkWxListStore retval = (GtkWxListStore ) g_object_new (GTK_TYPE_WX_LIST_STORE, NULL);
	158	return retval;
	159	}
	160
790b137e	161	static void
1557c77b	162	wxgtk_list_store_class_init (GtkWxListStoreClass *klass)
790b137e RR	163	{
790b137e RR	164	GObjectClass *object_class;
1557c77b RR	165	parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
1557c77b RR	166	object_class = (GObjectClass*) klass;
790b137e RR	167	object_class->finalize = wxgtk_list_store_finalize;
	168	}
	169
	170	static void
	171	wxgtk_list_store_tree_model_init (GtkTreeModelIface *iface)
	172	{
	173	iface->get_flags = wxgtk_list_store_get_flags;
	174	iface->get_n_columns = wxgtk_list_store_get_n_columns;
	175	iface->get_column_type = wxgtk_list_store_get_column_type;
	176	iface->get_iter = wxgtk_list_store_get_iter;
	177	iface->get_path = wxgtk_list_store_get_path;
	178	iface->get_value = wxgtk_list_store_get_value;
	179	iface->iter_next = wxgtk_list_store_iter_next;
	180	iface->iter_children = wxgtk_list_store_iter_children;
	181	iface->iter_has_child = wxgtk_list_store_iter_has_child;
	182	iface->iter_n_children = wxgtk_list_store_iter_n_children;
	183	iface->iter_nth_child = wxgtk_list_store_iter_nth_child;
	184	iface->iter_parent = wxgtk_list_store_iter_parent;
	185	}
	186
	187	static void
	188	wxgtk_list_store_init (GtkWxListStore *list_store)
	189	{
	190	list_store->model = NULL;
1557c77b	191	list_store->stamp = g_random_int();
790b137e RR	192	}
	193
	194	static void
	195	wxgtk_list_store_finalize (GObject *object)
	196	{
1557c77b	197	/* GtkWxListStore list_store = GTK_WX_LIST_STORE (object); /
790b137e RR	198
790b137e RR	199	/* we need to sort out, which class deletes what */
111f83c4	200	/* delete list_store->model; */
790b137e RR	201
	202	/* must chain up */
	203	(* parent_class->finalize) (object);
	204	}
	205
	206	} // extern "C"
	207
	208	//-----------------------------------------------------------------------------
	209	// implement callbacks from wxGtkListStore class by letting
	210	// them call the methods of wxWidgets' wxDataViewListModel
	211	//-----------------------------------------------------------------------------
	212
	213	static GtkTreeModelFlags
	214	wxgtk_list_store_get_flags (GtkTreeModel *tree_model)
	215	{
1557c77b	216	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), (GtkTreeModelFlags)0 );
790b137e	217
67cbdfc1 RR	218	// GTK+ list store uses a linked list for storing the
	219	// items and a pointer to a child is used as the member
	220	// field of a GtkTreeIter. This means that the iter is
	221	// valid in the GtkListStore as long as the child exists.
	222	// We use the index of the row and since the index of a
	223	// specific row will change if a row above is deleted,
	224	// the iter does not persist
	225	return /* GTK_TREE_MODEL_ITERS_PERSIST \| */ GTK_TREE_MODEL_LIST_ONLY;
790b137e RR	226	}
	227
	228	static gint
	229	wxgtk_list_store_get_n_columns (GtkTreeModel *tree_model)
	230	{
	231	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
	232	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), 0);
	233
239eaa41	234	return list_store->model->GetNumberOfCols();
790b137e RR	235	}
	236
	237	static GType
	238	wxgtk_list_store_get_column_type (GtkTreeModel *tree_model,
	239	gint index)
	240	{
	241	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
	242	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), G_TYPE_INVALID);
	243
1557c77b	244	GType gtype = G_TYPE_INVALID;
239eaa41	245
1557c77b RR	246	wxString wxtype = list_store->model->GetColType( (size_t) index );
	247
	248	if (wxtype == wxT("string"))
	249	gtype = G_TYPE_STRING;
790b137e RR	250
	251	return gtype;
	252	}
	253
	254	static gboolean
	255	wxgtk_list_store_get_iter (GtkTreeModel *tree_model,
	256	GtkTreeIter *iter,
	257	GtkTreePath *path)
	258	{
	259	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
	260	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
	261	g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
	262
1557c77b	263	size_t i = (size_t)gtk_tree_path_get_indices (path)[0];
790b137e	264
1557c77b	265	if (i >= list_store->model->GetNumberOfRows())
239eaa41	266	return FALSE;
790b137e	267
239eaa41 RR	268	iter->stamp = list_store->stamp;
	269	// user_data is just the index
	270	iter->user_data = (gpointer) i;
790b137e RR	271
	272	return TRUE;
	273	}
	274
	275	static GtkTreePath *
	276	wxgtk_list_store_get_path (GtkTreeModel *tree_model,
	277	GtkTreeIter *iter)
	278	{
790b137e	279	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), NULL);
239eaa41	280	g_return_val_if_fail (iter->stamp == GTK_WX_LIST_STORE (tree_model)->stamp, NULL);
790b137e	281
239eaa41 RR	282	GtkTreePath *retval = gtk_tree_path_new ();
239eaa41 RR	283	// user_data is just the index
1557c77b	284	int i = (int) iter->user_data;
239eaa41 RR	285	gtk_tree_path_append_index (retval, i);
239eaa41 RR	286	return retval;
790b137e RR	287	}
	288
	289	static void
	290	wxgtk_list_store_get_value (GtkTreeModel *tree_model,
	291	GtkTreeIter *iter,
	292	gint column,
	293	GValue *value)
	294	{
1557c77b	295	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
790b137e	296	g_return_if_fail (GTK_IS_WX_LIST_STORE (tree_model) );
239eaa41	297
1557c77b RR	298	wxDataViewListModel *model = list_store->model;
	299	wxString mtype = model->GetColType( (size_t) column );
	300	if (mtype == wxT("string"))
	301	{
	302	g_value_init( value, G_TYPE_STRING );
	303	wxVariant variant = model->GetValue( (size_t) column, (size_t) iter->user_data );
	304	g_value_set_string( value, wxGTK_CONV(variant.GetString()) );
	305	}
	306	else
	307	{
	308	}
790b137e RR	309
	310	#if 0
	311	GtkTreeDataList *list;
	312	gint tmp_column = column;
	313
	314	g_return_if_fail (column < GTK_LIST_STORE (tree_model)->n_columns);
	315	g_return_if_fail (GTK_LIST_STORE (tree_model)->stamp == iter->stamp);
	316
	317	list = G_SLIST (iter->user_data)->data;
	318
	319	while (tmp_column-- > 0 && list)
	320	list = list->next;
	321
	322	if (list == NULL)
	323	g_value_init (value, GTK_LIST_STORE (tree_model)->column_headers[column]);
	324	else
	325	_gtk_tree_data_list_node_to_value (list,
	326	GTK_LIST_STORE (tree_model)->column_headers[column],
	327	value);
	328	#endif
	329
	330	}
	331
	332	static gboolean
	333	wxgtk_list_store_iter_next (GtkTreeModel *tree_model,
	334	GtkTreeIter *iter)
	335	{
790b137e	336	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
1557c77b	337	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
790b137e	338
67cbdfc1	339	g_return_val_if_fail (list_store->stamp == iter->stamp, FALSE);
790b137e	340
67cbdfc1 RR	341	int n = (int) iter->user_data;
	342
	343	if (n == -1)
	344	return FALSE;
	345
1557c77b	346	if (n >= (int) list_store->model->GetNumberOfRows())
67cbdfc1 RR	347	return FALSE;
67cbdfc1 RR	348
111f83c4	349	iter->user_data = (gpointer) ++n;
790b137e	350
67cbdfc1	351	return TRUE;
790b137e RR	352	}
	353
	354	static gboolean
	355	wxgtk_list_store_iter_children (GtkTreeModel *tree_model,
	356	GtkTreeIter *iter,
	357	GtkTreeIter *parent)
	358	{
67cbdfc1	359	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
1557c77b	360	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
67cbdfc1 RR	361
67cbdfc1 RR	362	// this is a list, nodes have no children
790b137e RR	363	if (parent)
	364	return FALSE;
	365
67cbdfc1 RR	366	iter->stamp = list_store->stamp;
	367	iter->user_data = (gpointer) -1;
	368
	369	return TRUE;
790b137e RR	370	}
	371
	372	static gboolean
	373	wxgtk_list_store_iter_has_child (GtkTreeModel *tree_model,
	374	GtkTreeIter *iter)
	375	{
	376	return FALSE;
	377	}
	378
	379	static gint
	380	wxgtk_list_store_iter_n_children (GtkTreeModel *tree_model,
	381	GtkTreeIter *iter)
	382	{
	383	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), -1);
1557c77b	384	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
790b137e RR	385
790b137e RR	386	if (iter == NULL)
1557c77b	387	return (gint) list_store->model->GetNumberOfRows();
790b137e	388
67cbdfc1	389	g_return_val_if_fail (list_store->stamp == iter->stamp, -1);
790b137e RR	390
	391	return 0;
	392	}
	393
	394	static gboolean
	395	wxgtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
	396	GtkTreeIter *iter,
	397	GtkTreeIter *parent,
	398	gint n)
	399	{
67cbdfc1	400	g_return_val_if_fail (GTK_IS_WX_LIST_STORE (tree_model), FALSE);
1557c77b	401	GtkWxListStore list_store = (GtkWxListStore ) tree_model;
67cbdfc1 RR	402
	403	if (parent)
	404	return FALSE;
790b137e	405
67cbdfc1 RR	406	if (n < 0)
	407	return FALSE;
	408
1557c77b	409	if (n >= (gint) list_store->model->GetNumberOfRows())
67cbdfc1	410	return FALSE;
790b137e	411
67cbdfc1 RR	412	iter->stamp = list_store->stamp;
	413	iter->user_data = (gpointer) n;
	414
	415	return TRUE;
790b137e RR	416	}
	417
	418	static gboolean
	419	wxgtk_list_store_iter_parent (GtkTreeModel *tree_model,
	420	GtkTreeIter *iter,
	421	GtkTreeIter *child)
	422	{
	423	return FALSE;
	424	}
	425
6e2e590f RR	426	// ---------------------------------------------------------
	427	// wxGtkDataViewListModelNotifier
	428	// ---------------------------------------------------------
	429
	430	class wxGtkDataViewListModelNotifier: public wxDataViewListModelNotifier
	431	{
	432	public:
	433	wxGtkDataViewListModelNotifier( GtkWxListStore* gtk_store, wxDataViewListModel *wx_model );
	434
	435	virtual bool RowAppended();
	436	virtual bool RowPrepended();
	437	virtual bool RowInserted( size_t before );
	438	virtual bool RowDeleted( size_t row );
	439	virtual bool RowChanged( size_t row );
	440	virtual bool ValueChanged( size_t row, size_t col );
	441	virtual bool Cleared();
	442
	443	GtkWxListStore *m_gtk_store;
	444	wxDataViewListModel *m_wx_model;
	445	};
	446
	447	// ---------------------------------------------------------
	448	// wxGtkDataViewListModelNotifier
	449	// ---------------------------------------------------------
	450
	451	wxGtkDataViewListModelNotifier::wxGtkDataViewListModelNotifier(
	452	GtkWxListStore* gtk_store, wxDataViewListModel *wx_model )
	453	{
	454	m_gtk_store = gtk_store;
	455	m_wx_model = wx_model;
	456	}
	457
	458	bool wxGtkDataViewListModelNotifier::RowAppended()
	459	{
	460	size_t pos = m_wx_model->GetNumberOfRows()-1;
	461
	462	GtkTreeIter iter;
	463	iter.stamp = m_gtk_store->stamp;
	464	iter.user_data = (gpointer) pos;
	465
	466	GtkTreePath *path = gtk_tree_path_new ();
	467	gtk_tree_path_append_index (path, (gint) pos);
	468	gtk_tree_model_row_inserted (GTK_TREE_MODEL (m_gtk_store), path, &iter);
	469	gtk_tree_path_free (path);
	470
	471	return true;
	472	}
	473
	474	bool wxGtkDataViewListModelNotifier::RowPrepended()
	475	{
	476	return false;
	477	}
	478
	479	bool wxGtkDataViewListModelNotifier::RowInserted( size_t before )
	480	{
	481	return false;
	482	}
	483
	484	bool wxGtkDataViewListModelNotifier::RowDeleted( size_t row )
	485	{
	486	return false;
	487	}
	488
	489	bool wxGtkDataViewListModelNotifier::RowChanged( size_t row )
490	{
491	return false;
492	}
493
494	bool wxGtkDataViewListModelNotifier::ValueChanged( size_t row, size_t col )
495	{
496	return false;
497	}
498
499	bool wxGtkDataViewListModelNotifier::Cleared()
500	{
501	return false;
502	}
503
790b137e	504
fa28826d RR	505	// ---------------------------------------------------------
	506	// wxDataViewColumn
	507	// ---------------------------------------------------------
	508
	509	IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
	510
	511	wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCtrl *ctrl,
	512	wxDataViewColumnType kind, int flags ) :
	513	wxDataViewColumnBase( title, ctrl, kind, flags )
	514	{
	515	GtkCellRenderer *renderer = NULL;
	516
	517	if (kind == wxDATAVIEW_COL_TEXT)
	518	{
	519	renderer = gtk_cell_renderer_text_new();
	520	} else
	521	if (kind == wxDATAVIEW_COL_CHECK)
	522	{
	523	renderer = gtk_cell_renderer_toggle_new();
	524	} else
	525	if (kind == wxDATAVIEW_COL_ICON)
	526	{
	527	renderer = gtk_cell_renderer_pixbuf_new();
	528	}
	529	else
	530	return;
	531
	532	GtkTreeViewColumn *column =
	533	gtk_tree_view_column_new_with_attributes( wxGTK_CONV(title), renderer, "text", 0, NULL );
	534
	535	// bind to data here... not above.
	536
	537	m_column = (void*) column;
	538	}
	539
	540	wxDataViewColumn::~wxDataViewColumn()
	541	{
	542	}
	543
	544	void wxDataViewColumn::SetTitle( const wxString &title )
	545	{
	546	wxDataViewColumnBase::SetTitle( title );
	547
	548	GtkTreeViewColumn column = (GtkTreeViewColumn )m_column;
	549	gtk_tree_view_column_set_title( column, wxGTK_CONV(title) );
	550	}
	551
790b137e RR	552	//-----------------------------------------------------------------------------
	553	// wxDataViewCtrl
	554	//-----------------------------------------------------------------------------
	555
239eaa41 RR	556	IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
	557
	558	wxDataViewCtrl::~wxDataViewCtrl()
	559	{
	560	}
	561
	562	void wxDataViewCtrl::Init()
	563	{
	564	}
	565
	566	bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
	567	const wxPoint& pos, const wxSize& size,
	568	long style, const wxValidator& validator )
	569	{
	570	Init();
	571
	572	m_needParent = TRUE;
	573	m_acceptsFocus = TRUE;
	574
	575	if (!PreCreation( parent, pos, size ) \|\|
	576	!CreateBase( parent, id, pos, size, style, validator ))
	577	{
	578	wxFAIL_MSG( wxT("wxDataViewCtrl creation failed") );
	579	return FALSE;
	580	}
	581
	582	m_widget = gtk_tree_view_new();
	583
	584	m_parent->DoAddChild( this );
	585
	586	PostCreation(size);
	587
	588	return true;
	589	}
	590
6e2e590f	591	bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
239eaa41 RR	592	{
	593	if (!wxDataViewCtrlBase::AssociateModel( model ))
	594	return false;
	595
6e2e590f RR	596	GtkWxListStore *gtk_store = wxgtk_list_store_new();
	597	gtk_store->model = model;
	598
	599	wxGtkDataViewListModelNotifier *notifier =
	600	new wxGtkDataViewListModelNotifier( gtk_store, model );
	601
	602	model->SetNotifier( notifier );
1557c77b	603
6e2e590f	604	gtk_tree_view_set_model( GTK_TREE_VIEW(m_widget), GTK_TREE_MODEL(gtk_store) );
239eaa41 RR	605
	606	return true;
	607	}
790b137e	608
fa28826d RR	609	bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
	610	{
	611	if (!wxDataViewCtrlBase::AppendColumn(col))
	612	return false;
	613
	614	GtkTreeViewColumn column = (GtkTreeViewColumn )col->GetGtkHandle();
	615
	616	gtk_tree_view_append_column( GTK_TREE_VIEW(m_widget), column );
	617
	618	return true;
	619	}
	620
790b137e RR	621
	622	#endif // wxUSE_DATAVIEWCTRL
	623