[wxWidgets.git] / include / wx / dvrenderers.h

///////////////////////////////////////////////////////////////////////////////
// Name:        wx/dvrenderers.h
// Purpose:     Declare all wxDataViewCtrl classes
// Author:      Robert Roebling, Vadim Zeitlin
// Created:     2009-11-08 (extracted from wx/dataview.h)
// RCS-ID:      $Id$
// Copyright:   (c) 2006 Robert Roebling
//              (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifndef _WX_DVRENDERERS_H_
#define _WX_DVRENDERERS_H_

/*
    Note about the structure of various headers: they're organized in a more
    complicated way than usual because of the various dependencies which are
    different for different ports. In any case the only public header, i.e. the
    one which can be included directly is wx/dataview.h. It, in turn, includes
    this one to define all the renderer classes.

    We define the base wxDataViewRendererBase class first and then include a
    port-dependent wx/xxx/dvrenderer.h which defines wxDataViewRenderer itself.
    After this we can define wxDataViewRendererCustomBase (and maybe in the
    future base classes for other renderers if the need arises, i.e. if there
    is any non-trivial code or API which it makes sense to keep in common code)
    and include wx/xxx/dvrenderers.h (notice the plural) which defines all the
    rest of the renderer classes.
 */

class WXDLLIMPEXP_FWD_ADV wxDataViewCustomRenderer;

// ----------------------------------------------------------------------------
// wxDataViewIconText: helper class used by wxDataViewIconTextRenderer
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_ADV wxDataViewIconText : public wxObject
{
public:
    wxDataViewIconText( const wxString &text = wxEmptyString,
                        const wxIcon& icon = wxNullIcon )
        : m_text(text),
          m_icon(icon)
    { }

    wxDataViewIconText( const wxDataViewIconText &other )
        : wxObject(),
          m_text(other.m_text),
          m_icon(other.m_icon)
    { }

    void SetText( const wxString &text ) { m_text = text; }
    wxString GetText() const             { return m_text; }
    void SetIcon( const wxIcon &icon )   { m_icon = icon; }
    const wxIcon &GetIcon() const        { return m_icon; }

    bool IsSameAs(const wxDataViewIconText& other) const
    {
        return m_text == other.m_text && m_icon.IsSameAs(other.m_icon);
    }

    bool operator==(const wxDataViewIconText& other) const
    {
        return IsSameAs(other);
    }

    bool operator!=(const wxDataViewIconText& other) const
    {
        return !IsSameAs(other);
    }

private:
    wxString    m_text;
    wxIcon      m_icon;

    DECLARE_DYNAMIC_CLASS(wxDataViewIconText)
};

DECLARE_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)

// ----------------------------------------------------------------------------
// wxDataViewRendererBase
// ----------------------------------------------------------------------------

enum wxDataViewCellMode
{
    wxDATAVIEW_CELL_INERT,
    wxDATAVIEW_CELL_ACTIVATABLE,
    wxDATAVIEW_CELL_EDITABLE
};

enum wxDataViewCellRenderState
{
    wxDATAVIEW_CELL_SELECTED    = 1,
    wxDATAVIEW_CELL_PRELIT      = 2,
    wxDATAVIEW_CELL_INSENSITIVE = 4,
    wxDATAVIEW_CELL_FOCUSED     = 8
};

class WXDLLIMPEXP_ADV wxDataViewRendererBase: public wxObject
{
public:
    wxDataViewRendererBase( const wxString &varianttype,
                            wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
                            int alignment = wxDVR_DEFAULT_ALIGNMENT );
    virtual ~wxDataViewRendererBase();

    virtual bool Validate( wxVariant& WXUNUSED(value) )
        { return true; }

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

    // renderer value and attributes: SetValue() and SetAttr() are called
    // before a cell is rendered using this renderer
    virtual bool SetValue(const wxVariant& value) = 0;
    virtual bool GetValue(wxVariant& value) const = 0;

    virtual void SetAttr(const wxDataViewItemAttr& WXUNUSED(attr)) { }

    virtual void SetEnabled(bool WXUNUSED(enabled)) { }

    wxString GetVariantType() const             { return m_variantType; }

    // helper that calls SetValue and SetAttr:
    void PrepareForItem(const wxDataViewModel *model,
                        const wxDataViewItem& item, unsigned column);

    // renderer properties:
    virtual void SetMode( wxDataViewCellMode mode ) = 0;
    virtual wxDataViewCellMode GetMode() const = 0;

