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

///////////////////////////////////////////////////////////////////////////////
// Name:        wx/renderer.h
// Purpose:     wxRendererNative class declaration
// Author:      Vadim Zeitlin
// Modified by:
// Created:     20.07.2003
// RCS-ID:      $Id$
// Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

/*
   Renderers are used in wxWidgets for two similar but different things:
    (a) wxUniversal uses them to draw everything, i.e. all the control
    (b) all the native ports use them to draw generic controls only

   wxUniversal needs more functionality than what is included in the base class
   as it needs to draw stuff like scrollbars which are never going to be
   generic. So we put the bare minimum needed by the native ports here and the
   full wxRenderer class is declared in wx/univ/renderer.h and is only used by
   wxUniveral (although note that native ports can load wxRenderer objects from
   theme DLLs and use them as wxRendererNative ones, of course).
 */

#ifndef _WX_RENDERER_H_
#define _WX_RENDERER_H_

class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxWindow;

#include "wx/gdicmn.h" // for wxPoint
#include "wx/colour.h"
#include "wx/font.h"
#include "wx/bitmap.h"
#include "wx/string.h"

// some platforms have their own renderers, others use the generic one
#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK__)
    #define wxHAS_NATIVE_RENDERER
#else
    #undef wxHAS_NATIVE_RENDERER
#endif

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// control state flags used in wxRenderer and wxColourScheme
enum
{
    wxCONTROL_DISABLED   = 0x00000001,  // control is disabled
    wxCONTROL_FOCUSED    = 0x00000002,  // currently has keyboard focus
    wxCONTROL_PRESSED    = 0x00000004,  // (button) is pressed
    wxCONTROL_SPECIAL    = 0x00000008,  // control-specific bit:
    wxCONTROL_ISDEFAULT  = wxCONTROL_SPECIAL, // only for the buttons
    wxCONTROL_ISSUBMENU  = wxCONTROL_SPECIAL, // only for the menu items
    wxCONTROL_EXPANDED   = wxCONTROL_SPECIAL, // only for the tree items
    wxCONTROL_SIZEGRIP   = wxCONTROL_SPECIAL, // only for the status bar panes
    wxCONTROL_FLAT       = wxCONTROL_SPECIAL, // checkboxes only: flat border
    wxCONTROL_CURRENT    = 0x00000010,  // mouse is currently over the control
    wxCONTROL_SELECTED   = 0x00000020,  // selected item in e.g. listbox
    wxCONTROL_CHECKED    = 0x00000040,  // (check/radio button) is checked
    wxCONTROL_CHECKABLE  = 0x00000080,  // (menu) item can be checked
    wxCONTROL_UNDETERMINED = wxCONTROL_CHECKABLE, // (check) undetermined state

    wxCONTROL_FLAGS_MASK = 0x000000ff,

    // this is a pseudo flag not used directly by wxRenderer but rather by some
    // controls internally
    wxCONTROL_DIRTY      = 0x80000000
};

// ----------------------------------------------------------------------------
// helper structs
// ----------------------------------------------------------------------------

// wxSplitterWindow parameters
struct WXDLLEXPORT wxSplitterRenderParams
{
    // the only way to initialize this struct is by using this ctor
    wxSplitterRenderParams(wxCoord widthSash_, wxCoord border_, bool isSens_)
        : widthSash(widthSash_), border(border_), isHotSensitive(isSens_)
        {
        }

    // the width of the splitter sash
    const wxCoord widthSash;

    // the width of the border of the splitter window
    const wxCoord border;

    // true if the splitter changes its appearance when the mouse is over it
    const bool isHotSensitive;
};


// extra optional parameters for DrawHeaderButton
struct WXDLLEXPORT wxHeaderButtonParams
{
    wxHeaderButtonParams()
        : m_labelAlignment(wxALIGN_LEFT)
    { }

    wxColour    m_arrowColour;
    wxColour    m_selectionColour;
    wxString    m_labelText;
    wxFont      m_labelFont;
    wxColour    m_labelColour;
    wxBitmap    m_labelBitmap;
    int         m_labelAlignment;
};

