src/common/datavcmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/datavcmn.cpp
// Purpose:     wxDataViewCtrl base classes and common parts
// Author:      Robert Roebling
// Created:     2006/02/20
// RCS-ID:      $Id$
// Copyright:   (c) 2006, Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_DATAVIEWCTRL

#include "wx/dataview.h"

#ifndef WX_PRECOMP
    #include "wx/log.h"
#endif

const wxChar wxDataViewCtrlNameStr[] = wxT("dataviewCtrl");

// ---------------------------------------------------------
// wxDataViewModel
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewModel, wxObject)

// ---------------------------------------------------------
// wxDataViewListModel
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewListModel, wxDataViewModel)

wxDataViewListModel::wxDataViewListModel()
{
    m_viewingColumns.DeleteContents( true );
    m_notifiers.DeleteContents( true );
}

wxDataViewListModel::~wxDataViewListModel()
{
}

bool wxDataViewListModel::RowAppended()
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->RowAppended())
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::RowPrepended()
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->RowPrepended())
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::RowInserted( size_t before )
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->RowInserted(before))
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::RowDeleted( size_t row )
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->RowDeleted( row ))
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::RowChanged( size_t row )
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->RowChanged( row ))
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::ValueChanged( size_t col, size_t row )
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->ValueChanged( col, row ))
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::RowsReordered( size_t *new_order )
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->RowsReordered( new_order ))
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

bool wxDataViewListModel::Cleared()
{
    bool ret = true;

    wxList::compatibility_iterator node = m_notifiers.GetFirst();
    while (node)
    {
        wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
        if (!notifier->Cleared())
            ret = false;
        node = node->GetNext();
    }

    return ret;
}

void wxDataViewListModel::AddViewingColumn( wxDataViewColumn *view_column, size_t model_column )
{
    m_viewingColumns.Append( new wxDataViewViewingColumn( view_column, model_column ) );
}

void wxDataViewListModel::RemoveViewingColumn( wxDataViewColumn *column )
{
    wxList::compatibility_iterator node = m_viewingColumns.GetFirst();
    while (node)
    {
        wxDataViewViewingColumn* tmp = (wxDataViewViewingColumn*) node->GetData();

        if (tmp->m_viewColumn == column)
        {
            m_viewingColumns.DeleteObject( tmp );
            return;
        }

        node = node->GetNext();
    }
}

void wxDataViewListModel::AddNotifier( wxDataViewListModelNotifier *notifier )
{
    m_notifiers.Append( notifier );
    notifier->SetOwner( this );
}

void wxDataViewListModel::RemoveNotifier( wxDataViewListModelNotifier *notifier )
{
    m_notifiers.DeleteObject( notifier );
}

// ---------------------------------------------------------
// wxDataViewSortedListModelNotifier
// ---------------------------------------------------------

class wxDataViewSortedListModelNotifier: public wxDataViewListModelNotifier
{
public:
    wxDataViewSortedListModelNotifier( wxDataViewSortedListModel *model )
    { m_model = model; }

    virtual bool RowAppended() { return true; }
    virtual bool RowPrepended()  { return true; }
    virtual bool RowInserted( size_t WXUNUSED(before) )  { return true; }
    virtual bool RowDeleted( size_t WXUNUSED(row) ) { return true; }
    virtual bool RowChanged( size_t WXUNUSED(row) ) { return true; }
    virtual bool ValueChanged( size_t col, size_t row )
         { return m_model->ChildValueChanged( col, row); }
    virtual bool RowsReordered( size_t *WXUNUSED(new_order) ) { return true; }
    virtual bool Cleared() { return true; }

    wxDataViewSortedListModel *m_model;
};

// ---------------------------------------------------------
// wxDataViewSortedListModel compare function
// ---------------------------------------------------------

