src/generic/datavgen.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        datavgen.cpp
// Purpose:     wxDataViewCtrl generic 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"

#ifdef wxUSE_GENERICDATAVIEWCTRL

#include "wx/stockitem.h"
#include "wx/dcclient.h"
#include "wx/calctrl.h"
#include "wx/popupwin.h"
#include "wx/sizer.h"
#include "wx/log.h"
#include "wx/renderer.h"

#ifdef __WXMSW__
    #include <windows.h> // for DLGC_WANTARROWS
    #include "wx/msw/winundef.h"
#endif

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

class wxDataViewCtrl;

// ---------------------------------------------------------
// wxGenericDataViewListModelNotifier
// ---------------------------------------------------------

class wxGenericDataViewListModelNotifier: public wxDataViewListModelNotifier
{
public:
    wxGenericDataViewListModelNotifier( 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 col, size_t row );
    virtual bool RowsReordered( size_t *new_order );
    virtual bool Cleared();

    wxDataViewListModel *m_wx_model;
};

// ---------------------------------------------------------
// wxGenericDataViewListModelNotifier
// ---------------------------------------------------------

wxGenericDataViewListModelNotifier::wxGenericDataViewListModelNotifier(
    wxDataViewListModel *wx_model )
{
    m_wx_model = wx_model;
}

bool wxGenericDataViewListModelNotifier::RowAppended()
{
    size_t pos = m_wx_model->GetNumberOfRows()-1;

    return false;
}

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

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

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

bool wxGenericDataViewListModelNotifier::RowChanged( size_t row )
{
    return true;
}

bool wxGenericDataViewListModelNotifier::ValueChanged( size_t model_col, size_t model_row )
{
    wxNode *node = GetOwner()->m_viewingColumns.GetFirst();
    while (node)
    {
        wxDataViewViewingColumn* viewing_column = (wxDataViewViewingColumn*) node->GetData();
        if (viewing_column->m_modelColumn == model_col)
        {

        }

        node = node->GetNext();
    }

    return false;
}

bool wxGenericDataViewListModelNotifier::RowsReordered( size_t *new_order )
{
    wxNode *node = GetOwner()->m_viewingColumns.GetFirst();
    while (node)
    {
        wxDataViewViewingColumn* viewing_column = (wxDataViewViewingColumn*) node->GetData();

        node = node->GetNext();
    }

    return false;
}

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

// ---------------------------------------------------------
// wxDataViewCell
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)

wxDataViewCell::wxDataViewCell( const wxString &varianttype, wxDataViewCellMode mode ) :
    wxDataViewCellBase( varianttype, mode )
{
}

// ---------------------------------------------------------
// wxDataViewTextCell
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCell)

wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewCellMode mode ) :
    wxDataViewCell( varianttype, mode )
{
}

bool wxDataViewTextCell::SetValue( const wxVariant &value )
{
    return false;
}

bool wxDataViewTextCell::GetValue( wxVariant &value )
{
    return false;
}

// ---------------------------------------------------------
// wxDataViewToggleCell
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCell)

wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
                        wxDataViewCellMode mode ) :
    wxDataViewCell( varianttype, mode )
{
}

bool wxDataViewToggleCell::SetValue( const wxVariant &value )
{
    return false;
}

bool wxDataViewToggleCell::GetValue( wxVariant &value )
{
    return false;
}

// ---------------------------------------------------------
// wxDataViewCustomCell
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)

wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,
                          wxDataViewCellMode mode ) :
    wxDataViewCell( varianttype, mode )
{
    m_dc = NULL;

    Init();
}

bool wxDataViewCustomCell::Init()
{
    return false;
}

wxDataViewCustomCell::~wxDataViewCustomCell()
{
    if (m_dc)
        delete m_dc;
}

wxDC *wxDataViewCustomCell::GetDC()
{
    if (m_dc == NULL)
    {
        if (GetOwner() == NULL)
            return NULL;
        if (GetOwner()->GetOwner() == NULL)
            return NULL;
        m_dc = new wxClientDC( GetOwner()->GetOwner() );
    }

    return m_dc;
}

// ---------------------------------------------------------
// wxDataViewProgressCell
// ---------------------------------------------------------

IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)

wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,
    const wxString &varianttype, wxDataViewCellMode mode ) :
    wxDataViewCustomCell( varianttype, mode )
{
    m_label = label;
    m_value = 0;
}

wxDataViewProgressCell::~wxDataViewProgressCell()
{
}

bool wxDataViewProgressCell::SetValue( const wxVariant &value )
{
    m_value = (long) value;

    if (m_value < 0) m_value = 0;
    if (m_value > 100) m_value = 100;

    return true;
}

bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int state )
{
    double pct = (double)m_value / 100.0;
    wxRect bar = cell;
    bar.width = (int)(cell.width * pct);
    dc->SetPen( *wxTRANSPARENT_PEN );
    dc->SetBrush( *wxBLUE_BRUSH );
    dc->DrawRectangle( bar );

    dc->SetBrush( *wxTRANSPARENT_BRUSH );
    dc->SetPen( *wxBLACK_PEN );
    dc->DrawRectangle( cell );

    return true;
}

wxSize wxDataViewProgressCell::GetSize()
{
    return wxSize(40,12);
}

// ---------------------------------------------------------
// wxDataViewDateCell
// ---------------------------------------------------------

class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
{
public:
    wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
        wxDataViewListModel *model, size_t col, size_t row ) :
        wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
    {
        m_model = model;
        m_col = col;
        m_row = row;
        m_cal = new wxCalendarCtrl( this, -1, *value );
        wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
        sizer->Add( m_cal, 1, wxGROW );
        SetSizer( sizer );
        sizer->Fit( this );
    }

    virtual void OnDismiss()
    {
    }

    void OnCalendar( wxCalendarEvent &event );

    wxCalendarCtrl      *m_cal;
    wxDataViewListModel *m_model;
    size_t               m_col;
    size_t               m_row;

private:
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)
    EVT_CALENDAR( -1, wxDataViewDateCellPopupTransient::OnCalendar )
END_EVENT_TABLE()

void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
{
    wxDateTime date = event.GetDate();
    wxVariant value = date;
    m_model->SetValue( value, m_col, m_row );
    m_model->ValueChanged( m_col, m_row );
    DismissAndNotify();
}

IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)

wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
                        wxDataViewCellMode mode ) :
    wxDataViewCustomCell( varianttype, mode )
{
}

bool wxDataViewDateCell::SetValue( const wxVariant &value )
{
    m_date = value.GetDateTime();

    return true;
}

bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int state )
{
    dc->SetFont( GetOwner()->GetOwner()->GetFont() );
    wxString tmp = m_date.FormatDate();
    dc->DrawText( tmp, cell.x, cell.y );

    return true;
}

wxSize wxDataViewDateCell::GetSize()
{
    wxDataViewCtrl* view = GetOwner()->GetOwner();
    wxString tmp = m_date.FormatDate();
    wxCoord x,y,d;
    view->GetTextExtent( tmp, &x, &y, &d );
    return wxSize(x,y+d);
}

bool wxDataViewDateCell::Activate( wxRect cell, wxDataViewListModel *model, size_t col, size_t row )
{
    wxVariant variant;
    model->GetValue( variant, col, row );
    wxDateTime value = variant.GetDateTime();

    wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(
        GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
    wxPoint pos = wxGetMousePosition();
    popup->Move( pos );
    popup->Layout();
    popup->Popup( popup->m_cal );

    return true;
}

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

IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)

wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell,
    size_t model_column, int flags ) :
    wxDataViewColumnBase( title, cell, model_column, flags )
{
}

wxDataViewColumn::~wxDataViewColumn()
{
}

void wxDataViewColumn::SetTitle( const wxString &title )
{
    wxDataViewColumnBase::SetTitle( title );

}

//-----------------------------------------------------------------------------
// wxDataViewHeaderWindow
//-----------------------------------------------------------------------------

class wxDataViewHeaderWindow: public wxWindow
{
public:
    wxDataViewHeaderWindow( wxDataViewCtrl *parent,
                            wxWindowID id,
                            const wxPoint &pos = wxDefaultPosition,
                            const wxSize &size = wxDefaultSize,
                            const wxString &name = wxT("wxdataviewctrlheaderwindow") );
    ~wxDataViewHeaderWindow();

    void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
    wxDataViewCtrl *GetOwner() { return m_owner; }