enum wxHeaderSortIconType {
    wxHDR_SORT_ICON_NONE,        // Header button has no sort arrow
    wxHDR_SORT_ICON_UP,          // Header button an an up sort arrow icon
    wxHDR_SORT_ICON_DOWN         // Header button an a down sort arrow icon
};


// wxRendererNative interface version
struct WXDLLEXPORT wxRendererVersion
{
    wxRendererVersion(int version_, int age_) : version(version_), age(age_) { }

    // default copy ctor, assignment operator and dtor are ok

    // the current version and age of wxRendererNative interface: different
    // versions are incompatible (in both ways) while the ages inside the same
    // version are upwards compatible, i.e. the version of the renderer must
    // match the version of the main program exactly while the age may be
    // highergreater or equal to it
    //
    // NB: don't forget to increment age after adding any new virtual function!
    enum
    {
        Current_Version = 1,
        Current_Age = 5
    };


    // check if the given version is compatible with the current one
    static bool IsCompatible(const wxRendererVersion& ver)
    {
        return ver.version == Current_Version && ver.age >= Current_Age;
    }

    const int version;
    const int age;
};

// ----------------------------------------------------------------------------
// wxRendererNative: abstracts drawing methods needed by the native controls
// ----------------------------------------------------------------------------

class WXDLLEXPORT wxRendererNative
{
public:
    // drawing functions
    // -----------------

    // draw the header control button (used by wxListCtrl) Returns optimal
    // width for the label contents.
    virtual int  DrawHeaderButton(wxWindow *win,
                                  wxDC& dc,
                                  const wxRect& rect,
                                  int flags = 0,
                                  wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
                                  wxHeaderButtonParams* params=NULL) = 0;


    // Draw the contents of a header control button (label, sort arrows, etc.)
    // Normally only called by DrawHeaderButton.
    virtual int  DrawHeaderButtonContents(wxWindow *win,
                                          wxDC& dc,
                                          const wxRect& rect,
                                          int flags = 0,
                                          wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
                                          wxHeaderButtonParams* params=NULL) = 0;

    // Returns the default height of a header button, either a fixed platform
    // height if available, or a generic height based on the window's font.
    virtual int GetHeaderButtonHeight(wxWindow *win) = 0;


    // draw the expanded/collapsed icon for a tree control item
    virtual void DrawTreeItemButton(wxWindow *win,
                                    wxDC& dc,
                                    const wxRect& rect,
                                    int flags = 0) = 0;

    // draw the border for sash window: this border must be such that the sash
    // drawn by DrawSash() blends into it well
    virtual void DrawSplitterBorder(wxWindow *win,
                                    wxDC& dc,
                                    const wxRect& rect,
                                    int flags = 0) = 0;

    // draw a (vertical) sash
    virtual void DrawSplitterSash(wxWindow *win,
                                  wxDC& dc,
                                  const wxSize& size,
                                  wxCoord position,
                                  wxOrientation orient,
                                  int flags = 0) = 0;

    // draw a combobox dropdown button
    //
    // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
    virtual void DrawComboBoxDropButton(wxWindow *win,
                                        wxDC& dc,
                                        const wxRect& rect,
                                        int flags = 0) = 0;

    // draw a dropdown arrow
    //
    // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
    virtual void DrawDropArrow(wxWindow *win,
                               wxDC& dc,
                               const wxRect& rect,
                               int flags = 0) = 0;

    // draw check button
    //
    // flags may use wxCONTROL_CHECKED, wxCONTROL_UNDETERMINED and wxCONTROL_CURRENT
    virtual void DrawCheckBox(wxWindow *win,
                              wxDC& dc,
                              const wxRect& rect,
                              int flags = 0) = 0;

    // draw blank button
    //
    // flags may use wxCONTROL_PRESSED, wxCONTROL_CURRENT and wxCONTROL_ISDEFAULT
    virtual void DrawPushButton(wxWindow *win,
                                wxDC& dc,
                                const wxRect& rect,
                                int flags = 0) = 0;