    // NOTE: Set/GetAlignment do not take/return a wxAlignment enum but
    //       rather an "int"; that's because for rendering cells it's allowed
    //       to combine alignment flags (e.g. wxALIGN_LEFT|wxALIGN_BOTTOM)
    virtual void SetAlignment( int align ) = 0;
    virtual int GetAlignment() const = 0;

    // enable or disable (if called with wxELLIPSIZE_NONE) replacing parts of
    // the item text (hence this only makes sense for renderers showing
    // text...) with ellipsis in order to make it fit the column width
    virtual void EnableEllipsize(wxEllipsizeMode mode = wxELLIPSIZE_MIDDLE) = 0;
    void DisableEllipsize() { EnableEllipsize(wxELLIPSIZE_NONE); }

    virtual wxEllipsizeMode GetEllipsizeMode() const = 0;

    // in-place editing
    virtual bool HasEditorCtrl() const
        { return false; }
    virtual wxWindow* CreateEditorCtrl(wxWindow * WXUNUSED(parent),
                                       wxRect WXUNUSED(labelRect),
                                       const wxVariant& WXUNUSED(value))
        { return NULL; }
    virtual bool GetValueFromEditorCtrl(wxWindow * WXUNUSED(editor),
                                        wxVariant& WXUNUSED(value))
        { return false; }

    virtual bool StartEditing( const wxDataViewItem &item, wxRect labelRect );
    virtual void CancelEditing();
    virtual bool FinishEditing();

    wxWindow *GetEditorCtrl() { return m_editorCtrl; }

    virtual bool IsCustomRenderer() const { return false; }


protected:
    // Called from {Cancel,Finish}Editing() to cleanup m_editorCtrl
    void DestroyEditControl();

    wxString                m_variantType;
    wxDataViewColumn       *m_owner;
    wxWeakRef<wxWindow>     m_editorCtrl;
    wxDataViewItem          m_item; // for m_editorCtrl

    // internal utility, may be used anywhere the window associated with the
    // renderer is required
    wxDataViewCtrl* GetView() const;

protected:
    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewRendererBase)
};

// include the real wxDataViewRenderer declaration for the native ports
#ifdef wxHAS_GENERIC_DATAVIEWCTRL
    // in the generic implementation there is no real wxDataViewRenderer, all
    // renderers are custom so it's the same as wxDataViewCustomRenderer and
    // wxDataViewCustomRendererBase derives from wxDataViewRendererBase directly
    //
    // this is a rather ugly hack but unfortunately it just doesn't seem to be
    // possible to have the same class hierarchy in all ports and avoid
    // duplicating the entire wxDataViewCustomRendererBase in the generic
    // wxDataViewRenderer class (well, we could use a mix-in but this would
    // make classes hierarchy non linear and arguably even more complex)
    #define wxDataViewCustomRendererRealBase wxDataViewRendererBase
#else
    #if defined(__WXGTK20__)
        #include "wx/gtk/dvrenderer.h"
    #elif defined(__WXMAC__)
        #include "wx/osx/dvrenderer.h"
    #else
        #error "unknown native wxDataViewCtrl implementation"
    #endif
    #define wxDataViewCustomRendererRealBase wxDataViewRenderer
#endif