int wxCALLBACK wxDataViewListModelSortedDefaultCompare
      (size_t row1, size_t row2, size_t col, wxDataViewListModel* model )
{
    wxVariant value1,value2;
    model->GetValue( value1, col, row1 );
    model->GetValue( value2, col, row2 );
    if (value1.GetType() == wxT("string"))
    {
        wxString str1 = value1.GetString();
        wxString str2 = value2.GetString();
        return str1.Cmp( str2 );
    }
    if (value1.GetType() == wxT("long"))
    {
        long l1 = value1.GetLong();
        long l2 = value2.GetLong();
        return l1-l2;
    }
    if (value1.GetType() == wxT("double"))
    {
        double d1 = value1.GetDouble();
        double d2 = value2.GetDouble();
        if (d1 == d2) return 0;
        if (d1 < d2) return 1;
        return -1;
    }
    if (value1.GetType() == wxT("datetime"))
    {
        wxDateTime dt1 = value1.GetDateTime();
        wxDateTime dt2 = value2.GetDateTime();
        if (dt1.IsEqualTo(dt2)) return 0;
        if (dt1.IsEarlierThan(dt2)) return 1;
        return -1;
    }

    return 0;
}

static wxDataViewListModelCompare   s_CmpFunc;
static wxDataViewListModel         *s_CmpModel;
static size_t                       s_CmpCol;

int LINKAGEMODE wxDataViewIntermediateCmp( size_t row1, size_t row2 )
{
    return s_CmpFunc( row1, row2, s_CmpCol, s_CmpModel );
}

// ---------------------------------------------------------
// wxDataViewSortedListModel
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewSortedListModel, wxDataViewListModel)

wxDataViewSortedListModel::wxDataViewSortedListModel( wxDataViewListModel *child ) :
  m_array( wxDataViewIntermediateCmp )
{
    m_child = child;
    s_CmpCol = 0;
    s_CmpModel = child;
    s_CmpFunc = wxDataViewListModelSortedDefaultCompare;

    m_notifierOnChild = new wxDataViewSortedListModelNotifier( this );
    m_child->AddNotifier( m_notifierOnChild );

    Resort();
}

wxDataViewSortedListModel::~wxDataViewSortedListModel()
{
    m_child->RemoveNotifier( m_notifierOnChild );
}

void wxDataViewSortedListModel::Resort()
{
    m_array.Clear();
    size_t n = m_child->GetNumberOfRows();
    size_t i;
    for (i = 0; i < n; i++)
        m_array.Add( i );
}

#if 0
static void Dump( wxDataViewListModel *model, size_t col )
{
    size_t n = model->GetNumberOfRows();
    size_t i;
    for (i = 0; i < n; i++)
    {
        wxVariant variant;
        model->GetValue( variant, col, i );
        wxString tmp;
        tmp = variant.GetString();
        wxPrintf( wxT("%d: %s\n"), (int) i, tmp.c_str() );
    }
}
#endif

bool wxDataViewSortedListModel::ChildValueChanged( size_t col, size_t row )
{
    size_t i;
    size_t len = m_array.GetCount();

    // Remove and readd sorted. Find out at which
    // position it was and where it ended.
    size_t start_pos = 0,end_pos = 0;
    for (i = 0; i < len; i++)
        if (m_array[i] == row)
        {
            start_pos = i;
            break;
        }
    m_array.RemoveAt( start_pos );
    m_array.Add( row );

    for (i = 0; i < len; i++)
        if (m_array[i] == row)
        {
            end_pos = i;
            break;
        }

    if (end_pos == start_pos)
        return wxDataViewListModel::ValueChanged( col, start_pos );

    // Create an array where order[old] -> new_pos, so that
    // if nothing changed order[0] -> 0 etc.
    size_t *order = new size_t[ len ];
    // Fill up initial values.
    for (i = 0; i < len; i++)
        order[i] = i;

    if (start_pos < end_pos)
    {
        for (i = start_pos; i < end_pos; i++)
            order[i] = order[i+1];
        order[end_pos] = start_pos;
    }
    else
    {
        for (i = end_pos; i > start_pos; i--)
            order[i] = order[i-1];
        order[start_pos] = end_pos;
    }

    wxDataViewListModel::RowsReordered( order );

    delete [] order;

    return true;
}

size_t wxDataViewSortedListModel::GetNumberOfRows()
{
    return m_array.GetCount();
}

size_t wxDataViewSortedListModel::GetNumberOfCols()
{
    return m_child->GetNumberOfCols();
}