    // draw rectangle indicating that an item in e.g. a list control
    // has been selected or focused
    //
    // flags may use
    // wxCONTROL_SELECTED (item is selected, e.g. draw background)
    // wxCONTROL_CURRENT (item is the current item, e.g. dotted border)
    // wxCONTROL_FOCUSED (the whole control has focus, e.g. blue background vs. grey otherwise)
    virtual void DrawItemSelectionRect(wxWindow *win,
                                       wxDC& dc,
                                       const wxRect& rect,
                                       int flags = 0) = 0;

    // geometry functions
    // ------------------

    // get the splitter parameters: the x field of the returned point is the
    // sash width and the y field is the border width
    virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win) = 0;


    // pseudo constructors
    // -------------------

    // return the currently used renderer
    static wxRendererNative& Get();

    // return the generic implementation of the renderer
    static wxRendererNative& GetGeneric();

    // return the default (native) implementation for this platform
    static wxRendererNative& GetDefault();


    // changing the global renderer
    // ----------------------------

#if wxUSE_DYNLIB_CLASS
    // load the renderer from the specified DLL, the returned pointer must be
    // deleted by caller if not NULL when it is not used any more
    static wxRendererNative *Load(const wxString& name);
#endif // wxUSE_DYNLIB_CLASS

    // set the renderer to use, passing NULL reverts to using the default
    // renderer
    //
    // return the previous renderer used with Set() or NULL if none
    static wxRendererNative *Set(wxRendererNative *renderer);


    // miscellaneous stuff
    // -------------------

    // this function is used for version checking: Load() refuses to load any
    // DLLs implementing an older or incompatible version; it should be
    // implemented simply by returning wxRendererVersion::Current_XXX values
    virtual wxRendererVersion GetVersion() const = 0;

    // virtual dtor for any base class
    virtual ~wxRendererNative();
};

// ----------------------------------------------------------------------------
// wxDelegateRendererNative: allows reuse of renderers code
// ----------------------------------------------------------------------------

class WXDLLEXPORT wxDelegateRendererNative : public wxRendererNative
{
public:
    wxDelegateRendererNative()
        : m_rendererNative(GetGeneric()) { }

    wxDelegateRendererNative(wxRendererNative& rendererNative)
        : m_rendererNative(rendererNative) { }


    virtual int  DrawHeaderButton(wxWindow *win,
                                  wxDC& dc,
                                  const wxRect& rect,
                                  int flags = 0,
                                  wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
                                  wxHeaderButtonParams* params = NULL)
        { return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params); }

    virtual int  DrawHeaderButtonContents(wxWindow *win,
                                          wxDC& dc,
                                          const wxRect& rect,
                                          int flags = 0,
                                          wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
                                          wxHeaderButtonParams* params = NULL)
        { return m_rendererNative.DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }

    virtual int GetHeaderButtonHeight(wxWindow *win)
        { return m_rendererNative.GetHeaderButtonHeight(win); }

    virtual void DrawTreeItemButton(wxWindow *win,
                                    wxDC& dc,
                                    const wxRect& rect,
                                    int flags = 0)
        { m_rendererNative.DrawTreeItemButton(win, dc, rect, flags); }

    virtual void DrawSplitterBorder(wxWindow *win,
                                    wxDC& dc,
                                    const wxRect& rect,
                                    int flags = 0)
        { m_rendererNative.DrawSplitterBorder(win, dc, rect, flags); }

    virtual void DrawSplitterSash(wxWindow *win,
                                  wxDC& dc,
                                  const wxSize& size,
                                  wxCoord position,
                                  wxOrientation orient,
                                  int flags = 0)
        { m_rendererNative.DrawSplitterSash(win, dc, size,
                                            position, orient, flags); }

    virtual void DrawComboBoxDropButton(wxWindow *win,
                                        wxDC& dc,
                                        const wxRect& rect,
                                        int flags = 0)
        { m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags); }

    virtual void DrawDropArrow(wxWindow *win,
                               wxDC& dc,
                               const wxRect& rect,
                               int flags = 0)
        { m_rendererNative.DrawDropArrow(win, dc, rect, flags); }

    virtual void DrawCheckBox(wxWindow *win,
                              wxDC& dc,
                              const wxRect& rect,
                              int flags = 0 )
        { m_rendererNative.DrawCheckBox( win, dc, rect, flags ); }

    virtual void DrawPushButton(wxWindow *win,
                                wxDC& dc,
                                const wxRect& rect,
                                int flags = 0 )
        { m_rendererNative.DrawPushButton( win, dc, rect, flags ); }

    virtual void DrawItemSelectionRect(wxWindow *win,
                                       wxDC& dc,
                                       const wxRect& rect,
                                       int flags = 0 )
        { m_rendererNative.DrawItemSelectionRect( win, dc, rect, flags ); }

    virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win)
        { return m_rendererNative.GetSplitterParams(win); }

    virtual wxRendererVersion GetVersion() const
        { return m_rendererNative.GetVersion(); }