// ----------------------------------------------------------------------------
// wxDataViewCustomRendererBase
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_ADV wxDataViewCustomRendererBase
    : public wxDataViewCustomRendererRealBase
{
public:
    // Constructor must specify the usual renderer parameters which we simply
    // pass to the base class
    wxDataViewCustomRendererBase(const wxString& varianttype = "string",
                                 wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
                                 int align = wxDVR_DEFAULT_ALIGNMENT)
        : wxDataViewCustomRendererRealBase(varianttype, mode, align)
    {
    }


    // Render the item using the current value (returned by GetValue()).
    virtual bool Render(wxRect cell, wxDC *dc, int state) = 0;

    // Return the size of the item appropriate to its current value.
    virtual wxSize GetSize() const = 0;

    // Define virtual function which are called when a key is pressed on the
    // item, clicked or the user starts to drag it: by default they all simply
    // return false indicating that the events are not handled

    virtual bool ActivateCell(const wxRect& cell,
                              wxDataViewModel *model,
                              const wxDataViewItem & item,
                              unsigned int col,
                              const wxMouseEvent* mouseEvent);

    // Deprecated, use (and override) ActivateCell() instead
    wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
        virtual bool Activate(wxRect WXUNUSED(cell),
                              wxDataViewModel *WXUNUSED(model),
                              const wxDataViewItem & WXUNUSED(item),
                              unsigned int WXUNUSED(col)),
                          return false; )

    // Deprecated, use (and override) ActivateCell() instead
    wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
        virtual bool LeftClick(wxPoint WXUNUSED(cursor),
                               wxRect WXUNUSED(cell),
                               wxDataViewModel *WXUNUSED(model),
                               const wxDataViewItem & WXUNUSED(item),
                               unsigned int WXUNUSED(col)),
                          return false; )

    virtual bool StartDrag(const wxPoint& WXUNUSED(cursor),
                           const wxRect& WXUNUSED(cell),
                           wxDataViewModel *WXUNUSED(model),
                           const wxDataViewItem & WXUNUSED(item),
                           unsigned int WXUNUSED(col) )
        { return false; }


    // Helper which can be used by Render() implementation in the derived
    // classes: it will draw the text in the same manner as the standard
    // renderers do.
    virtual void RenderText(const wxString& text,
                            int xoffset,
                            wxRect cell,
                            wxDC *dc,
                            int state);


    // Override the base class virtual method to simply store the attribute so
    // that it can be accessed using GetAttr() from Render() if needed.
    virtual void SetAttr(const wxDataViewItemAttr& attr) { m_attr = attr; }
    const wxDataViewItemAttr& GetAttr() const { return m_attr; }

    // Store the enabled state of the item so that it can be accessed from
    // Render() via GetEnabled() if needed.
    virtual void SetEnabled(bool enabled) { m_enabled = enabled; }
    bool GetEnabled() const { return m_enabled; }


    // Implementation only from now on

    // Retrieve the DC to use for drawing. This is implemented in derived
    // platform-specific classes.
    virtual wxDC *GetDC() = 0;

    // Prepare DC to use attributes and call Render().
    void WXCallRender(wxRect rect, wxDC *dc, int state);

    virtual bool IsCustomRenderer() const { return true; }

protected:
    // helper for GetSize() implementations, respects attributes
    wxSize GetTextExtent(const wxString& str) const;

private:
    wxDataViewItemAttr m_attr;
    bool m_enabled;

    wxDECLARE_NO_COPY_CLASS(wxDataViewCustomRendererBase);
};

// include the declaration of all the other renderers to get the real
// wxDataViewCustomRenderer from which we need to inherit below
#ifdef wxHAS_GENERIC_DATAVIEWCTRL
    // because of the different renderer classes hierarchy in the generic
    // version, as explained above, we can include the header defining
    // wxDataViewRenderer only here and not before wxDataViewCustomRendererBase
    // declaration as for the native ports
    #include "wx/generic/dvrenderer.h"
    #include "wx/generic/dvrenderers.h"
#elif defined(__WXGTK20__)
    #include "wx/gtk/dvrenderers.h"
#elif defined(__WXMAC__)
    #include "wx/osx/dvrenderers.h"
#else
    #error "unknown native wxDataViewCtrl implementation"
#endif

// ----------------------------------------------------------------------------
// wxDataViewSpinRenderer
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_ADV wxDataViewSpinRenderer: public wxDataViewCustomRenderer
{
public:
    wxDataViewSpinRenderer( int min, int max,
                            wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
                            int alignment = wxDVR_DEFAULT_ALIGNMENT );
    virtual bool HasEditorCtrl() const { return true; }
    virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
    virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
    virtual bool Render( wxRect rect, wxDC *dc, int state );
    virtual wxSize GetSize() const;
    virtual bool SetValue( const wxVariant &value );
    virtual bool GetValue( wxVariant &value ) const;

private:
    long    m_data;
    long    m_min,m_max;
};

#if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXOSX_CARBON__)

// ----------------------------------------------------------------------------
// wxDataViewChoiceRenderer
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_ADV wxDataViewChoiceRenderer: public wxDataViewCustomRenderer
{
public:
    wxDataViewChoiceRenderer( const wxArrayString &choices,
                            wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
                            int alignment = wxDVR_DEFAULT_ALIGNMENT );
    virtual bool HasEditorCtrl() const { return true; }
    virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
    virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
    virtual bool Render( wxRect rect, wxDC *dc, int state );
    virtual wxSize GetSize() const;
    virtual bool SetValue( const wxVariant &value );
    virtual bool GetValue( wxVariant &value ) const;

    wxString GetChoice(size_t index) const { return m_choices[index]; }
    const wxArrayString& GetChoices() const { return m_choices; }

private:
    wxArrayString m_choices;
    wxString      m_data;
};