    void OnPaint( wxPaintEvent &event );
    void OnMouse( wxMouseEvent &event );
    void OnSetFocus( wxFocusEvent &event );

private:
    wxDataViewCtrl      *m_owner;
    wxCursor            *m_resizeCursor;

private:
    DECLARE_DYNAMIC_CLASS(wxDataViewHeaderWindow)
    DECLARE_EVENT_TABLE()
};

IMPLEMENT_ABSTRACT_CLASS(wxDataViewHeaderWindow, wxWindow)

BEGIN_EVENT_TABLE(wxDataViewHeaderWindow,wxWindow)
    EVT_PAINT         (wxDataViewHeaderWindow::OnPaint)
    EVT_MOUSE_EVENTS  (wxDataViewHeaderWindow::OnMouse)
    EVT_SET_FOCUS     (wxDataViewHeaderWindow::OnSetFocus)
END_EVENT_TABLE()

wxDataViewHeaderWindow::wxDataViewHeaderWindow( wxDataViewCtrl *parent, wxWindowID id,
     const wxPoint &pos, const wxSize &size, const wxString &name ) :
    wxWindow( parent, id, pos, size, 0, name )
{
    SetOwner( parent );

    m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );

    wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
    SetOwnForegroundColour( attr.colFg );
    SetOwnBackgroundColour( attr.colBg );
    if (!m_hasFont)
        SetOwnFont( attr.font );
}

wxDataViewHeaderWindow::~wxDataViewHeaderWindow()
{
    delete m_resizeCursor;
}

void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
{
    wxPaintDC dc;
    PrepareDC( dc );

    int xpix;
    m_owner->GetScrollPixelsPerUnit( &xpix, NULL );

    int x;
    m_owner->GetViewStart( &x, NULL );

    // account for the horz scrollbar offset
    dc.SetDeviceOrigin( -x * xpix, 0 );

    dc.SetFont( GetFont() );

    dc.DrawText( wxT("This is the header.."), 5, 5 );
}

void wxDataViewHeaderWindow::OnMouse( wxMouseEvent &event )
{
}

void wxDataViewHeaderWindow::OnSetFocus( wxFocusEvent &event )
{
    event.Skip();
}

//-----------------------------------------------------------------------------
// wxDataViewMainWindow
//-----------------------------------------------------------------------------

class wxDataViewMainWindow: public wxWindow
{
public:
    wxDataViewMainWindow( wxDataViewCtrl *parent,
                            wxWindowID id,
                            const wxPoint &pos = wxDefaultPosition,
                            const wxSize &size = wxDefaultSize,
                            const wxString &name = wxT("wxdataviewctrlmainwindow") );
    ~wxDataViewMainWindow();

    void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
    wxDataViewCtrl *GetOwner() { return m_owner; }

    void OnPaint( wxPaintEvent &event );
    void OnMouse( wxMouseEvent &event );
    void OnSetFocus( wxFocusEvent &event );

private:
    wxDataViewCtrl      *m_owner;

private:
    DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
    DECLARE_EVENT_TABLE()
};

IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)

BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
    EVT_PAINT         (wxDataViewMainWindow::OnPaint)
    EVT_MOUSE_EVENTS  (wxDataViewMainWindow::OnMouse)
    EVT_SET_FOCUS     (wxDataViewMainWindow::OnSetFocus)
END_EVENT_TABLE()

wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
    const wxPoint &pos, const wxSize &size, const wxString &name ) :
    wxWindow( parent, id, pos, size, 0, name )
{
    SetOwner( parent );
}

wxDataViewMainWindow::~wxDataViewMainWindow()
{
}

void wxDataViewMainWindow::OnPaint( wxPaintEvent &event )
{
    wxPaintDC dc( this );

    PrepareDC( dc );

    int dev_x, dev_y;
    m_owner->CalcScrolledPosition( 0, 0, &dev_x, &dev_y );

    dc.SetFont( GetFont() );

    dc.DrawText( wxT("main window"), 5, 5 );
}

void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
{
    event.Skip();
}

void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
{
    event.Skip();
}

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

IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)

wxDataViewCtrl::~wxDataViewCtrl()
{
    if (m_notifier)
        GetModel()->RemoveNotifier( m_notifier );
}