protected:
    wxRendererNative& m_rendererNative;

    DECLARE_NO_COPY_CLASS(wxDelegateRendererNative)
};

// ----------------------------------------------------------------------------
// inline functions implementation
// ----------------------------------------------------------------------------

#ifndef wxHAS_NATIVE_RENDERER

// default native renderer is the generic one then
/* static */ inline
wxRendererNative& wxRendererNative::GetDefault()
{
    return GetGeneric();
}

#endif // !wxHAS_NATIVE_RENDERER

#endif // _WX_RENDERER_H_
Commit	Line	Data
9c7f49f5 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/renderer.h
	3	// Purpose: wxRendererNative class declaration
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 20.07.2003
	7	// RCS-ID: $Id$
77ffb593	8	// Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>
65571936	9	// Licence: wxWindows licence
9c7f49f5 VZ	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	/*
77ffb593	13	Renderers are used in wxWidgets for two similar but different things:
9c7f49f5 VZ	14	(a) wxUniversal uses them to draw everything, i.e. all the control
	15	(b) all the native ports use them to draw generic controls only
	16
	17	wxUniversal needs more functionality than what is included in the base class
	18	as it needs to draw stuff like scrollbars which are never going to be
	19	generic. So we put the bare minimum needed by the native ports here and the
	20	full wxRenderer class is declared in wx/univ/renderer.h and is only used by
	21	wxUniveral (although note that native ports can load wxRenderer objects from
	22	theme DLLs and use them as wxRendererNative ones, of course).
	23	*/
	24
	25	#ifndef _WX_RENDERER_H_
	26	#define _WX_RENDERER_H_
	27
b5dbe15d VS	28	class WXDLLIMPEXP_FWD_CORE wxDC;
b5dbe15d VS	29	class WXDLLIMPEXP_FWD_CORE wxWindow;
38c4cb6a	30
7df07b10	31	#include "wx/gdicmn.h" // for wxPoint
0856300f WS	32	#include "wx/colour.h"
	33	#include "wx/font.h"
	34	#include "wx/bitmap.h"
	35	#include "wx/string.h"
7df07b10	36
f0244295	37	// some platforms have their own renderers, others use the generic one
82ef81ed	38	#if defined(__WXMSW__) \|\| defined(__WXMAC__) \|\| defined(__WXGTK__)
f0244295 VZ	39	#define wxHAS_NATIVE_RENDERER
	40	#else
	41	#undef wxHAS_NATIVE_RENDERER
	42	#endif
	43