// ----------------------------------------------------------------------------
// wxDataViewChoiceByIndexRenderer
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_ADV wxDataViewChoiceByIndexRenderer: public wxDataViewChoiceRenderer
{
public:
    wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
                              wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
                              int alignment = wxDVR_DEFAULT_ALIGNMENT );

    virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
    virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );

    virtual bool SetValue( const wxVariant &value );
    virtual bool GetValue( wxVariant &value ) const;
};


#endif // generic or Carbon versions

#if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXGTK__)

// ----------------------------------------------------------------------------
// wxDataViewDateRenderer
// ----------------------------------------------------------------------------

#if wxUSE_DATEPICKCTRL
class WXDLLIMPEXP_ADV wxDataViewDateRenderer: public wxDataViewCustomRenderer
{
public:
    wxDataViewDateRenderer(const wxString &varianttype = wxT("datetime"),
                           wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
                           int align = wxDVR_DEFAULT_ALIGNMENT);

    virtual bool HasEditorCtrl() const { return true; }
    virtual wxWindow *CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant &value);
    virtual bool GetValueFromEditorCtrl(wxWindow* editor, wxVariant &value);
    virtual bool SetValue(const wxVariant &value);
    virtual bool GetValue(wxVariant& value) const;
    virtual bool Render( wxRect cell, wxDC *dc, int state );
    virtual wxSize GetSize() const;

private:
    wxDateTime    m_date;
};
#else // !wxUSE_DATEPICKCTRL
typedef wxDataViewTextRenderer wxDataViewDateRenderer;
#endif

#endif // generic or GTK+ versions

// this class is obsolete, its functionality was merged in
// wxDataViewTextRenderer itself now, don't use it any more
#define wxDataViewTextRendererAttr wxDataViewTextRenderer

#endif // _WX_DVRENDERERS_H_
Commit	Line	Data
6eec70b9 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/dvrenderers.h
	3	// Purpose: Declare all wxDataViewCtrl classes
	4	// Author: Robert Roebling, Vadim Zeitlin
	5	// Created: 2009-11-08 (extracted from wx/dataview.h)
b1153ed6	6	// RCS-ID: $Id$
6eec70b9 VZ	7	// Copyright: (c) 2006 Robert Roebling
	8	// (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_DVRENDERERS_H_
	13	#define _WX_DVRENDERERS_H_
	14
	15	/*
	16	Note about the structure of various headers: they're organized in a more
	17	complicated way than usual because of the various dependencies which are
	18	different for different ports. In any case the only public header, i.e. the
	19	one which can be included directly is wx/dataview.h. It, in turn, includes
	20	this one to define all the renderer classes.
	21
	22	We define the base wxDataViewRendererBase class first and then include a
	23	port-dependent wx/xxx/dvrenderer.h which defines wxDataViewRenderer itself.
	24	After this we can define wxDataViewRendererCustomBase (and maybe in the
	25	future base classes for other renderers if the need arises, i.e. if there
	26	is any non-trivial code or API which it makes sense to keep in common code)
	27	and include wx/xxx/dvrenderers.h (notice the plural) which defines all the
	28	rest of the renderer classes.
	29	*/
	30
	31	class WXDLLIMPEXP_FWD_ADV wxDataViewCustomRenderer;
	32
	33	// ----------------------------------------------------------------------------
	34	// wxDataViewIconText: helper class used by wxDataViewIconTextRenderer
	35	// ----------------------------------------------------------------------------
	36
	37	class WXDLLIMPEXP_ADV wxDataViewIconText : public wxObject
	38	{
	39	public:
	40	wxDataViewIconText( const wxString &text = wxEmptyString,
	41	const wxIcon& icon = wxNullIcon )
	42	: m_text(text),
	43	m_icon(icon)
	44	{ }
	45
	46	wxDataViewIconText( const wxDataViewIconText &other )
	47	: wxObject(),
	48	m_text(other.m_text),
	49	m_icon(other.m_icon)
	50	{ }
	51
	52	void SetText( const wxString &text ) { m_text = text; }
	53	wxString GetText() const { return m_text; }
	54	void SetIcon( const wxIcon &icon ) { m_icon = icon; }
	55	const wxIcon &GetIcon() const { return m_icon; }
	56
60d10101 VZ	57	bool IsSameAs(const wxDataViewIconText& other) const
	58	{
	59	return m_text == other.m_text && m_icon.IsSameAs(other.m_icon);
	60	}
	61
	62	bool operator==(const wxDataViewIconText& other) const
	63	{
	64	return IsSameAs(other);
	65	}
	66
	67	bool operator!=(const wxDataViewIconText& other) const
	68	{
	69	return !IsSameAs(other);
	70	}
	71
6eec70b9 VZ	72	private:
	73	wxString m_text;
	74	wxIcon m_icon;
	75
	76	DECLARE_DYNAMIC_CLASS(wxDataViewIconText)
	77	};
	78