wxString wxDataViewSortedListModel::GetColType( size_t col )
{
    return m_child->GetColType( col );
}

void wxDataViewSortedListModel::GetValue( wxVariant &variant, size_t col, size_t row )
{
    size_t child_row = m_array[row];
    m_child->GetValue( variant, col, child_row );
}

bool wxDataViewSortedListModel::SetValue( wxVariant &variant, size_t col, size_t row )
{
    size_t child_row = m_array[row];
    bool ret = m_child->SetValue( variant, col, child_row );

    // Resort in ::ChildValueChanged() which gets reported back.

    return ret;
}

bool wxDataViewSortedListModel::RowAppended()
{
    // you can only append
    bool ret = m_child->RowAppended();

    // report RowInsrted

    return ret;
}

bool wxDataViewSortedListModel::RowPrepended()
{
    // you can only append
    bool ret = m_child->RowAppended();

    // report RowInsrted

    return ret;
}

bool wxDataViewSortedListModel::RowInserted( size_t WXUNUSED(before) )
{
    // you can only append
    bool ret = m_child->RowAppended();

    // report different RowInsrted

    return ret;
}

bool wxDataViewSortedListModel::RowDeleted( size_t row )
{
    size_t child_row = m_array[row];

    bool ret = m_child->RowDeleted( child_row );

    // Do nothing here as the change in the
    // child model will be reported back.

    return ret;
}

bool wxDataViewSortedListModel::RowChanged( size_t row )
{
    size_t child_row = m_array[row];
    bool ret = m_child->RowChanged( child_row );

    // Do nothing here as the change in the
    // child model will be reported back.

    return ret;
}

bool wxDataViewSortedListModel::ValueChanged( size_t col, size_t row )
{
    size_t child_row = m_array[row];
    bool ret = m_child->ValueChanged( col, child_row );

    // Do nothing here as the change in the
    // child model will be reported back.

    return ret;
}

bool wxDataViewSortedListModel::RowsReordered( size_t *WXUNUSED(new_order) )
{
    // We sort them ourselves.

    return false;
}

bool wxDataViewSortedListModel::Cleared()
{
    bool ret = m_child->Cleared();

    wxDataViewListModel::Cleared();

    return ret;
}

// ---------------------------------------------------------
// wxDataViewCellBase
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewCellBase, wxObject)

wxDataViewCellBase::wxDataViewCellBase( const wxString &varianttype, wxDataViewCellMode mode )
{
    m_variantType = varianttype;
    m_mode = mode;
}

// ---------------------------------------------------------
// wxDataViewColumnBase
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumnBase, wxObject)

wxDataViewColumnBase::wxDataViewColumnBase(const wxString& title,
                                           wxDataViewCell *cell,
                                           size_t model_column,
                                           int WXUNUSED(fixed_width),
                                           wxDataViewColumnSizing WXUNUSED(sizing),
                                           int flags )
{
    m_cell = cell;
    m_model_column = model_column;
    m_flags = flags;
    m_title = title;
    m_owner = NULL;
    m_cell->SetOwner( (wxDataViewColumn*) this );
}

wxDataViewColumnBase::~wxDataViewColumnBase()
{
    if (m_cell)
        delete m_cell;

    if (GetOwner())
    {
        GetOwner()->GetModel()->RemoveViewingColumn( (wxDataViewColumn*) this );
    }
}

void wxDataViewColumnBase::SetTitle( const wxString &title )
{
    m_title = title;
}

wxString wxDataViewColumnBase::GetTitle()
{
    return m_title;
}

// ---------------------------------------------------------
// wxDataViewCtrlBase
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewCtrlBase, wxControl)

wxDataViewCtrlBase::wxDataViewCtrlBase()
{
    m_model = NULL;
    m_cols.DeleteContents( true );
}

wxDataViewCtrlBase::~wxDataViewCtrlBase()
{
}

bool wxDataViewCtrlBase::AssociateModel( wxDataViewListModel *model )
{
    m_model = model;

    return true;
}

wxDataViewListModel* wxDataViewCtrlBase::GetModel()
{
    return m_model;
}