9c7f49f5 VZ	44	// ----------------------------------------------------------------------------
	45	// constants
	46	// ----------------------------------------------------------------------------
	47
	48	// control state flags used in wxRenderer and wxColourScheme
	49	enum
	50	{
	51	wxCONTROL_DISABLED = 0x00000001, // control is disabled
	52	wxCONTROL_FOCUSED = 0x00000002, // currently has keyboard focus
	53	wxCONTROL_PRESSED = 0x00000004, // (button) is pressed
fb61f58a VZ	54	wxCONTROL_SPECIAL = 0x00000008, // control-specific bit:
	55	wxCONTROL_ISDEFAULT = wxCONTROL_SPECIAL, // only for the buttons
	56	wxCONTROL_ISSUBMENU = wxCONTROL_SPECIAL, // only for the menu items
	57	wxCONTROL_EXPANDED = wxCONTROL_SPECIAL, // only for the tree items
	58	wxCONTROL_SIZEGRIP = wxCONTROL_SPECIAL, // only for the status bar panes
8a461249	59	wxCONTROL_FLAT = wxCONTROL_SPECIAL, // checkboxes only: flat border
9c7f49f5 VZ	60	wxCONTROL_CURRENT = 0x00000010, // mouse is currently over the control
	61	wxCONTROL_SELECTED = 0x00000020, // selected item in e.g. listbox
	62	wxCONTROL_CHECKED = 0x00000040, // (check/radio button) is checked
	63	wxCONTROL_CHECKABLE = 0x00000080, // (menu) item can be checked
415a0ff1	64	wxCONTROL_UNDETERMINED = wxCONTROL_CHECKABLE, // (check) undetermined state
9c7f49f5	65
a61c9122	66	wxCONTROL_FLAGS_MASK = 0x000000ff,
9c7f49f5 VZ	67
	68	// this is a pseudo flag not used directly by wxRenderer but rather by some
	69	// controls internally
	70	wxCONTROL_DIRTY = 0x80000000
	71	};
	72
af99040c VZ	73	// ----------------------------------------------------------------------------
	74	// helper structs
	75	// ----------------------------------------------------------------------------
	76
	77	// wxSplitterWindow parameters
	78	struct WXDLLEXPORT wxSplitterRenderParams
	79	{
	80	// the only way to initialize this struct is by using this ctor
	81	wxSplitterRenderParams(wxCoord widthSash_, wxCoord border_, bool isSens_)
	82	: widthSash(widthSash_), border(border_), isHotSensitive(isSens_)
	83	{
	84	}
	85
	86	// the width of the splitter sash
	87	const wxCoord widthSash;
	88
	89	// the width of the border of the splitter window
	90	const wxCoord border;
	91
	92	// true if the splitter changes its appearance when the mouse is over it
	93	const bool isHotSensitive;
	94	};
	95
4b94ddc4 RD	96
	97	// extra optional parameters for DrawHeaderButton
	98	struct WXDLLEXPORT wxHeaderButtonParams
	99	{
	100	wxHeaderButtonParams()
	101	: m_labelAlignment(wxALIGN_LEFT)
	102	{ }
0856300f	103
4b94ddc4 RD	104	wxColour m_arrowColour;
	105	wxColour m_selectionColour;
	106	wxString m_labelText;
	107	wxFont m_labelFont;
	108	wxColour m_labelColour;
	109	wxBitmap m_labelBitmap;
	110	int m_labelAlignment;
	111	};
	112
80752b57 RD	113	enum wxHeaderSortIconType {
	114	wxHDR_SORT_ICON_NONE, // Header button has no sort arrow
	115	wxHDR_SORT_ICON_UP, // Header button an an up sort arrow icon
	116	wxHDR_SORT_ICON_DOWN // Header button an a down sort arrow icon
	117	};
	118
4b94ddc4	119
04857cb7 VZ	120	// wxRendererNative interface version
	121	struct WXDLLEXPORT wxRendererVersion
	122	{
	123	wxRendererVersion(int version_, int age_) : version(version_), age(age_) { }
	124
	125	// default copy ctor, assignment operator and dtor are ok
	126
	127	// the current version and age of wxRendererNative interface: different
	128	// versions are incompatible (in both ways) while the ages inside the same
	129	// version are upwards compatible, i.e. the version of the renderer must
	130	// match the version of the main program exactly while the age may be
	131	// highergreater or equal to it
	132	//
	133	// NB: don't forget to increment age after adding any new virtual function!
	134	enum
	135	{
	136	Current_Version = 1,
	137	Current_Age = 5
	138	};
	139
	140
	141	// check if the given version is compatible with the current one
	142	static bool IsCompatible(const wxRendererVersion& ver)
	143	{
	144	return ver.version == Current_Version && ver.age >= Current_Age;
	145	}
	146
	147	const int version;
	148	const int age;
	149	};
	150