6eec70b9 VZ	79	DECLARE_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)
	80
	81	// ----------------------------------------------------------------------------
	82	// wxDataViewRendererBase
	83	// ----------------------------------------------------------------------------
	84
	85	enum wxDataViewCellMode
	86	{
	87	wxDATAVIEW_CELL_INERT,
	88	wxDATAVIEW_CELL_ACTIVATABLE,
	89	wxDATAVIEW_CELL_EDITABLE
	90	};
	91
	92	enum wxDataViewCellRenderState
	93	{
	94	wxDATAVIEW_CELL_SELECTED = 1,
	95	wxDATAVIEW_CELL_PRELIT = 2,
	96	wxDATAVIEW_CELL_INSENSITIVE = 4,
	97	wxDATAVIEW_CELL_FOCUSED = 8
	98	};
	99
	100	class WXDLLIMPEXP_ADV wxDataViewRendererBase: public wxObject
	101	{
	102	public:
	103	wxDataViewRendererBase( const wxString &varianttype,
	104	wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
	105	int alignment = wxDVR_DEFAULT_ALIGNMENT );
	106	virtual ~wxDataViewRendererBase();
	107
	108	virtual bool Validate( wxVariant& WXUNUSED(value) )
	109	{ return true; }
	110
	111	void SetOwner( wxDataViewColumn *owner ) { m_owner = owner; }
	112	wxDataViewColumn* GetOwner() const { return m_owner; }
	113
62265c2c VZ	114	// renderer value and attributes: SetValue() and SetAttr() are called
	115	// before a cell is rendered using this renderer
	116	virtual bool SetValue(const wxVariant& value) = 0;
	117	virtual bool GetValue(wxVariant& value) const = 0;
6eec70b9	118
62265c2c	119	virtual void SetAttr(const wxDataViewItemAttr& WXUNUSED(attr)) { }
6eec70b9	120
98f8e666 VZ	121	virtual void SetEnabled(bool WXUNUSED(enabled)) { }
98f8e666 VZ	122
6eec70b9 VZ	123	wxString GetVariantType() const { return m_variantType; }
6eec70b9 VZ	124
f0ccd2cb VS	125	// helper that calls SetValue and SetAttr:
	126	void PrepareForItem(const wxDataViewModel *model,
	127	const wxDataViewItem& item, unsigned column);
	128
62265c2c	129	// renderer properties:
6eec70b9 VZ	130	virtual void SetMode( wxDataViewCellMode mode ) = 0;
	131	virtual wxDataViewCellMode GetMode() const = 0;
	132
	133	// NOTE: Set/GetAlignment do not take/return a wxAlignment enum but
	134	// rather an "int"; that's because for rendering cells it's allowed
	135	// to combine alignment flags (e.g. wxALIGN_LEFT\|wxALIGN_BOTTOM)
	136	virtual void SetAlignment( int align ) = 0;
	137	virtual int GetAlignment() const = 0;
	138
	139	// enable or disable (if called with wxELLIPSIZE_NONE) replacing parts of
	140	// the item text (hence this only makes sense for renderers showing
	141	// text...) with ellipsis in order to make it fit the column width
	142	virtual void EnableEllipsize(wxEllipsizeMode mode = wxELLIPSIZE_MIDDLE) = 0;
	143	void DisableEllipsize() { EnableEllipsize(wxELLIPSIZE_NONE); }
	144
	145	virtual wxEllipsizeMode GetEllipsizeMode() const = 0;
	146
	147	// in-place editing
	148	virtual bool HasEditorCtrl() const
	149	{ return false; }
64c70359 VS	150	virtual wxWindow* CreateEditorCtrl(wxWindow * WXUNUSED(parent),
	151	wxRect WXUNUSED(labelRect),
	152	const wxVariant& WXUNUSED(value))
6eec70b9	153	{ return NULL; }
64c70359	154	virtual bool GetValueFromEditorCtrl(wxWindow * WXUNUSED(editor),
6eec70b9 VZ	155	wxVariant& WXUNUSED(value))
	156	{ return false; }
	157
	158	virtual bool StartEditing( const wxDataViewItem &item, wxRect labelRect );
	159	virtual void CancelEditing();
	160	virtual bool FinishEditing();
	161
64c70359	162	wxWindow *GetEditorCtrl() { return m_editorCtrl; }
6eec70b9	163
f8816e49 RD	164	virtual bool IsCustomRenderer() const { return false; }
	165
	166
6eec70b9	167	protected:
66c02e6e VZ	168	// Called from {Cancel,Finish}Editing() to cleanup m_editorCtrl
	169	void DestroyEditControl();
	170
6eec70b9 VZ	171	wxString m_variantType;
6eec70b9 VZ	172	wxDataViewColumn *m_owner;
64c70359	173	wxWeakRef<wxWindow> m_editorCtrl;
6eec70b9 VZ	174	wxDataViewItem m_item; // for m_editorCtrl
6eec70b9 VZ	175
dbab29b9 VZ	176	// internal utility, may be used anywhere the window associated with the
	177	// renderer is required
	178	wxDataViewCtrl* GetView() const;
6eec70b9 VZ	179
	180	protected:
	181	DECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewRendererBase)
	182	};
	183
	184	// include the real wxDataViewRenderer declaration for the native ports
	185	#ifdef wxHAS_GENERIC_DATAVIEWCTRL
	186	// in the generic implementation there is no real wxDataViewRenderer, all
	187	// renderers are custom so it's the same as wxDataViewCustomRenderer and
	188	// wxDataViewCustomRendererBase derives from wxDataViewRendererBase directly
	189	//
	190	// this is a rather ugly hack but unfortunately it just doesn't seem to be
	191	// possible to have the same class hierarchy in all ports and avoid
	192	// duplicating the entire wxDataViewCustomRendererBase in the generic
	193	// wxDataViewRenderer class (well, we could use a mix-in but this would
	194	// make classes hierarchy non linear and arguably even more complex)
	195	#define wxDataViewCustomRendererRealBase wxDataViewRendererBase
	196	#else
	197	#if defined(__WXGTK20__)
	198	#include "wx/gtk/dvrenderer.h"
	199	#elif defined(__WXMAC__)
	200	#include "wx/osx/dvrenderer.h"
	201	#else
	202	#error "unknown native wxDataViewCtrl implementation"
	203	#endif
	204	#define wxDataViewCustomRendererRealBase wxDataViewRenderer
	205	#endif
	206
	207	// ----------------------------------------------------------------------------
	208	// wxDataViewCustomRendererBase
	209	// ----------------------------------------------------------------------------
	210
	211	class WXDLLIMPEXP_ADV wxDataViewCustomRendererBase
	212	: public wxDataViewCustomRendererRealBase
	213	{
	214	public:
	215	// Constructor must specify the usual renderer parameters which we simply
	216	// pass to the base class
	217	wxDataViewCustomRendererBase(const wxString& varianttype = "string",
	218	wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
	219	int align = wxDVR_DEFAULT_ALIGNMENT)
	220	: wxDataViewCustomRendererRealBase(varianttype, mode, align)
	221	{
	222	}
	223
	224
62265c2c VZ	225	// Render the item using the current value (returned by GetValue()).
	226	virtual bool Render(wxRect cell, wxDC *dc, int state) = 0;
	227
	228	// Return the size of the item appropriate to its current value.
	229	virtual wxSize GetSize() const = 0;
	230
dc73d7f5 VS	231	// Define virtual function which are called when a key is pressed on the
	232	// item, clicked or the user starts to drag it: by default they all simply
	233	// return false indicating that the events are not handled
	234
	235	virtual bool ActivateCell(const wxRect& cell,
	236	wxDataViewModel *model,
	237	const wxDataViewItem & item,
	238	unsigned int col,
fb57a95e	239	const wxMouseEvent* mouseEvent);
6eec70b9	240
dc73d7f5 VS	241	// Deprecated, use (and override) ActivateCell() instead
	242	wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
	243	virtual bool Activate(wxRect WXUNUSED(cell),
	244	wxDataViewModel *WXUNUSED(model),
	245	const wxDataViewItem & WXUNUSED(item),
	246	unsigned int WXUNUSED(col)),
	247	return false; )
	248
	249	// Deprecated, use (and override) ActivateCell() instead
	250	wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
	251	virtual bool LeftClick(wxPoint WXUNUSED(cursor),
	252	wxRect WXUNUSED(cell),
	253	wxDataViewModel *WXUNUSED(model),
	254	const wxDataViewItem & WXUNUSED(item),
	255	unsigned int WXUNUSED(col)),
	256	return false; )