bool wxDataViewCtrlBase::AppendTextColumn( const wxString &label, size_t model_column )
{
    return AppendColumn( new wxDataViewColumn( label, new wxDataViewTextCell(), model_column ) );
}

bool wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, size_t model_column )
{
    return AppendColumn( new wxDataViewColumn( label, new wxDataViewToggleCell(), model_column, 30 ) );
}

bool wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, size_t model_column )
{
    return AppendColumn( new wxDataViewColumn( label, new wxDataViewProgressCell(), model_column, 70 ) );
}

bool wxDataViewCtrlBase::AppendDateColumn( const wxString &label, size_t model_column )
{
    return AppendColumn( new wxDataViewColumn( label, new wxDataViewDateCell(), model_column ) );
}

bool wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
{
    m_cols.Append( (wxObject*) col );
    col->SetOwner( (wxDataViewCtrl*) this );
    m_model->AddViewingColumn( col, col->GetModelColumn() );
    return true;
}

size_t wxDataViewCtrlBase::GetNumberOfColumns()
{
    return m_cols.GetCount();
}

bool wxDataViewCtrlBase::DeleteColumn( size_t WXUNUSED(pos) )
{
    return false;
}

bool wxDataViewCtrlBase::ClearColumns()
{
    return false;
}

wxDataViewColumn* wxDataViewCtrlBase::GetColumn( size_t pos )
{
    return (wxDataViewColumn*) m_cols[ pos ];
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/datavcmn.cpp
	3	// Purpose: wxDataViewCtrl base classes and common parts
	4	// Author: Robert Roebling
	5	// Created: 2006/02/20
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2006, Robert Roebling
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#if wxUSE_DATAVIEWCTRL
	19
	20	#include "wx/dataview.h"
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/log.h"
	24	#endif
	25
	26	const wxChar wxDataViewCtrlNameStr[] = wxT("dataviewCtrl");
	27
	28	// ---------------------------------------------------------
	29	// wxDataViewModel
	30	// ---------------------------------------------------------
	31
	32	IMPLEMENT_ABSTRACT_CLASS(wxDataViewModel, wxObject)
	33
	34	// ---------------------------------------------------------
	35	// wxDataViewListModel
	36	// ---------------------------------------------------------
	37
	38	IMPLEMENT_ABSTRACT_CLASS(wxDataViewListModel, wxDataViewModel)
	39
	40	wxDataViewListModel::wxDataViewListModel()
	41	{
	42	m_viewingColumns.DeleteContents( true );
	43	m_notifiers.DeleteContents( true );
	44	}
	45
	46	wxDataViewListModel::~wxDataViewListModel()
	47	{
	48	}
	49
	50	bool wxDataViewListModel::RowAppended()
	51	{
	52	bool ret = true;
	53
	54	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	55	while (node)
	56	{
	57	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	58	if (!notifier->RowAppended())
	59	ret = false;
	60	node = node->GetNext();
	61	}
	62
	63	return ret;
	64	}
	65
	66	bool wxDataViewListModel::RowPrepended()
	67	{
	68	bool ret = true;
	69
	70	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	71	while (node)
	72	{
	73	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	74	if (!notifier->RowPrepended())
	75	ret = false;
	76	node = node->GetNext();
	77	}
	78
	79	return ret;
	80	}
	81
	82	bool wxDataViewListModel::RowInserted( size_t before )
	83	{
	84	bool ret = true;
	85
	86	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	87	while (node)
	88	{
	89	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	90	if (!notifier->RowInserted(before))
	91	ret = false;
	92	node = node->GetNext();
	93	}
	94
	95	return ret;
	96	}
	97
	98	bool wxDataViewListModel::RowDeleted( size_t row )
	99	{
	100	bool ret = true;
	101
	102	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	103	while (node)
	104	{
	105	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	106	if (!notifier->RowDeleted( row ))
	107	ret = false;
	108	node = node->GetNext();
	109	}
	110
	111	return ret;
	112	}
	113
	114	bool wxDataViewListModel::RowChanged( size_t row )
	115	{
	116	bool ret = true;
	117
	118	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	119	while (node)
	120	{
	121	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	122	if (!notifier->RowChanged( row ))
	123	ret = false;
	124	node = node->GetNext();
	125	}
	126
	127	return ret;
	128	}
	129
	130	bool wxDataViewListModel::ValueChanged( size_t col, size_t row )
	131	{
	132	bool ret = true;
	133
	134	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	135	while (node)
	136	{
	137	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	138	if (!notifier->ValueChanged( col, row ))
	139	ret = false;
	140	node = node->GetNext();
	141	}
	142
	143	return ret;
	144	}
	145
	146	bool wxDataViewListModel::RowsReordered( size_t *new_order )
	147	{
	148	bool ret = true;
	149
	150	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	151	while (node)
	152	{
	153	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	154	if (!notifier->RowsReordered( new_order ))
	155	ret = false;
	156	node = node->GetNext();
	157	}
	158
	159	return ret;
	160	}
	161
	162	bool wxDataViewListModel::Cleared()
	163	{
	164	bool ret = true;
	165
	166	wxList::compatibility_iterator node = m_notifiers.GetFirst();
	167	while (node)
	168	{
	169	wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
	170	if (!notifier->Cleared())
	171	ret = false;
	172	node = node->GetNext();
	173	}
	174
	175	return ret;
	176	}
	177
	178	void wxDataViewListModel::AddViewingColumn( wxDataViewColumn *view_column, size_t model_column )
	179	{
	180	m_viewingColumns.Append( new wxDataViewViewingColumn( view_column, model_column ) );
	181	}
	182
	183	void wxDataViewListModel::RemoveViewingColumn( wxDataViewColumn *column )
	184	{
	185	wxList::compatibility_iterator node = m_viewingColumns.GetFirst();
	186	while (node)
	187	{
	188	wxDataViewViewingColumn* tmp = (wxDataViewViewingColumn*) node->GetData();
	189
	190	if (tmp->m_viewColumn == column)
	191	{
	192	m_viewingColumns.DeleteObject( tmp );
	193	return;
	194	}
	195
	196	node = node->GetNext();
	197	}
	198	}
	199
	200	void wxDataViewListModel::AddNotifier( wxDataViewListModelNotifier *notifier )
	201	{
	202	m_notifiers.Append( notifier );
	203	notifier->SetOwner( this );
	204	}
	205
	206	void wxDataViewListModel::RemoveNotifier( wxDataViewListModelNotifier *notifier )
	207	{
	208	m_notifiers.DeleteObject( notifier );
	209	}
	210
	211	// ---------------------------------------------------------
	212	// wxDataViewSortedListModelNotifier
	213	// ---------------------------------------------------------
	214
	215	class wxDataViewSortedListModelNotifier: public wxDataViewListModelNotifier
	216	{
	217	public:
	218	wxDataViewSortedListModelNotifier( wxDataViewSortedListModel *model )
	219	{ m_model = model; }
	220
	221	virtual bool RowAppended() { return true; }
	222	virtual bool RowPrepended() { return true; }
	223	virtual bool RowInserted( size_t WXUNUSED(before) ) { return true; }
	224	virtual bool RowDeleted( size_t WXUNUSED(row) ) { return true; }
	225	virtual bool RowChanged( size_t WXUNUSED(row) ) { return true; }
	226	virtual bool ValueChanged( size_t col, size_t row )
	227	{ return m_model->ChildValueChanged( col, row); }
	228	virtual bool RowsReordered( size_t *WXUNUSED(new_order) ) { return true; }
	229	virtual bool Cleared() { return true; }
	230
	231	wxDataViewSortedListModel *m_model;
	232	};
	233
	234	// ---------------------------------------------------------
	235	// wxDataViewSortedListModel compare function
	236	// ---------------------------------------------------------
	237
	238	int wxCALLBACK wxDataViewListModelSortedDefaultCompare
	239	(size_t row1, size_t row2, size_t col, wxDataViewListModel* model )
	240	{
	241	wxVariant value1,value2;
	242	model->GetValue( value1, col, row1 );
	243	model->GetValue( value2, col, row2 );
	244	if (value1.GetType() == wxT("string"))
	245	{
	246	wxString str1 = value1.GetString();
	247	wxString str2 = value2.GetString();
	248	return str1.Cmp( str2 );
	249	}
	250	if (value1.GetType() == wxT("long"))
	251	{
	252	long l1 = value1.GetLong();
	253	long l2 = value2.GetLong();
	254	return l1-l2;
	255	}
	256	if (value1.GetType() == wxT("double"))
	257	{
	258	double d1 = value1.GetDouble();
	259	double d2 = value2.GetDouble();
	260	if (d1 == d2) return 0;
	261	if (d1 < d2) return 1;
	262	return -1;
	263	}
	264	if (value1.GetType() == wxT("datetime"))
	265	{
	266	wxDateTime dt1 = value1.GetDateTime();
	267	wxDateTime dt2 = value2.GetDateTime();
	268	if (dt1.IsEqualTo(dt2)) return 0;
	269	if (dt1.IsEarlierThan(dt2)) return 1;
	270	return -1;
	271	}
	272
	273	return 0;
	274	}
	275
	276	static wxDataViewListModelCompare s_CmpFunc;
	277	static wxDataViewListModel *s_CmpModel;
	278	static size_t s_CmpCol;
	279
	280	int LINKAGEMODE wxDataViewIntermediateCmp( size_t row1, size_t row2 )
	281	{
	282	return s_CmpFunc( row1, row2, s_CmpCol, s_CmpModel );
	283	}
	284
	285	// ---------------------------------------------------------
	286	// wxDataViewSortedListModel
	287	// ---------------------------------------------------------
	288
	289	IMPLEMENT_ABSTRACT_CLASS(wxDataViewSortedListModel, wxDataViewListModel)
	290
	291	wxDataViewSortedListModel::wxDataViewSortedListModel( wxDataViewListModel *child ) :
	292	m_array( wxDataViewIntermediateCmp )
	293	{
	294	m_child = child;
	295	s_CmpCol = 0;
	296	s_CmpModel = child;
	297	s_CmpFunc = wxDataViewListModelSortedDefaultCompare;
	298
	299	m_notifierOnChild = new wxDataViewSortedListModelNotifier( this );
	300	m_child->AddNotifier( m_notifierOnChild );
	301
	302	Resort();
	303	}
	304
	305	wxDataViewSortedListModel::~wxDataViewSortedListModel()
	306	{
	307	m_child->RemoveNotifier( m_notifierOnChild );
	308	}
	309
	310	void wxDataViewSortedListModel::Resort()
	311	{
	312	m_array.Clear();
	313	size_t n = m_child->GetNumberOfRows();
	314	size_t i;
	315	for (i = 0; i < n; i++)
	316	m_array.Add( i );
	317	}
	318
	319	#if 0
	320	static void Dump( wxDataViewListModel *model, size_t col )
	321	{
	322	size_t n = model->GetNumberOfRows();
	323	size_t i;
	324	for (i = 0; i < n; i++)
	325	{
	326	wxVariant variant;
	327	model->GetValue( variant, col, i );
	328	wxString tmp;
	329	tmp = variant.GetString();
	330	wxPrintf( wxT("%d: %s\n"), (int) i, tmp.c_str() );
	331	}
	332	}
	333	#endif
	334
	335	bool wxDataViewSortedListModel::ChildValueChanged( size_t col, size_t row )
	336	{
	337	size_t i;
	338	size_t len = m_array.GetCount();
	339
	340	// Remove and readd sorted. Find out at which
	341	// position it was and where it ended.
	342	size_t start_pos = 0,end_pos = 0;
	343	for (i = 0; i < len; i++)
	344	if (m_array[i] == row)
	345	{
	346	start_pos = i;
	347	break;
	348	}
	349	m_array.RemoveAt( start_pos );
	350	m_array.Add( row );
	351
	352	for (i = 0; i < len; i++)
	353	if (m_array[i] == row)
	354	{
	355	end_pos = i;
	356	break;
	357	}
	358
	359	if (end_pos == start_pos)
	360	return wxDataViewListModel::ValueChanged( col, start_pos );
	361
	362	// Create an array where order[old] -> new_pos, so that
	363	// if nothing changed order[0] -> 0 etc.
	364	size_t *order = new size_t[ len ];
	365	// Fill up initial values.
	366	for (i = 0; i < len; i++)
	367	order[i] = i;
	368
	369	if (start_pos < end_pos)
	370	{
	371	for (i = start_pos; i < end_pos; i++)
	372	order[i] = order[i+1];
	373	order[end_pos] = start_pos;
	374	}
	375	else
	376	{
	377	for (i = end_pos; i > start_pos; i--)
	378	order[i] = order[i-1];
	379	order[start_pos] = end_pos;
	380	}
	381
	382	wxDataViewListModel::RowsReordered( order );
	383
	384	delete [] order;
	385
	386	return true;
	387	}
	388
	389	size_t wxDataViewSortedListModel::GetNumberOfRows()
	390	{
	391	return m_array.GetCount();
	392	}
	393
	394	size_t wxDataViewSortedListModel::GetNumberOfCols()
	395	{
	396	return m_child->GetNumberOfCols();
	397	}
	398
	399	wxString wxDataViewSortedListModel::GetColType( size_t col )
	400	{
	401	return m_child->GetColType( col );
	402	}
	403
	404	void wxDataViewSortedListModel::GetValue( wxVariant &variant, size_t col, size_t row )
	405	{
	406	size_t child_row = m_array[row];
	407	m_child->GetValue( variant, col, child_row );
	408	}
	409
	410	bool wxDataViewSortedListModel::SetValue( wxVariant &variant, size_t col, size_t row )
	411	{
	412	size_t child_row = m_array[row];
	413	bool ret = m_child->SetValue( variant, col, child_row );
	414
	415	// Resort in ::ChildValueChanged() which gets reported back.
	416
	417	return ret;
	418	}
	419
	420	bool wxDataViewSortedListModel::RowAppended()
	421	{
	422	// you can only append
	423	bool ret = m_child->RowAppended();
	424
	425	// report RowInsrted
	426
	427	return ret;
	428	}
	429
	430	bool wxDataViewSortedListModel::RowPrepended()
	431	{
	432	// you can only append
	433	bool ret = m_child->RowAppended();
	434
	435	// report RowInsrted
	436
	437	return ret;
	438	}
	439
	440	bool wxDataViewSortedListModel::RowInserted( size_t WXUNUSED(before) )
	441	{
	442	// you can only append
	443	bool ret = m_child->RowAppended();
	444
	445	// report different RowInsrted
	446
	447	return ret;
	448	}
	449
	450	bool wxDataViewSortedListModel::RowDeleted( size_t row )
	451	{
	452	size_t child_row = m_array[row];
	453
	454	bool ret = m_child->RowDeleted( child_row );
	455
	456	// Do nothing here as the change in the
	457	// child model will be reported back.
	458
	459	return ret;
	460	}
	461
	462	bool wxDataViewSortedListModel::RowChanged( size_t row )
	463	{
	464	size_t child_row = m_array[row];
	465	bool ret = m_child->RowChanged( child_row );
	466
	467	// Do nothing here as the change in the
	468	// child model will be reported back.
	469
	470	return ret;
	471	}
	472
	473	bool wxDataViewSortedListModel::ValueChanged( size_t col, size_t row )
	474	{
	475	size_t child_row = m_array[row];
	476	bool ret = m_child->ValueChanged( col, child_row );
	477
	478	// Do nothing here as the change in the
	479	// child model will be reported back.
	480
	481	return ret;
	482	}
	483
	484	bool wxDataViewSortedListModel::RowsReordered( size_t *WXUNUSED(new_order) )
	485	{
	486	// We sort them ourselves.
	487
	488	return false;
	489	}
	490
	491	bool wxDataViewSortedListModel::Cleared()
	492	{
	493	bool ret = m_child->Cleared();
	494
	495	wxDataViewListModel::Cleared();
	496
	497	return ret;
	498	}
	499
	500	// ---------------------------------------------------------
	501	// wxDataViewCellBase
	502	// ---------------------------------------------------------
	503
	504	IMPLEMENT_ABSTRACT_CLASS(wxDataViewCellBase, wxObject)
	505
	506	wxDataViewCellBase::wxDataViewCellBase( const wxString &varianttype, wxDataViewCellMode mode )
	507	{
	508	m_variantType = varianttype;
	509	m_mode = mode;
	510	}
	511
	512	// ---------------------------------------------------------
	513	// wxDataViewColumnBase
	514	// ---------------------------------------------------------
	515
	516	IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumnBase, wxObject)
	517
	518	wxDataViewColumnBase::wxDataViewColumnBase(const wxString& title,
	519	wxDataViewCell *cell,
	520	size_t model_column,
	521	int WXUNUSED(fixed_width),
	522	wxDataViewColumnSizing WXUNUSED(sizing),
	523	int flags )
	524	{
	525	m_cell = cell;
	526	m_model_column = model_column;
	527	m_flags = flags;
	528	m_title = title;
	529	m_owner = NULL;
	530	m_cell->SetOwner( (wxDataViewColumn*) this );
	531	}
	532
	533	wxDataViewColumnBase::~wxDataViewColumnBase()
	534	{
	535	if (m_cell)
	536	delete m_cell;
	537
	538	if (GetOwner())
	539	{
	540	GetOwner()->GetModel()->RemoveViewingColumn( (wxDataViewColumn*) this );
	541	}
	542	}
	543
	544	void wxDataViewColumnBase::SetTitle( const wxString &title )
	545	{
	546	m_title = title;
	547	}
	548
	549	wxString wxDataViewColumnBase::GetTitle()
	550	{
	551	return m_title;
	552	}
	553
	554	// ---------------------------------------------------------
	555	// wxDataViewCtrlBase
	556	// ---------------------------------------------------------
	557
	558	IMPLEMENT_ABSTRACT_CLASS(wxDataViewCtrlBase, wxControl)
	559
	560	wxDataViewCtrlBase::wxDataViewCtrlBase()
	561	{
	562	m_model = NULL;
	563	m_cols.DeleteContents( true );
	564	}
	565
	566	wxDataViewCtrlBase::~wxDataViewCtrlBase()
	567	{
	568	}
	569
	570	bool wxDataViewCtrlBase::AssociateModel( wxDataViewListModel *model )
	571	{
	572	m_model = model;
	573
	574	return true;
	575	}
	576
	577	wxDataViewListModel* wxDataViewCtrlBase::GetModel()
	578	{
	579	return m_model;
	580	}
	581
	582	bool wxDataViewCtrlBase::AppendTextColumn( const wxString &label, size_t model_column )
	583	{
	584	return AppendColumn( new wxDataViewColumn( label, new wxDataViewTextCell(), model_column ) );
	585	}
	586
	587	bool wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, size_t model_column )
	588	{
	589	return AppendColumn( new wxDataViewColumn( label, new wxDataViewToggleCell(), model_column, 30 ) );
	590	}
	591
	592	bool wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, size_t model_column )
	593	{
	594	return AppendColumn( new wxDataViewColumn( label, new wxDataViewProgressCell(), model_column, 70 ) );
	595	}
	596
	597	bool wxDataViewCtrlBase::AppendDateColumn( const wxString &label, size_t model_column )
	598	{
	599	return AppendColumn( new wxDataViewColumn( label, new wxDataViewDateCell(), model_column ) );
	600	}
	601
	602	bool wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
	603	{
	604	m_cols.Append( (wxObject*) col );
	605	col->SetOwner( (wxDataViewCtrl*) this );
	606	m_model->AddViewingColumn( col, col->GetModelColumn() );
	607	return true;
	608	}
	609
	610	size_t wxDataViewCtrlBase::GetNumberOfColumns()
	611	{
	612	return m_cols.GetCount();
	613	}
	614
	615	bool wxDataViewCtrlBase::DeleteColumn( size_t WXUNUSED(pos) )
	616	{
	617	return false;
	618	}
	619
	620	bool wxDataViewCtrlBase::ClearColumns()
	621	{
	622	return false;
	623	}
	624
	625	wxDataViewColumn* wxDataViewCtrlBase::GetColumn( size_t pos )
	626	{
	627	return (wxDataViewColumn*) m_cols[ pos ];
	628	}
	629
	630	#endif