9c7f49f5 VZ	151	// ----------------------------------------------------------------------------
	152	// wxRendererNative: abstracts drawing methods needed by the native controls
	153	// ----------------------------------------------------------------------------
	154
	155	class WXDLLEXPORT wxRendererNative
	156	{
	157	public:
	158	// drawing functions
	159	// -----------------
	160
c97c9952 RD	161	// draw the header control button (used by wxListCtrl) Returns optimal
	162	// width for the label contents.
	163	virtual int DrawHeaderButton(wxWindow *win,
9c7f49f5 VZ	164	wxDC& dc,
9c7f49f5 VZ	165	const wxRect& rect,
4b94ddc4	166	int flags = 0,
80752b57	167	wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
4b94ddc4 RD	168	wxHeaderButtonParams* params=NULL) = 0;
	169
	170
	171	// Draw the contents of a header control button (label, sort arrows, etc.)
	172	// Normally only called by DrawHeaderButton.
c97c9952	173	virtual int DrawHeaderButtonContents(wxWindow *win,
4b94ddc4 RD	174	wxDC& dc,
	175	const wxRect& rect,
	176	int flags = 0,
80752b57	177	wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
4b94ddc4 RD	178	wxHeaderButtonParams* params=NULL) = 0;
	179
	180	// Returns the default height of a header button, either a fixed platform
	181	// height if available, or a generic height based on the window's font.
	182	virtual int GetHeaderButtonHeight(wxWindow *win) = 0;
	183
9c7f49f5 VZ	184
	185	// draw the expanded/collapsed icon for a tree control item
	186	virtual void DrawTreeItemButton(wxWindow *win,
	187	wxDC& dc,
	188	const wxRect& rect,
	189	int flags = 0) = 0;
	190
b3208e11 VZ	191	// draw the border for sash window: this border must be such that the sash
	192	// drawn by DrawSash() blends into it well
	193	virtual void DrawSplitterBorder(wxWindow *win,
	194	wxDC& dc,
af99040c VZ	195	const wxRect& rect,
af99040c VZ	196	int flags = 0) = 0;
b3208e11 VZ	197
	198	// draw a (vertical) sash
	199	virtual void DrawSplitterSash(wxWindow *win,
	200	wxDC& dc,
	201	const wxSize& size,
62dc9cb4	202	wxCoord position,
af99040c VZ	203	wxOrientation orient,
af99040c VZ	204	int flags = 0) = 0;
b3208e11	205
f33cef9f VZ	206	// draw a combobox dropdown button
f33cef9f VZ	207	//
4c85ab75	208	// flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
f33cef9f VZ	209	virtual void DrawComboBoxDropButton(wxWindow *win,
	210	wxDC& dc,
	211	const wxRect& rect,
	212	int flags = 0) = 0;
	213
4c85ab75 VZ	214	// draw a dropdown arrow
	215	//
	216	// flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
	217	virtual void DrawDropArrow(wxWindow *win,
	218	wxDC& dc,
	219	const wxRect& rect,
	220	int flags = 0) = 0;
b3208e11	221
862d8041 RR	222	// draw check button
	223	//
	224	// flags may use wxCONTROL_CHECKED, wxCONTROL_UNDETERMINED and wxCONTROL_CURRENT
90b903c2 WS	225	virtual void DrawCheckBox(wxWindow *win,
	226	wxDC& dc,
	227	const wxRect& rect,
	228	int flags = 0) = 0;
2209baae RR	229
	230	// draw blank button
	231	//
	232	// flags may use wxCONTROL_PRESSED, wxCONTROL_CURRENT and wxCONTROL_ISDEFAULT
	233	virtual void DrawPushButton(wxWindow *win,
	234	wxDC& dc,
	235	const wxRect& rect,
	236	int flags = 0) = 0;
	237
daebb44c RR	238	// draw rectangle indicating that an item in e.g. a list control
	239	// has been selected or focused
	240	//
0856300f	241	// flags may use
daebb44c RR	242	// wxCONTROL_SELECTED (item is selected, e.g. draw background)
	243	// wxCONTROL_CURRENT (item is the current item, e.g. dotted border)
	244	// wxCONTROL_FOCUSED (the whole control has focus, e.g. blue background vs. grey otherwise)
	245	virtual void DrawItemSelectionRect(wxWindow *win,
	246	wxDC& dc,
	247	const wxRect& rect,
	248	int flags = 0) = 0;
	249
b3208e11 VZ	250	// geometry functions
	251	// ------------------
	252
	253	// get the splitter parameters: the x field of the returned point is the
	254	// sash width and the y field is the border width
af99040c	255	virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win) = 0;
b3208e11	256
9c7f49f5 VZ	257
	258	// pseudo constructors
	259	// -------------------
	260
	261	// return the currently used renderer
	262	static wxRendererNative& Get();
	263
	264	// return the generic implementation of the renderer
	265	static wxRendererNative& GetGeneric();