6eec70b9	257
548fa9c1 VS	258	virtual bool StartDrag(const wxPoint& WXUNUSED(cursor),
548fa9c1 VS	259	const wxRect& WXUNUSED(cell),
6eec70b9 VZ	260	wxDataViewModel *WXUNUSED(model),
	261	const wxDataViewItem & WXUNUSED(item),
	262	unsigned int WXUNUSED(col) )
	263	{ return false; }
	264
	265
62265c2c VZ	266	// Helper which can be used by Render() implementation in the derived
	267	// classes: it will draw the text in the same manner as the standard
	268	// renderers do.
	269	virtual void RenderText(const wxString& text,
	270	int xoffset,
	271	wxRect cell,
	272	wxDC *dc,
	273	int state);
	274
	275
	276	// Override the base class virtual method to simply store the attribute so
	277	// that it can be accessed using GetAttr() from Render() if needed.
	278	virtual void SetAttr(const wxDataViewItemAttr& attr) { m_attr = attr; }
	279	const wxDataViewItemAttr& GetAttr() const { return m_attr; }
	280
98f8e666 VZ	281	// Store the enabled state of the item so that it can be accessed from
	282	// Render() via GetEnabled() if needed.
	283	virtual void SetEnabled(bool enabled) { m_enabled = enabled; }
	284	bool GetEnabled() const { return m_enabled; }
	285