void wxDataViewCtrl::Init()
{
    m_notifier = NULL;
}

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

#ifdef __WXMAC__
    MacSetClipChildren( true ) ;
#endif

    m_clientArea = new wxDataViewMainWindow( this, -1 );
    m_headerArea = new wxDataViewHeaderWindow( this, -1, wxDefaultPosition, wxSize(-1,25) );

    SetTargetWindow( m_clientArea );

    wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
    sizer->Add( m_headerArea, 0, wxGROW );
    sizer->Add( m_clientArea, 1, wxGROW );
    SetSizer( sizer );

    return true;
}

#ifdef __WXMSW__
WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
                                       WXWPARAM wParam,
                                       WXLPARAM lParam)
{
    WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);

#ifndef __WXWINCE__
    // we need to process arrows ourselves for scrolling
    if ( nMsg == WM_GETDLGCODE )
    {
        rc |= DLGC_WANTARROWS;
    }
#endif

    return rc;
}
#endif

void wxDataViewCtrl::ScrollWindow( int dx, int dy, const wxRect *rect )
{
    wxDataViewCtrlBase::ScrollWindow( dx, dy, rect );
    m_headerArea->ScrollWindow( dx, 0, rect );
}

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

    m_notifier = new wxGenericDataViewListModelNotifier( model );

    model->AddNotifier( m_notifier );

    return true;
}

bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
{
    if (!wxDataViewCtrlBase::AppendColumn(col))
        return false;

    return true;
}

#endif
    // !wxUSE_GENERICDATAVIEWCTRL