f0244295 VZ	266
	267	// return the default (native) implementation for this platform
	268	static wxRendererNative& GetDefault();
9f2be125 VZ	269
	270
	271	// changing the global renderer
	272	// ----------------------------
	273
	274	#if wxUSE_DYNLIB_CLASS
	275	// load the renderer from the specified DLL, the returned pointer must be
	276	// deleted by caller if not NULL when it is not used any more
	277	static wxRendererNative *Load(const wxString& name);
	278	#endif // wxUSE_DYNLIB_CLASS
	279
	280	// set the renderer to use, passing NULL reverts to using the default
	281	// renderer
	282	//
	283	// return the previous renderer used with Set() or NULL if none
	284	static wxRendererNative Set(wxRendererNative renderer);
04857cb7 VZ	285
	286
	287	// miscellaneous stuff
	288	// -------------------
	289
	290	// this function is used for version checking: Load() refuses to load any
	291	// DLLs implementing an older or incompatible version; it should be
	292	// implemented simply by returning wxRendererVersion::Current_XXX values
	293	virtual wxRendererVersion GetVersion() const = 0;
	294
	295	// virtual dtor for any base class
	296	virtual ~wxRendererNative();
9c7f49f5 VZ	297	};
	298
	299	// ----------------------------------------------------------------------------
	300	// wxDelegateRendererNative: allows reuse of renderers code
	301	// ----------------------------------------------------------------------------
	302
	303	class WXDLLEXPORT wxDelegateRendererNative : public wxRendererNative
	304	{
	305	public:
	306	wxDelegateRendererNative()
	307	: m_rendererNative(GetGeneric()) { }
	308
	309	wxDelegateRendererNative(wxRendererNative& rendererNative)
	310	: m_rendererNative(rendererNative) { }
	311
	312
c97c9952	313	virtual int DrawHeaderButton(wxWindow *win,
9c7f49f5 VZ	314	wxDC& dc,
9c7f49f5 VZ	315	const wxRect& rect,
4b94ddc4	316	int flags = 0,
80752b57	317	wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
4b94ddc4	318	wxHeaderButtonParams* params = NULL)
c97c9952	319	{ return m_rendererNative.DrawHeaderButton(win, dc, rect, flags, sortArrow, params); }
0856300f	320
c97c9952	321	virtual int DrawHeaderButtonContents(wxWindow *win,
4b94ddc4 RD	322	wxDC& dc,
	323	const wxRect& rect,
	324	int flags = 0,
80752b57	325	wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
4b94ddc4	326	wxHeaderButtonParams* params = NULL)
c97c9952	327	{ return m_rendererNative.DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }
0856300f	328
4b94ddc4 RD	329	virtual int GetHeaderButtonHeight(wxWindow *win)
4b94ddc4 RD	330	{ return m_rendererNative.GetHeaderButtonHeight(win); }
b3208e11	331
9c7f49f5 VZ	332	virtual void DrawTreeItemButton(wxWindow *win,
	333	wxDC& dc,
	334	const wxRect& rect,
	335	int flags = 0)
	336	{ m_rendererNative.DrawTreeItemButton(win, dc, rect, flags); }
	337
b3208e11 VZ	338	virtual void DrawSplitterBorder(wxWindow *win,
b3208e11 VZ	339	wxDC& dc,
af99040c VZ	340	const wxRect& rect,
af99040c VZ	341	int flags = 0)
2c0e6de1	342	{ m_rendererNative.DrawSplitterBorder(win, dc, rect, flags); }
b3208e11 VZ	343
	344	virtual void DrawSplitterSash(wxWindow *win,
	345	wxDC& dc,
	346	const wxSize& size,
62dc9cb4	347	wxCoord position,
af99040c VZ	348	wxOrientation orient,
af99040c VZ	349	int flags = 0)
2c0e6de1 VZ	350	{ m_rendererNative.DrawSplitterSash(win, dc, size,
2c0e6de1 VZ	351	position, orient, flags); }
b3208e11	352
f33cef9f VZ	353	virtual void DrawComboBoxDropButton(wxWindow *win,
	354	wxDC& dc,
	355	const wxRect& rect,
	356	int flags = 0)
	357	{ m_rendererNative.DrawComboBoxDropButton(win, dc, rect, flags); }
	358
4c85ab75 VZ	359	virtual void DrawDropArrow(wxWindow *win,
	360	wxDC& dc,
	361	const wxRect& rect,
	362	int flags = 0)
	363	{ m_rendererNative.DrawDropArrow(win, dc, rect, flags); }
b3208e11	364
90b903c2 WS	365	virtual void DrawCheckBox(wxWindow *win,
	366	wxDC& dc,
	367	const wxRect& rect,
	368	int flags = 0 )
	369	{ m_rendererNative.DrawCheckBox( win, dc, rect, flags ); }
2209baae RR	370
	371	virtual void DrawPushButton(wxWindow *win,
	372	wxDC& dc,
	373	const wxRect& rect,
	374	int flags = 0 )
	375	{ m_rendererNative.DrawPushButton( win, dc, rect, flags ); }
	376
daebb44c RR	377	virtual void DrawItemSelectionRect(wxWindow *win,
	378	wxDC& dc,
	379	const wxRect& rect,
	380	int flags = 0 )
	381	{ m_rendererNative.DrawItemSelectionRect( win, dc, rect, flags ); }
	382
af99040c VZ	383	virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win)
af99040c VZ	384	{ return m_rendererNative.GetSplitterParams(win); }
b3208e11	385
04857cb7 VZ	386	virtual wxRendererVersion GetVersion() const
	387	{ return m_rendererNative.GetVersion(); }
	388
9c7f49f5 VZ	389	protected:
9c7f49f5 VZ	390	wxRendererNative& m_rendererNative;
fc7a2a60 VZ	391
fc7a2a60 VZ	392	DECLARE_NO_COPY_CLASS(wxDelegateRendererNative)
9c7f49f5 VZ	393	};
9c7f49f5 VZ	394
f0244295 VZ	395	// ----------------------------------------------------------------------------
	396	// inline functions implementation
	397	// ----------------------------------------------------------------------------
	398
	399	#ifndef wxHAS_NATIVE_RENDERER
	400
	401	// default native renderer is the generic one then
	402	/* static */ inline
	403	wxRendererNative& wxRendererNative::GetDefault()
	404	{
	405	return GetGeneric();
	406	}
	407
	408	#endif // !wxHAS_NATIVE_RENDERER
	409
9c7f49f5	410	#endif // _WX_RENDERER_H_