62265c2c VZ	286
	287	// Implementation only from now on
	288
	289	// Retrieve the DC to use for drawing. This is implemented in derived
	290	// platform-specific classes.
	291	virtual wxDC *GetDC() = 0;
	292
	293	// Prepare DC to use attributes and call Render().
	294	void WXCallRender(wxRect rect, wxDC *dc, int state);
	295
f8816e49 RD	296	virtual bool IsCustomRenderer() const { return true; }
f8816e49 RD	297
86755098 VS	298	protected:
	299	// helper for GetSize() implementations, respects attributes
	300	wxSize GetTextExtent(const wxString& str) const;
	301
6eec70b9	302	private:
62265c2c	303	wxDataViewItemAttr m_attr;
98f8e666	304	bool m_enabled;
62265c2c	305
6eec70b9 VZ	306	wxDECLARE_NO_COPY_CLASS(wxDataViewCustomRendererBase);
	307	};
	308
	309	// include the declaration of all the other renderers to get the real
	310	// wxDataViewCustomRenderer from which we need to inherit below
	311	#ifdef wxHAS_GENERIC_DATAVIEWCTRL
	312	// because of the different renderer classes hierarchy in the generic
	313	// version, as explained above, we can include the header defining
	314	// wxDataViewRenderer only here and not before wxDataViewCustomRendererBase
	315	// declaration as for the native ports
	316	#include "wx/generic/dvrenderer.h"
	317	#include "wx/generic/dvrenderers.h"
	318	#elif defined(__WXGTK20__)
	319	#include "wx/gtk/dvrenderers.h"
	320	#elif defined(__WXMAC__)
	321	#include "wx/osx/dvrenderers.h"
	322	#else
	323	#error "unknown native wxDataViewCtrl implementation"
	324	#endif
	325
	326	// ----------------------------------------------------------------------------
	327	// wxDataViewSpinRenderer
	328	// ----------------------------------------------------------------------------
	329
	330	class WXDLLIMPEXP_ADV wxDataViewSpinRenderer: public wxDataViewCustomRenderer
	331	{
	332	public:
	333	wxDataViewSpinRenderer( int min, int max,
	334	wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
	335	int alignment = wxDVR_DEFAULT_ALIGNMENT );
	336	virtual bool HasEditorCtrl() const { return true; }
64c70359 VS	337	virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
64c70359 VS	338	virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
6eec70b9 VZ	339	virtual bool Render( wxRect rect, wxDC *dc, int state );
	340	virtual wxSize GetSize() const;
	341	virtual bool SetValue( const wxVariant &value );
	342	virtual bool GetValue( wxVariant &value ) const;
	343
	344	private:
	345	long m_data;
	346	long m_min,m_max;
	347	};
	348
	349	#if defined(wxHAS_GENERIC_DATAVIEWCTRL) \|\| defined(__WXOSX_CARBON__)
	350
	351	// ----------------------------------------------------------------------------
	352	// wxDataViewChoiceRenderer
	353	// ----------------------------------------------------------------------------
	354
	355	class WXDLLIMPEXP_ADV wxDataViewChoiceRenderer: public wxDataViewCustomRenderer
	356	{
	357	public:
	358	wxDataViewChoiceRenderer( const wxArrayString &choices,
	359	wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
	360	int alignment = wxDVR_DEFAULT_ALIGNMENT );
	361	virtual bool HasEditorCtrl() const { return true; }
64c70359 VS	362	virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
64c70359 VS	363	virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
6eec70b9 VZ	364	virtual bool Render( wxRect rect, wxDC *dc, int state );
	365	virtual wxSize GetSize() const;
	366	virtual bool SetValue( const wxVariant &value );
	367	virtual bool GetValue( wxVariant &value ) const;
	368
6bb6cc1e RR	369	wxString GetChoice(size_t index) const { return m_choices[index]; }
	370	const wxArrayString& GetChoices() const { return m_choices; }
	371
6eec70b9 VZ	372	private:
	373	wxArrayString m_choices;
	374	wxString m_data;
	375	};
	376