#endif
    // wxUSE_DATAVIEWCTRL
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: datavgen.cpp
	3	// Purpose: wxDataViewCtrl generic 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
	19	#ifdef wxUSE_GENERICDATAVIEWCTRL
	20
	21	#include "wx/stockitem.h"
	22	#include "wx/dcclient.h"
	23	#include "wx/calctrl.h"
	24	#include "wx/popupwin.h"
	25	#include "wx/sizer.h"
	26	#include "wx/log.h"
	27	#include "wx/renderer.h"
	28
	29	#ifdef __WXMSW__
	30	#include <windows.h> // for DLGC_WANTARROWS
	31	#include "wx/msw/winundef.h"
	32	#endif
	33
	34	//-----------------------------------------------------------------------------
	35	// classes
	36	//-----------------------------------------------------------------------------
	37
	38	class wxDataViewCtrl;
	39
	40	// ---------------------------------------------------------
	41	// wxGenericDataViewListModelNotifier
	42	// ---------------------------------------------------------
	43
	44	class wxGenericDataViewListModelNotifier: public wxDataViewListModelNotifier
	45	{
	46	public:
	47	wxGenericDataViewListModelNotifier( wxDataViewListModel *wx_model );
	48
	49	virtual bool RowAppended();
	50	virtual bool RowPrepended();
	51	virtual bool RowInserted( size_t before );
	52	virtual bool RowDeleted( size_t row );
	53	virtual bool RowChanged( size_t row );
	54	virtual bool ValueChanged( size_t col, size_t row );
	55	virtual bool RowsReordered( size_t *new_order );
	56	virtual bool Cleared();
	57
	58	wxDataViewListModel *m_wx_model;
	59	};
	60
	61	// ---------------------------------------------------------
	62	// wxGenericDataViewListModelNotifier
	63	// ---------------------------------------------------------
	64
	65	wxGenericDataViewListModelNotifier::wxGenericDataViewListModelNotifier(
	66	wxDataViewListModel *wx_model )
	67	{
	68	m_wx_model = wx_model;
	69	}
	70
	71	bool wxGenericDataViewListModelNotifier::RowAppended()
	72	{
	73	size_t pos = m_wx_model->GetNumberOfRows()-1;
	74
	75	return false;
	76	}
	77
	78	bool wxGenericDataViewListModelNotifier::RowPrepended()
	79	{
	80	return false;
	81	}
	82
	83	bool wxGenericDataViewListModelNotifier::RowInserted( size_t before )
	84	{
	85	return false;
	86	}
	87
	88	bool wxGenericDataViewListModelNotifier::RowDeleted( size_t row )
	89	{
	90	return false;
	91	}
	92
	93	bool wxGenericDataViewListModelNotifier::RowChanged( size_t row )
	94	{
	95	return true;
	96	}
	97
	98	bool wxGenericDataViewListModelNotifier::ValueChanged( size_t model_col, size_t model_row )
	99	{
	100	wxNode *node = GetOwner()->m_viewingColumns.GetFirst();
	101	while (node)
	102	{
	103	wxDataViewViewingColumn* viewing_column = (wxDataViewViewingColumn*) node->GetData();
	104	if (viewing_column->m_modelColumn == model_col)
	105	{
	106
	107	}
	108
	109	node = node->GetNext();
	110	}
	111
	112	return false;
	113	}
	114
	115	bool wxGenericDataViewListModelNotifier::RowsReordered( size_t *new_order )
	116	{
	117	wxNode *node = GetOwner()->m_viewingColumns.GetFirst();
	118	while (node)
	119	{
	120	wxDataViewViewingColumn* viewing_column = (wxDataViewViewingColumn*) node->GetData();
	121
	122	node = node->GetNext();
	123	}
	124
	125	return false;
	126	}
	127
	128	bool wxGenericDataViewListModelNotifier::Cleared()
	129	{
	130	return false;
	131	}
	132
	133	// ---------------------------------------------------------
	134	// wxDataViewCell
	135	// ---------------------------------------------------------
	136
	137	IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
	138
	139	wxDataViewCell::wxDataViewCell( const wxString &varianttype, wxDataViewCellMode mode ) :
	140	wxDataViewCellBase( varianttype, mode )
	141	{
	142	}
	143
	144	// ---------------------------------------------------------
	145	// wxDataViewTextCell
	146	// ---------------------------------------------------------
	147
	148	IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCell)
	149
	150	wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewCellMode mode ) :
	151	wxDataViewCell( varianttype, mode )
	152	{
	153	}
	154
	155	bool wxDataViewTextCell::SetValue( const wxVariant &value )
	156	{
	157	return false;
	158	}
	159
	160	bool wxDataViewTextCell::GetValue( wxVariant &value )
	161	{
	162	return false;
	163	}
	164
	165	// ---------------------------------------------------------
	166	// wxDataViewToggleCell
	167	// ---------------------------------------------------------
	168
	169	IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCell)
	170
	171	wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
	172	wxDataViewCellMode mode ) :
	173	wxDataViewCell( varianttype, mode )
	174	{
	175	}
	176
	177	bool wxDataViewToggleCell::SetValue( const wxVariant &value )
	178	{
	179	return false;
	180	}
	181
	182	bool wxDataViewToggleCell::GetValue( wxVariant &value )
	183	{
	184	return false;
	185	}
	186
	187	// ---------------------------------------------------------
	188	// wxDataViewCustomCell
	189	// ---------------------------------------------------------
	190
	191	IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
	192
	193	wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,
	194	wxDataViewCellMode mode ) :
	195	wxDataViewCell( varianttype, mode )
	196	{
	197	m_dc = NULL;
	198
	199	Init();
	200	}
	201
	202	bool wxDataViewCustomCell::Init()
	203	{
	204	return false;
	205	}
	206
	207	wxDataViewCustomCell::~wxDataViewCustomCell()
	208	{
	209	if (m_dc)
	210	delete m_dc;
	211	}
	212
	213	wxDC *wxDataViewCustomCell::GetDC()
	214	{
	215	if (m_dc == NULL)
	216	{
	217	if (GetOwner() == NULL)
	218	return NULL;
	219	if (GetOwner()->GetOwner() == NULL)
	220	return NULL;
	221	m_dc = new wxClientDC( GetOwner()->GetOwner() );
	222	}
	223
	224	return m_dc;
	225	}
	226
	227	// ---------------------------------------------------------
	228	// wxDataViewProgressCell
	229	// ---------------------------------------------------------
	230
	231	IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
	232
	233	wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,
	234	const wxString &varianttype, wxDataViewCellMode mode ) :
	235	wxDataViewCustomCell( varianttype, mode )
	236	{
	237	m_label = label;
	238	m_value = 0;
	239	}
	240
	241	wxDataViewProgressCell::~wxDataViewProgressCell()
	242	{
	243	}
	244
	245	bool wxDataViewProgressCell::SetValue( const wxVariant &value )
	246	{
	247	m_value = (long) value;
	248
	249	if (m_value < 0) m_value = 0;
	250	if (m_value > 100) m_value = 100;
	251
	252	return true;
	253	}
	254
	255	bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int state )
	256	{
	257	double pct = (double)m_value / 100.0;
	258	wxRect bar = cell;
	259	bar.width = (int)(cell.width * pct);
	260	dc->SetPen( *wxTRANSPARENT_PEN );
	261	dc->SetBrush( *wxBLUE_BRUSH );
	262	dc->DrawRectangle( bar );
	263
	264	dc->SetBrush( *wxTRANSPARENT_BRUSH );
	265	dc->SetPen( *wxBLACK_PEN );
	266	dc->DrawRectangle( cell );
	267
	268	return true;
	269	}
	270
	271	wxSize wxDataViewProgressCell::GetSize()
	272	{
	273	return wxSize(40,12);
	274	}
	275
	276	// ---------------------------------------------------------
	277	// wxDataViewDateCell
	278	// ---------------------------------------------------------
	279
	280	class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
	281	{
	282	public:
	283	wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
	284	wxDataViewListModel *model, size_t col, size_t row ) :
	285	wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
	286	{
	287	m_model = model;
	288	m_col = col;
	289	m_row = row;
	290	m_cal = new wxCalendarCtrl( this, -1, *value );
	291	wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
	292	sizer->Add( m_cal, 1, wxGROW );
	293	SetSizer( sizer );
	294	sizer->Fit( this );
	295	}
	296
	297	virtual void OnDismiss()
	298	{
	299	}
	300
	301	void OnCalendar( wxCalendarEvent &event );
	302
	303	wxCalendarCtrl *m_cal;
	304	wxDataViewListModel *m_model;
	305	size_t m_col;
	306	size_t m_row;
	307
	308	private:
	309	DECLARE_EVENT_TABLE()
	310	};
	311
	312	BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)
	313	EVT_CALENDAR( -1, wxDataViewDateCellPopupTransient::OnCalendar )
	314	END_EVENT_TABLE()
	315
	316	void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
	317	{
	318	wxDateTime date = event.GetDate();
	319	wxVariant value = date;
	320	m_model->SetValue( value, m_col, m_row );
	321	m_model->ValueChanged( m_col, m_row );
	322	DismissAndNotify();
	323	}
	324
	325	IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)
	326
	327	wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
	328	wxDataViewCellMode mode ) :
	329	wxDataViewCustomCell( varianttype, mode )
	330	{
	331	}
	332
	333	bool wxDataViewDateCell::SetValue( const wxVariant &value )
	334	{
	335	m_date = value.GetDateTime();
	336
	337	return true;
	338	}
	339
	340	bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int state )
	341	{
	342	dc->SetFont( GetOwner()->GetOwner()->GetFont() );
	343	wxString tmp = m_date.FormatDate();
	344	dc->DrawText( tmp, cell.x, cell.y );
	345
	346	return true;
	347	}
	348
	349	wxSize wxDataViewDateCell::GetSize()
	350	{
	351	wxDataViewCtrl* view = GetOwner()->GetOwner();
	352	wxString tmp = m_date.FormatDate();
	353	wxCoord x,y,d;
	354	view->GetTextExtent( tmp, &x, &y, &d );
	355	return wxSize(x,y+d);
	356	}
	357
	358	bool wxDataViewDateCell::Activate( wxRect cell, wxDataViewListModel *model, size_t col, size_t row )
	359	{
	360	wxVariant variant;
	361	model->GetValue( variant, col, row );
	362	wxDateTime value = variant.GetDateTime();
	363
	364	wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(
	365	GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
	366	wxPoint pos = wxGetMousePosition();
	367	popup->Move( pos );
	368	popup->Layout();
	369	popup->Popup( popup->m_cal );
	370
	371	return true;
	372	}
	373
	374	// ---------------------------------------------------------
	375	// wxDataViewColumn
	376	// ---------------------------------------------------------
	377
	378	IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
	379
	380	wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell,
	381	size_t model_column, int flags ) :
	382	wxDataViewColumnBase( title, cell, model_column, flags )
	383	{
	384	}
	385
	386	wxDataViewColumn::~wxDataViewColumn()
	387	{
	388	}
	389
	390	void wxDataViewColumn::SetTitle( const wxString &title )
	391	{
	392	wxDataViewColumnBase::SetTitle( title );
	393
	394	}
	395
	396	//-----------------------------------------------------------------------------
	397	// wxDataViewHeaderWindow
	398	//-----------------------------------------------------------------------------
	399
	400	class wxDataViewHeaderWindow: public wxWindow
	401	{
	402	public:
	403	wxDataViewHeaderWindow( wxDataViewCtrl *parent,
	404	wxWindowID id,
	405	const wxPoint &pos = wxDefaultPosition,
	406	const wxSize &size = wxDefaultSize,
	407	const wxString &name = wxT("wxdataviewctrlheaderwindow") );
	408	~wxDataViewHeaderWindow();
	409
	410	void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
	411	wxDataViewCtrl *GetOwner() { return m_owner; }
	412
	413	void OnPaint( wxPaintEvent &event );
	414	void OnMouse( wxMouseEvent &event );
	415	void OnSetFocus( wxFocusEvent &event );
	416
	417	private:
	418	wxDataViewCtrl *m_owner;
	419	wxCursor *m_resizeCursor;
	420
	421	private:
	422	DECLARE_DYNAMIC_CLASS(wxDataViewHeaderWindow)
	423	DECLARE_EVENT_TABLE()
	424	};
	425
	426	IMPLEMENT_ABSTRACT_CLASS(wxDataViewHeaderWindow, wxWindow)
	427
	428	BEGIN_EVENT_TABLE(wxDataViewHeaderWindow,wxWindow)
	429	EVT_PAINT (wxDataViewHeaderWindow::OnPaint)
	430	EVT_MOUSE_EVENTS (wxDataViewHeaderWindow::OnMouse)
	431	EVT_SET_FOCUS (wxDataViewHeaderWindow::OnSetFocus)
	432	END_EVENT_TABLE()
	433
	434	wxDataViewHeaderWindow::wxDataViewHeaderWindow( wxDataViewCtrl *parent, wxWindowID id,
	435	const wxPoint &pos, const wxSize &size, const wxString &name ) :
	436	wxWindow( parent, id, pos, size, 0, name )
	437	{
	438	SetOwner( parent );
	439
	440	m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
	441
	442	wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
	443	SetOwnForegroundColour( attr.colFg );
	444	SetOwnBackgroundColour( attr.colBg );
	445	if (!m_hasFont)
	446	SetOwnFont( attr.font );
	447	}
	448
	449	wxDataViewHeaderWindow::~wxDataViewHeaderWindow()
	450	{
	451	delete m_resizeCursor;
	452	}
	453
	454	void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
	455	{
	456	wxPaintDC dc;
	457	PrepareDC( dc );
	458
	459	int xpix;
	460	m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
	461
	462	int x;
	463	m_owner->GetViewStart( &x, NULL );
	464
	465	// account for the horz scrollbar offset
	466	dc.SetDeviceOrigin( -x * xpix, 0 );
	467
	468	dc.SetFont( GetFont() );
	469
	470	dc.DrawText( wxT("This is the header.."), 5, 5 );
	471	}
	472
	473	void wxDataViewHeaderWindow::OnMouse( wxMouseEvent &event )
	474	{
	475	}
	476
	477	void wxDataViewHeaderWindow::OnSetFocus( wxFocusEvent &event )
	478	{
	479	event.Skip();
	480	}
	481
	482	//-----------------------------------------------------------------------------
	483	// wxDataViewMainWindow
	484	//-----------------------------------------------------------------------------
	485
	486	class wxDataViewMainWindow: public wxWindow
	487	{
	488	public:
	489	wxDataViewMainWindow( wxDataViewCtrl *parent,
	490	wxWindowID id,
	491	const wxPoint &pos = wxDefaultPosition,
	492	const wxSize &size = wxDefaultSize,
	493	const wxString &name = wxT("wxdataviewctrlmainwindow") );
	494	~wxDataViewMainWindow();
	495
	496	void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
	497	wxDataViewCtrl *GetOwner() { return m_owner; }
	498
	499	void OnPaint( wxPaintEvent &event );
	500	void OnMouse( wxMouseEvent &event );
	501	void OnSetFocus( wxFocusEvent &event );
	502
	503	private:
	504	wxDataViewCtrl *m_owner;
	505
	506	private:
	507	DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
	508	DECLARE_EVENT_TABLE()
	509	};
	510
	511	IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)
	512
	513	BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
	514	EVT_PAINT (wxDataViewMainWindow::OnPaint)
	515	EVT_MOUSE_EVENTS (wxDataViewMainWindow::OnMouse)
	516	EVT_SET_FOCUS (wxDataViewMainWindow::OnSetFocus)
	517	END_EVENT_TABLE()
	518
	519	wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
	520	const wxPoint &pos, const wxSize &size, const wxString &name ) :
	521	wxWindow( parent, id, pos, size, 0, name )
	522	{
	523	SetOwner( parent );
	524	}
	525
	526	wxDataViewMainWindow::~wxDataViewMainWindow()
	527	{
	528	}
	529
	530	void wxDataViewMainWindow::OnPaint( wxPaintEvent &event )
	531	{
	532	wxPaintDC dc( this );
	533
	534	PrepareDC( dc );
	535
	536	int dev_x, dev_y;
	537	m_owner->CalcScrolledPosition( 0, 0, &dev_x, &dev_y );
	538
	539	dc.SetFont( GetFont() );
	540
	541	dc.DrawText( wxT("main window"), 5, 5 );
	542	}
	543
	544	void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
	545	{
	546	event.Skip();
	547	}
	548
	549	void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
	550	{
	551	event.Skip();
	552	}
	553
	554	//-----------------------------------------------------------------------------
	555	// wxDataViewCtrl
	556	//-----------------------------------------------------------------------------
	557
	558	IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
	559
	560	wxDataViewCtrl::~wxDataViewCtrl()
	561	{
	562	if (m_notifier)
	563	GetModel()->RemoveNotifier( m_notifier );
	564	}
	565
	566	void wxDataViewCtrl::Init()
	567	{
	568	m_notifier = NULL;
	569	}
	570
	571	bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
	572	const wxPoint& pos, const wxSize& size,
	573	long style, const wxValidator& validator )
	574	{
	575	Init();
	576
	577	#ifdef __WXMAC__
	578	MacSetClipChildren( true ) ;
	579	#endif
	580
	581	m_clientArea = new wxDataViewMainWindow( this, -1 );
	582	m_headerArea = new wxDataViewHeaderWindow( this, -1, wxDefaultPosition, wxSize(-1,25) );
	583
	584	SetTargetWindow( m_clientArea );
	585
	586	wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
	587	sizer->Add( m_headerArea, 0, wxGROW );
	588	sizer->Add( m_clientArea, 1, wxGROW );
	589	SetSizer( sizer );
	590
	591	return true;
	592	}
	593
	594	#ifdef __WXMSW__
	595	WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
	596	WXWPARAM wParam,
	597	WXLPARAM lParam)
	598	{
	599	WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
	600
	601	#ifndef __WXWINCE__
	602	// we need to process arrows ourselves for scrolling
	603	if ( nMsg == WM_GETDLGCODE )
	604	{
	605	rc \|= DLGC_WANTARROWS;
	606	}
	607	#endif
	608
	609	return rc;
	610	}
	611	#endif
	612
	613	void wxDataViewCtrl::ScrollWindow( int dx, int dy, const wxRect *rect )
	614	{
	615	wxDataViewCtrlBase::ScrollWindow( dx, dy, rect );
	616	m_headerArea->ScrollWindow( dx, 0, rect );
	617	}
	618
	619	bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
	620	{
	621	if (!wxDataViewCtrlBase::AssociateModel( model ))
	622	return false;
	623
	624	m_notifier = new wxGenericDataViewListModelNotifier( model );
	625
	626	model->AddNotifier( m_notifier );
	627
	628	return true;
	629	}
	630
	631	bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
	632	{
	633	if (!wxDataViewCtrlBase::AppendColumn(col))
	634	return false;
	635
	636	return true;
	637	}
	638
	639	#endif
	640	// !wxUSE_GENERICDATAVIEWCTRL
	641
	642	#endif
	643	// wxUSE_DATAVIEWCTRL
	644