79a53c39	377	// ----------------------------------------------------------------------------
65887bd0	378	// wxDataViewChoiceByIndexRenderer
79a53c39 RR	379	// ----------------------------------------------------------------------------
79a53c39 RR	380
65887bd0	381	class WXDLLIMPEXP_ADV wxDataViewChoiceByIndexRenderer: public wxDataViewChoiceRenderer
79a53c39 RR	382	{
79a53c39 RR	383	public:
65887bd0	384	wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
79a53c39	385	wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
65887bd0	386	int alignment = wxDVR_DEFAULT_ALIGNMENT );
ce00f59b	387
64c70359 VS	388	virtual wxWindow* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
64c70359 VS	389	virtual bool GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value );
ce00f59b	390
65887bd0 RR	391	virtual bool SetValue( const wxVariant &value );
65887bd0 RR	392	virtual bool GetValue( wxVariant &value ) const;
79a53c39 RR	393	};
	394
	395
65887bd0 RR	396	#endif // generic or Carbon versions
65887bd0 RR	397
1d3a930e VS	398	#if defined(wxHAS_GENERIC_DATAVIEWCTRL) \|\| defined(__WXGTK__)
	399
	400	// ----------------------------------------------------------------------------
	401	// wxDataViewDateRenderer
	402	// ----------------------------------------------------------------------------
	403
	404	#if wxUSE_DATEPICKCTRL
	405	class WXDLLIMPEXP_ADV wxDataViewDateRenderer: public wxDataViewCustomRenderer
	406	{
	407	public:
	408	wxDataViewDateRenderer(const wxString &varianttype = wxT("datetime"),
	409	wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
	410	int align = wxDVR_DEFAULT_ALIGNMENT);
	411
	412	virtual bool HasEditorCtrl() const { return true; }
	413	virtual wxWindow CreateEditorCtrl(wxWindow parent, wxRect labelRect, const wxVariant &value);
	414	virtual bool GetValueFromEditorCtrl(wxWindow* editor, wxVariant &value);
	415	virtual bool SetValue(const wxVariant &value);
	416	virtual bool GetValue(wxVariant& value) const;
	417	virtual bool Render( wxRect cell, wxDC *dc, int state );
	418	virtual wxSize GetSize() const;
	419
	420	private:
	421	wxDateTime m_date;
	422	};
	423	#else // !wxUSE_DATEPICKCTRL
	424	typedef wxDataViewTextRenderer wxDataViewDateRenderer;
	425	#endif
	426
	427	#endif // generic or GTK+ versions
	428
6eec70b9 VZ	429	// this class is obsolete, its functionality was merged in
	430	// wxDataViewTextRenderer itself now, don't use it any more
	431	#define wxDataViewTextRendererAttr wxDataViewTextRenderer
	432
	433	#endif // _WX_DVRENDERERS_H_
	434