[wxWidgets.git] / include / wx / propgrid / editors.h

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/propgrid/editors.h
// Purpose:     wxPropertyGrid editors
// Author:      Jaakko Salli
// Modified by:
// Created:     2007-04-14
// RCS-ID:      $Id$
// Copyright:   (c) Jaakko Salli
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_PROPGRID_EDITORS_H_
#define _WX_PROPGRID_EDITORS_H_

#include "wx/defs.h"

#if wxUSE_PROPGRID

class WXDLLIMPEXP_FWD_PROPGRID wxPGCell;
class WXDLLIMPEXP_FWD_PROPGRID wxPGProperty;
class WXDLLIMPEXP_FWD_PROPGRID wxPropertyGrid;

// -----------------------------------------------------------------------
// wxPGWindowList contains list of editor windows returned by CreateControls.

class wxPGWindowList
{
public:
    wxPGWindowList()
    {
        m_primary = m_secondary = NULL;
    }

    void SetSecondary( wxWindow* secondary ) { m_secondary = secondary; }

    wxWindow*   m_primary;
    wxWindow*   m_secondary;

    wxPGWindowList( wxWindow* a )
    {
        m_primary = a;
        m_secondary = NULL;
    };
    wxPGWindowList( wxWindow* a, wxWindow* b )
    {
        m_primary = a;
        m_secondary = b;
    };
};

// -----------------------------------------------------------------------

/** @class wxPGEditor

    Base class for custom wxPropertyGrid editors.

    @remarks
    - Names of builtin property editors are: TextCtrl, Choice,
      ComboBox, CheckBox, TextCtrlAndButton, and ChoiceAndButton. Additional
      editors include SpinCtrl and DatePickerCtrl, but using them requires
      calling wxPropertyGrid::RegisterAdditionalEditors() prior use.

    - Pointer to builtin editor is available as wxPGEditor_EditorName
      (eg. wxPGEditor_TextCtrl).

    - To add new editor you need to register it first using static function
      wxPropertyGrid::RegisterEditorClass(), with code like this:
        @code
            wxPGEditor *editorPointer = wxPropertyGrid::RegisterEditorClass(
                                            new MyEditorClass(), "MyEditor");
        @endcode
      After that, wxPropertyGrid will take ownership of the given object, but
      you should still store editorPointer somewhere, so you can pass it to
      wxPGProperty::SetEditor(), or return it from
      wxPGEditor::DoGetEditorClass().

    @library{wxpropgrid}
    @category{propgrid}
*/
class WXDLLIMPEXP_PROPGRID wxPGEditor : public wxObject
{
    DECLARE_ABSTRACT_CLASS(wxPGEditor)
public:

    /** Constructor. */
    wxPGEditor()
        : wxObject()
    {
        m_clientData = NULL;
    }

    /** Destructor. */
    virtual ~wxPGEditor();

    /**
        Returns pointer to the name of the editor. For example,
        wxPGEditor_TextCtrl has name "TextCtrl". If you dont' need to access
        your custom editor by string name, then you do not need to implement
        this function.
    */
    virtual wxString GetName() const;

    /**
        Instantiates editor controls.

        @param propgrid
            wxPropertyGrid to which the property belongs (use as parent for
            control).
        @param property
            Property for which this method is called.
        @param pos
            Position, inside wxPropertyGrid, to create control(s) to.
        @param size
            Initial size for control(s).

        @remarks
        - Primary control shall use id wxPG_SUBID1, and secondary (button)
          control shall use wxPG_SUBID2.
        - Unlike in previous version of wxPropertyGrid, it is no longer
          necessary to call wxEvtHandler::Connect() for interesting editor
          events. Instead, all events from control are now automatically
          forwarded to wxPGEditor::OnEvent() and wxPGProperty::OnEvent().
    */
    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const = 0;

    /** Loads value from property to the control. */
    virtual void UpdateControl( wxPGProperty* property,
                                wxWindow* ctrl ) const = 0;

    /**
        Used to get the renderer to draw the value with when the control is
        hidden.

        Default implementation returns g_wxPGDefaultRenderer.
    */
    //virtual wxPGCellRenderer* GetCellRenderer() const;

    /** Draws value for given property.
    */
    virtual void DrawValue( wxDC& dc,
                            const wxRect& rect,
                            wxPGProperty* property,
                            const wxString& text ) const;

    /** Handles events. Returns true if value in control was modified
        (see wxPGProperty::OnEvent for more information).

        @remarks wxPropertyGrid will automatically unfocus the editor when
                wxEVT_COMMAND_TEXT_ENTER is received and when it results in
                property value being modified. This happens regardless of
                editor type (ie. behaviour is same for any wxTextCtrl and
                wxComboBox based editor).
    */
    virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
        wxWindow* wnd_primary, wxEvent& event ) const = 0;

    /** Returns value from control, via parameter 'variant'.
        Usually ends up calling property's StringToValue or IntToValue.
        Returns true if value was different.
    */
    virtual bool GetValueFromControl( wxVariant& variant,
                                      wxPGProperty* property,
                                      wxWindow* ctrl ) const;

    /**
        Sets new appearance for the control. Default implementation
        sets foreground colour, background colour, font, plus text
        for wxTextCtrl and wxComboCtrl.

        @param appearance
            New appearance to be applied.

        @param oldAppearance
            Previously applied appearance. Used to detect which
            control attributes need to be changed (e.g. so we only
            change background colour if really needed).

        @param unspecified
            @true if the new appearance represents an unspecified
            property value.
    */
    virtual void SetControlAppearance( wxPropertyGrid* pg,
                                       wxPGProperty* property,
                                       wxWindow* ctrl,
                                       const wxPGCell& appearance,
                                       const wxPGCell& oldAppearance,
                                       bool unspecified ) const;

    /**
        Sets value in control to unspecified.
    */
    virtual void SetValueToUnspecified( wxPGProperty* property,
                                        wxWindow* ctrl ) const;

    /** Sets control's value specifically from string. */
    virtual void SetControlStringValue( wxPGProperty* property,
                                        wxWindow* ctrl,
                                        const wxString& txt ) const;

    /** Sets control's value specifically from int (applies to choice etc.). */
    virtual void SetControlIntValue( wxPGProperty* property,
                                     wxWindow* ctrl,
                                     int value ) const;

    /** Inserts item to existing control. Index -1 means appending.
        Default implementation does nothing. Returns index of item added.
    */
    virtual int InsertItem( wxWindow* ctrl,
                            const wxString& label,
                            int index ) const;

    /** Deletes item from existing control.
        Default implementation does nothing.
    */
    virtual void DeleteItem( wxWindow* ctrl, int index ) const;

    /** Extra processing when control gains focus. For example, wxTextCtrl
        based controls should select all text.
    */
    virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;

    /** Returns true if control itself can contain the custom image. Default is
        to return false.
    */
    virtual bool CanContainCustomImage() const;

    //
    // This member is public so scripting language bindings
    // wrapper code can access it freely.
    void*       m_clientData;
};


#define WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(EDITOR,CLASSNAME,BASECLASS) \
IMPLEMENT_DYNAMIC_CLASS(CLASSNAME, BASECLASS) \
wxString CLASSNAME::GetName() const \
{ \
    return wxS(#EDITOR); \
} \
wxPGEditor* wxPGEditor_##EDITOR = NULL;


//
// Following are the built-in editor classes.
//

class WXDLLIMPEXP_PROPGRID wxPGTextCtrlEditor : public wxPGEditor
{
    DECLARE_DYNAMIC_CLASS(wxPGTextCtrlEditor)
public:
    wxPGTextCtrlEditor() {}
    virtual ~wxPGTextCtrlEditor();

    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const;
    virtual void UpdateControl( wxPGProperty* property,
                                wxWindow* ctrl ) const;
    virtual bool OnEvent( wxPropertyGrid* propgrid,
                          wxPGProperty* property,
                          wxWindow* primaryCtrl,
                          wxEvent& event ) const;
    virtual bool GetValueFromControl( wxVariant& variant,
                                      wxPGProperty* property,
                                      wxWindow* ctrl ) const;

    virtual wxString GetName() const;

    //virtual wxPGCellRenderer* GetCellRenderer() const;
    virtual void SetControlStringValue( wxPGProperty* property,
                                        wxWindow* ctrl,
                                        const wxString& txt ) const;
    virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;

    // Provided so that, for example, ComboBox editor can use the same code
    // (multiple inheritance would get way too messy).
    static bool OnTextCtrlEvent( wxPropertyGrid* propgrid,
                                 wxPGProperty* property,
                                 wxWindow* ctrl,
                                 wxEvent& event );

    static bool GetTextCtrlValueFromControl( wxVariant& variant,
                                             wxPGProperty* property,
                                             wxWindow* ctrl );

};


class WXDLLIMPEXP_PROPGRID wxPGChoiceEditor : public wxPGEditor
{
    DECLARE_DYNAMIC_CLASS(wxPGChoiceEditor)
public:
    wxPGChoiceEditor() {}
    virtual ~wxPGChoiceEditor();

    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const;
    virtual void UpdateControl( wxPGProperty* property,
                                wxWindow* ctrl ) const;
    virtual bool OnEvent( wxPropertyGrid* propgrid,
                          wxPGProperty* property,
                          wxWindow* primaryCtrl,
                          wxEvent& event ) const;
    virtual bool GetValueFromControl( wxVariant& variant,
                                      wxPGProperty* property,
                                      wxWindow* ctrl ) const;
    virtual void SetValueToUnspecified( wxPGProperty* property,
                                        wxWindow* ctrl ) const;
    virtual wxString GetName() const;

    virtual void SetControlIntValue( wxPGProperty* property,
                                     wxWindow* ctrl,
                                     int value ) const;
    virtual void SetControlStringValue( wxPGProperty* property,
                                        wxWindow* ctrl,
                                        const wxString& txt ) const;

    virtual int InsertItem( wxWindow* ctrl,
                            const wxString& label,
                            int index ) const;
    virtual void DeleteItem( wxWindow* ctrl, int index ) const;
    virtual bool CanContainCustomImage() const;

    // CreateControls calls this with CB_READONLY in extraStyle
    wxWindow* CreateControlsBase( wxPropertyGrid* propgrid,
                                  wxPGProperty* property,
                                  const wxPoint& pos,
                                  const wxSize& sz,
                                  long extraStyle ) const;

};


class WXDLLIMPEXP_PROPGRID wxPGComboBoxEditor : public wxPGChoiceEditor
{
    DECLARE_DYNAMIC_CLASS(wxPGComboBoxEditor)
public:
    wxPGComboBoxEditor() {}
    virtual ~wxPGComboBoxEditor();

    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const;

    virtual wxString GetName() const;

    virtual void UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const;

    virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
        wxWindow* ctrl, wxEvent& event ) const;

    virtual bool GetValueFromControl( wxVariant& variant,
                                      wxPGProperty* property,
                                      wxWindow* ctrl ) const;

    virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;

};


class WXDLLIMPEXP_PROPGRID wxPGChoiceAndButtonEditor : public wxPGChoiceEditor
{
public:
    wxPGChoiceAndButtonEditor() {}
    virtual ~wxPGChoiceAndButtonEditor();
    virtual wxString GetName() const;

    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const;

    DECLARE_DYNAMIC_CLASS(wxPGChoiceAndButtonEditor)
};

class WXDLLIMPEXP_PROPGRID
wxPGTextCtrlAndButtonEditor : public wxPGTextCtrlEditor
{
public:
    wxPGTextCtrlAndButtonEditor() {}
    virtual ~wxPGTextCtrlAndButtonEditor();
    virtual wxString GetName() const;

    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const;

    DECLARE_DYNAMIC_CLASS(wxPGTextCtrlAndButtonEditor)
};


#if wxPG_INCLUDE_CHECKBOX

//
// Use custom check box code instead of native control
// for cleaner (ie. more integrated) look.
//
class WXDLLIMPEXP_PROPGRID wxPGCheckBoxEditor : public wxPGEditor
{
    DECLARE_DYNAMIC_CLASS(wxPGCheckBoxEditor)
public:
    wxPGCheckBoxEditor() {}
    virtual ~wxPGCheckBoxEditor();

    virtual wxString GetName() const;
    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const;
    virtual void UpdateControl( wxPGProperty* property,
                                wxWindow* ctrl ) const;
    virtual bool OnEvent( wxPropertyGrid* propgrid,
                          wxPGProperty* property,
                          wxWindow* primaryCtrl,
                          wxEvent& event ) const;
    virtual bool GetValueFromControl( wxVariant& variant,
                                      wxPGProperty* property,
                                      wxWindow* ctrl ) const;
    virtual void SetValueToUnspecified( wxPGProperty* property,
                                        wxWindow* ctrl ) const;

    virtual void DrawValue( wxDC& dc,
                            const wxRect& rect,
                            wxPGProperty* property,
                            const wxString& text ) const;
    //virtual wxPGCellRenderer* GetCellRenderer() const;

    virtual void SetControlIntValue( wxPGProperty* property,
                                     wxWindow* ctrl,
                                     int value ) const;
};

#endif


// -----------------------------------------------------------------------
// Editor class registeration macro (mostly for internal use)

#define wxPGRegisterEditorClass(EDITOR) \
    if ( wxPGEditor_##EDITOR == NULL ) \
    { \
        wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
                new wxPG##EDITOR##Editor ); \
    }

// -----------------------------------------------------------------------

/** @class wxPGEditorDialogAdapter

    Derive a class from this to adapt an existing editor dialog or function to
    be used when editor button of a property is pushed.

    You only need to derive class and implement DoShowDialog() to create and
    show the dialog, and finally submit the value returned by the dialog
    via SetValue().

    @library{wxpropgrid}
    @category{propgrid}
*/
class WXDLLIMPEXP_PROPGRID wxPGEditorDialogAdapter : public wxObject
{
    DECLARE_ABSTRACT_CLASS(wxPGEditorDialogAdapter)
public:
    wxPGEditorDialogAdapter()
        : wxObject()
    {
        m_clientData = NULL;
    }

    virtual ~wxPGEditorDialogAdapter() { }

    bool ShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property );

    virtual bool DoShowDialog( wxPropertyGrid* propGrid,
                               wxPGProperty* property ) = 0;

    void SetValue( wxVariant value )
    {
        m_value = value;
    }

    /**
        This method is typically only used if deriving class from existing
        adapter with value conversion purposes.
    */
    wxVariant& GetValue() { return m_value; }

    //
    // This member is public so scripting language bindings
    // wrapper code can access it freely.
    void*               m_clientData;

private:
    wxVariant           m_value;
};

// -----------------------------------------------------------------------


/** @class wxPGMultiButton

    This class can be used to have multiple buttons in a property editor.
    You will need to create a new property editor class, override
    CreateControls, and have it return wxPGMultiButton instance in
    wxPGWindowList::SetSecondary().
*/
class WXDLLIMPEXP_PROPGRID wxPGMultiButton : public wxWindow
{
public:
    wxPGMultiButton( wxPropertyGrid* pg, const wxSize& sz );
    virtual ~wxPGMultiButton() {}

    wxWindow* GetButton( unsigned int i ) { return (wxWindow*) m_buttons[i]; }
    const wxWindow* GetButton( unsigned int i ) const
        { return (const wxWindow*) m_buttons[i]; }

    /** Utility function to be used in event handlers.
    */
    int GetButtonId( unsigned int i ) const { return GetButton(i)->GetId(); }

    /** Returns number of buttons.
    */
    unsigned int GetCount() const { return (unsigned int) m_buttons.size(); }

    void Add( const wxString& label, int id = -2 );
#if wxUSE_BMPBUTTON
    void Add( const wxBitmap& bitmap, int id = -2 );
#endif

    wxSize GetPrimarySize() const
    {
        return wxSize(m_fullEditorSize.x - m_buttonsWidth, m_fullEditorSize.y);
    }

    void Finalize( wxPropertyGrid* propGrid, const wxPoint& pos );

protected:

    void DoAddButton( wxWindow* button, const wxSize& sz );

    int GenId( int id ) const;

    wxArrayPtrVoid  m_buttons;
    wxSize          m_fullEditorSize;
    int             m_buttonsWidth;
};

// -----------------------------------------------------------------------

#endif // wxUSE_PROPGRID

#endif // _WX_PROPGRID_EDITORS_H_
Commit	Line	Data
1c4293cb VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/propgrid/editors.h
	3	// Purpose: wxPropertyGrid editors
	4	// Author: Jaakko Salli
	5	// Modified by:
	6	// Created: 2007-04-14
ea5af9c5	7	// RCS-ID: $Id$
1c4293cb	8	// Copyright: (c) Jaakko Salli
526954c5	9	// Licence: wxWindows licence
1c4293cb VZ	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_PROPGRID_EDITORS_H_
	13	#define _WX_PROPGRID_EDITORS_H_
	14
6f631217 JS	15	#include "wx/defs.h"
6f631217 JS	16
f4bc1aa2 JS	17	#if wxUSE_PROPGRID
f4bc1aa2 JS	18
c34ced94 VZ	19	class WXDLLIMPEXP_FWD_PROPGRID wxPGCell;
	20	class WXDLLIMPEXP_FWD_PROPGRID wxPGProperty;
	21	class WXDLLIMPEXP_FWD_PROPGRID wxPropertyGrid;
	22
1c4293cb VZ	23	// -----------------------------------------------------------------------
	24	// wxPGWindowList contains list of editor windows returned by CreateControls.
	25
	26	class wxPGWindowList
	27	{
	28	public:
	29	wxPGWindowList()
	30	{
	31	m_primary = m_secondary = NULL;
	32	}
	33
	34	void SetSecondary( wxWindow* secondary ) { m_secondary = secondary; }
	35
	36	wxWindow* m_primary;
	37	wxWindow* m_secondary;
	38
1c4293cb VZ	39	wxPGWindowList( wxWindow* a )
	40	{
	41	m_primary = a;
	42	m_secondary = NULL;
	43	};
	44	wxPGWindowList( wxWindow* a, wxWindow* b )
	45	{
	46	m_primary = a;
	47	m_secondary = b;
	48	};
1c4293cb VZ	49	};
	50
	51	// -----------------------------------------------------------------------
	52
	53	/** @class wxPGEditor
	54
	55	Base class for custom wxPropertyGrid editors.
	56
	57	@remarks
	58	- Names of builtin property editors are: TextCtrl, Choice,
	59	ComboBox, CheckBox, TextCtrlAndButton, and ChoiceAndButton. Additional
	60	editors include SpinCtrl and DatePickerCtrl, but using them requires
	61	calling wxPropertyGrid::RegisterAdditionalEditors() prior use.
	62
	63	- Pointer to builtin editor is available as wxPGEditor_EditorName
	64	(eg. wxPGEditor_TextCtrl).
	65
	66	- To add new editor you need to register it first using static function
	67	wxPropertyGrid::RegisterEditorClass(), with code like this:
	68	@code
	69	wxPGEditor *editorPointer = wxPropertyGrid::RegisterEditorClass(
	70	new MyEditorClass(), "MyEditor");
	71	@endcode
	72	After that, wxPropertyGrid will take ownership of the given object, but
	73	you should still store editorPointer somewhere, so you can pass it to
	74	wxPGProperty::SetEditor(), or return it from
	75	wxPGEditor::DoGetEditorClass().
	76
	77	@library{wxpropgrid}
	78	@category{propgrid}
	79	*/
	80	class WXDLLIMPEXP_PROPGRID wxPGEditor : public wxObject
	81	{
1c4293cb	82	DECLARE_ABSTRACT_CLASS(wxPGEditor)
1c4293cb VZ	83	public:
	84
	85	/** Constructor. */
	86	wxPGEditor()
	87	: wxObject()
	88	{
	89	m_clientData = NULL;
	90	}
	91
	92	/** Destructor. */
	93	virtual ~wxPGEditor();
	94
	95	/**
	96	Returns pointer to the name of the editor. For example,
5a45dd6f JS	97	wxPGEditor_TextCtrl has name "TextCtrl". If you dont' need to access
	98	your custom editor by string name, then you do not need to implement
	99	this function.
1c4293cb	100	*/
5a45dd6f	101	virtual wxString GetName() const;
1c4293cb VZ	102
	103	/**
	104	Instantiates editor controls.
	105
	106	@param propgrid
	107	wxPropertyGrid to which the property belongs (use as parent for
	108	control).
	109	@param property
	110	Property for which this method is called.
	111	@param pos
	112	Position, inside wxPropertyGrid, to create control(s) to.
	113	@param size
	114	Initial size for control(s).
	115
	116	@remarks
	117	- Primary control shall use id wxPG_SUBID1, and secondary (button)
	118	control shall use wxPG_SUBID2.
b0996c3d JS	119	- Unlike in previous version of wxPropertyGrid, it is no longer
	120	necessary to call wxEvtHandler::Connect() for interesting editor
	121	events. Instead, all events from control are now automatically
	122	forwarded to wxPGEditor::OnEvent() and wxPGProperty::OnEvent().
1c4293cb VZ	123	*/
	124	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	125	wxPGProperty* property,
	126	const wxPoint& pos,
	127	const wxSize& size) const = 0;
1c4293cb VZ	128
	129	/** Loads value from property to the control. */
	130	virtual void UpdateControl( wxPGProperty* property,
	131	wxWindow* ctrl ) const = 0;
	132
	133	/**
	134	Used to get the renderer to draw the value with when the control is
	135	hidden.
	136
	137	Default implementation returns g_wxPGDefaultRenderer.
	138	*/
	139	//virtual wxPGCellRenderer* GetCellRenderer() const;
	140
	141	/** Draws value for given property.
	142	*/
	143	virtual void DrawValue( wxDC& dc,
	144	const wxRect& rect,
	145	wxPGProperty* property,
	146	const wxString& text ) const;
	147
	148	/** Handles events. Returns true if value in control was modified
	149	(see wxPGProperty::OnEvent for more information).
0d4884cb JS	150
	151	@remarks wxPropertyGrid will automatically unfocus the editor when
	152	wxEVT_COMMAND_TEXT_ENTER is received and when it results in
	153	property value being modified. This happens regardless of
4c51a665	154	editor type (ie. behaviour is same for any wxTextCtrl and
0d4884cb	155	wxComboBox based editor).
1c4293cb VZ	156	*/
	157	virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
	158	wxWindow* wnd_primary, wxEvent& event ) const = 0;
	159
1c4293cb VZ	160	/** Returns value from control, via parameter 'variant'.
	161	Usually ends up calling property's StringToValue or IntToValue.
	162	Returns true if value was different.
	163	*/
	164	virtual bool GetValueFromControl( wxVariant& variant,
	165	wxPGProperty* property,
	166	wxWindow* ctrl ) const;
1c4293cb	167
3e6d8c31 JS	168	/**
	169	Sets new appearance for the control. Default implementation
	170	sets foreground colour, background colour, font, plus text
	171	for wxTextCtrl and wxComboCtrl.
	172
	173	@param appearance
	174	New appearance to be applied.
	175
	176	@param oldAppearance
	177	Previously applied appearance. Used to detect which
	178	control attributes need to be changed (e.g. so we only
	179	change background colour if really needed).
	180
	181	@param unspecified
	182	@true if the new appearance represents an unspecified
	183	property value.
	184	*/
	185	virtual void SetControlAppearance( wxPropertyGrid* pg,
	186	wxPGProperty* property,
	187	wxWindow* ctrl,
	188	const wxPGCell& appearance,
	189	const wxPGCell& oldAppearance,
	190	bool unspecified ) const;
	191
	192	/**
	193	Sets value in control to unspecified.
	194	*/
1c4293cb	195	virtual void SetValueToUnspecified( wxPGProperty* property,
3e6d8c31	196	wxWindow* ctrl ) const;
1c4293cb VZ	197
	198	/** Sets control's value specifically from string. */
	199	virtual void SetControlStringValue( wxPGProperty* property,
	200	wxWindow* ctrl,
	201	const wxString& txt ) const;
	202
	203	/** Sets control's value specifically from int (applies to choice etc.). */
	204	virtual void SetControlIntValue( wxPGProperty* property,
	205	wxWindow* ctrl,
	206	int value ) const;
	207
	208	/** Inserts item to existing control. Index -1 means appending.
	209	Default implementation does nothing. Returns index of item added.
	210	*/
	211	virtual int InsertItem( wxWindow* ctrl,
	212	const wxString& label,
	213	int index ) const;
	214
	215	/** Deletes item from existing control.
	216	Default implementation does nothing.
	217	*/
	218	virtual void DeleteItem( wxWindow* ctrl, int index ) const;
	219
	220	/** Extra processing when control gains focus. For example, wxTextCtrl
	221	based controls should select all text.
	222	*/
	223	virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;
	224
	225	/** Returns true if control itself can contain the custom image. Default is
	226	to return false.
	227	*/
	228	virtual bool CanContainCustomImage() const;
	229
	230	//
	231	// This member is public so scripting language bindings
	232	// wrapper code can access it freely.
	233	void* m_clientData;
	234	};
	235
	236
52cefafe	237	#define WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(EDITOR,CLASSNAME,BASECLASS) \
1c4293cb VZ	238	IMPLEMENT_DYNAMIC_CLASS(CLASSNAME, BASECLASS) \
	239	wxString CLASSNAME::GetName() const \
	240	{ \
	241	return wxS(#EDITOR); \
	242	} \
d3b9f782	243	wxPGEditor* wxPGEditor_##EDITOR = NULL;
1c4293cb VZ	244
	245
	246	//
	247	// Following are the built-in editor classes.
	248	//
	249
	250	class WXDLLIMPEXP_PROPGRID wxPGTextCtrlEditor : public wxPGEditor
	251	{
1c4293cb	252	DECLARE_DYNAMIC_CLASS(wxPGTextCtrlEditor)
1c4293cb VZ	253	public:
	254	wxPGTextCtrlEditor() {}
	255	virtual ~wxPGTextCtrlEditor();
	256
52cefafe JS	257	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	258	wxPGProperty* property,
	259	const wxPoint& pos,
	260	const wxSize& size) const;
	261	virtual void UpdateControl( wxPGProperty* property,
	262	wxWindow* ctrl ) const;
	263	virtual bool OnEvent( wxPropertyGrid* propgrid,
	264	wxPGProperty* property,
	265	wxWindow* primaryCtrl,
	266	wxEvent& event ) const;
	267	virtual bool GetValueFromControl( wxVariant& variant,
	268	wxPGProperty* property,
	269	wxWindow* ctrl ) const;
52cefafe	270
1c4293cb VZ	271	virtual wxString GetName() const;
	272
	273	//virtual wxPGCellRenderer* GetCellRenderer() const;
	274	virtual void SetControlStringValue( wxPGProperty* property,
	275	wxWindow* ctrl,
	276	const wxString& txt ) const;
	277	virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;
	278
	279	// Provided so that, for example, ComboBox editor can use the same code
	280	// (multiple inheritance would get way too messy).
	281	static bool OnTextCtrlEvent( wxPropertyGrid* propgrid,
	282	wxPGProperty* property,
	283	wxWindow* ctrl,
	284	wxEvent& event );
	285
	286	static bool GetTextCtrlValueFromControl( wxVariant& variant,
	287	wxPGProperty* property,
	288	wxWindow* ctrl );
	289
	290	};
	291
	292
	293	class WXDLLIMPEXP_PROPGRID wxPGChoiceEditor : public wxPGEditor
	294	{
1c4293cb	295	DECLARE_DYNAMIC_CLASS(wxPGChoiceEditor)
1c4293cb VZ	296	public:
	297	wxPGChoiceEditor() {}
	298	virtual ~wxPGChoiceEditor();
	299
52cefafe JS	300	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	301	wxPGProperty* property,
	302	const wxPoint& pos,
	303	const wxSize& size) const;
	304	virtual void UpdateControl( wxPGProperty* property,
	305	wxWindow* ctrl ) const;
	306	virtual bool OnEvent( wxPropertyGrid* propgrid,
	307	wxPGProperty* property,
	308	wxWindow* primaryCtrl,
	309	wxEvent& event ) const;
	310	virtual bool GetValueFromControl( wxVariant& variant,
	311	wxPGProperty* property,
	312	wxWindow* ctrl ) const;
	313	virtual void SetValueToUnspecified( wxPGProperty* property,
	314	wxWindow* ctrl ) const;
1c4293cb VZ	315	virtual wxString GetName() const;
	316
	317	virtual void SetControlIntValue( wxPGProperty* property,
	318	wxWindow* ctrl,
	319	int value ) const;
	320	virtual void SetControlStringValue( wxPGProperty* property,
	321	wxWindow* ctrl,
	322	const wxString& txt ) const;
	323
	324	virtual int InsertItem( wxWindow* ctrl,
	325	const wxString& label,
	326	int index ) const;
	327	virtual void DeleteItem( wxWindow* ctrl, int index ) const;
	328	virtual bool CanContainCustomImage() const;
	329
	330	// CreateControls calls this with CB_READONLY in extraStyle
	331	wxWindow* CreateControlsBase( wxPropertyGrid* propgrid,
	332	wxPGProperty* property,
	333	const wxPoint& pos,
	334	const wxSize& sz,
	335	long extraStyle ) const;
	336
	337	};
	338
	339
	340	class WXDLLIMPEXP_PROPGRID wxPGComboBoxEditor : public wxPGChoiceEditor
	341	{
1c4293cb	342	DECLARE_DYNAMIC_CLASS(wxPGComboBoxEditor)
1c4293cb VZ	343	public:
	344	wxPGComboBoxEditor() {}
	345	virtual ~wxPGComboBoxEditor();
	346
52cefafe JS	347	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	348	wxPGProperty* property,
	349	const wxPoint& pos,
	350	const wxSize& size) const;
1c4293cb VZ	351
	352	virtual wxString GetName() const;
	353
	354	virtual void UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const;
	355
	356	virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
	357	wxWindow* ctrl, wxEvent& event ) const;
	358
	359	virtual bool GetValueFromControl( wxVariant& variant,
	360	wxPGProperty* property,
	361	wxWindow* ctrl ) const;
	362
	363	virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;
	364
	365	};
	366
	367
1c4293cb VZ	368	class WXDLLIMPEXP_PROPGRID wxPGChoiceAndButtonEditor : public wxPGChoiceEditor
	369	{
	370	public:
	371	wxPGChoiceAndButtonEditor() {}
	372	virtual ~wxPGChoiceAndButtonEditor();
	373	virtual wxString GetName() const;
	374
52cefafe JS	375	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	376	wxPGProperty* property,
	377	const wxPoint& pos,
	378	const wxSize& size) const;
1c4293cb VZ	379
	380	DECLARE_DYNAMIC_CLASS(wxPGChoiceAndButtonEditor)
	381	};
	382
	383	class WXDLLIMPEXP_PROPGRID
	384	wxPGTextCtrlAndButtonEditor : public wxPGTextCtrlEditor
	385	{
	386	public:
	387	wxPGTextCtrlAndButtonEditor() {}
	388	virtual ~wxPGTextCtrlAndButtonEditor();
	389	virtual wxString GetName() const;
52cefafe JS	390
	391	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	392	wxPGProperty* property,
	393	const wxPoint& pos,
	394	const wxSize& size) const;
1c4293cb VZ	395
	396	DECLARE_DYNAMIC_CLASS(wxPGTextCtrlAndButtonEditor)
	397	};
	398
1c4293cb	399
a57f24f9	400	#if wxPG_INCLUDE_CHECKBOX
1c4293cb VZ	401
	402	//
	403	// Use custom check box code instead of native control
	404	// for cleaner (ie. more integrated) look.
	405	//
	406	class WXDLLIMPEXP_PROPGRID wxPGCheckBoxEditor : public wxPGEditor
	407	{
1c4293cb	408	DECLARE_DYNAMIC_CLASS(wxPGCheckBoxEditor)
1c4293cb VZ	409	public:
	410	wxPGCheckBoxEditor() {}
	411	virtual ~wxPGCheckBoxEditor();
	412
	413	virtual wxString GetName() const;
52cefafe JS	414	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
	415	wxPGProperty* property,
	416	const wxPoint& pos,
	417	const wxSize& size) const;
	418	virtual void UpdateControl( wxPGProperty* property,
	419	wxWindow* ctrl ) const;
	420	virtual bool OnEvent( wxPropertyGrid* propgrid,
	421	wxPGProperty* property,
	422	wxWindow* primaryCtrl,
	423	wxEvent& event ) const;
	424	virtual bool GetValueFromControl( wxVariant& variant,
	425	wxPGProperty* property,
	426	wxWindow* ctrl ) const;
	427	virtual void SetValueToUnspecified( wxPGProperty* property,
	428	wxWindow* ctrl ) const;
1c4293cb VZ	429
	430	virtual void DrawValue( wxDC& dc,
	431	const wxRect& rect,
	432	wxPGProperty* property,
	433	const wxString& text ) const;
	434	//virtual wxPGCellRenderer* GetCellRenderer() const;
	435
	436	virtual void SetControlIntValue( wxPGProperty* property,
	437	wxWindow* ctrl,
	438	int value ) const;
	439	};
	440
	441	#endif
	442
	443
	444	// -----------------------------------------------------------------------
52cefafe	445	// Editor class registeration macro (mostly for internal use)
1c4293cb VZ	446
1c4293cb VZ	447	#define wxPGRegisterEditorClass(EDITOR) \
d3b9f782	448	if ( wxPGEditor_##EDITOR == NULL ) \
1c4293cb VZ	449	{ \
1c4293cb VZ	450	wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
52cefafe	451	new wxPG##EDITOR##Editor ); \
1c4293cb VZ	452	}
1c4293cb VZ	453
1c4293cb VZ	454	// -----------------------------------------------------------------------
	455
	456	/** @class wxPGEditorDialogAdapter
	457
	458	Derive a class from this to adapt an existing editor dialog or function to
	459	be used when editor button of a property is pushed.
	460
	461	You only need to derive class and implement DoShowDialog() to create and
	462	show the dialog, and finally submit the value returned by the dialog
	463	via SetValue().
	464
	465	@library{wxpropgrid}
	466	@category{propgrid}
	467	*/
	468	class WXDLLIMPEXP_PROPGRID wxPGEditorDialogAdapter : public wxObject
	469	{
1c4293cb	470	DECLARE_ABSTRACT_CLASS(wxPGEditorDialogAdapter)
1c4293cb VZ	471	public:
	472	wxPGEditorDialogAdapter()
	473	: wxObject()
	474	{
	475	m_clientData = NULL;
	476	}
	477
	478	virtual ~wxPGEditorDialogAdapter() { }
	479
	480	bool ShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property );
	481
	482	virtual bool DoShowDialog( wxPropertyGrid* propGrid,
	483	wxPGProperty* property ) = 0;
	484
	485	void SetValue( wxVariant value )
	486	{
	487	m_value = value;
	488	}
	489
	490	/**
	491	This method is typically only used if deriving class from existing
	492	adapter with value conversion purposes.
	493	*/
	494	wxVariant& GetValue() { return m_value; }
	495
	496	//
	497	// This member is public so scripting language bindings
	498	// wrapper code can access it freely.
	499	void* m_clientData;
	500
	501	private:
	502	wxVariant m_value;
	503	};
	504
	505	// -----------------------------------------------------------------------
	506
	507
	508	/** @class wxPGMultiButton
	509
	510	This class can be used to have multiple buttons in a property editor.
	511	You will need to create a new property editor class, override
	512	CreateControls, and have it return wxPGMultiButton instance in
7a344f1b	513	wxPGWindowList::SetSecondary().
1c4293cb VZ	514	*/
	515	class WXDLLIMPEXP_PROPGRID wxPGMultiButton : public wxWindow
	516	{
	517	public:
	518	wxPGMultiButton( wxPropertyGrid* pg, const wxSize& sz );
517add0d	519	virtual ~wxPGMultiButton() {}
1c4293cb VZ	520
	521	wxWindow* GetButton( unsigned int i ) { return (wxWindow*) m_buttons[i]; }
	522	const wxWindow* GetButton( unsigned int i ) const
	523	{ return (const wxWindow*) m_buttons[i]; }
	524
	525	/** Utility function to be used in event handlers.
	526	*/
	527	int GetButtonId( unsigned int i ) const { return GetButton(i)->GetId(); }
	528
	529	/** Returns number of buttons.
	530	*/
68bcfd2c	531	unsigned int GetCount() const { return (unsigned int) m_buttons.size(); }
1c4293cb VZ	532
	533	void Add( const wxString& label, int id = -2 );
	534	#if wxUSE_BMPBUTTON
	535	void Add( const wxBitmap& bitmap, int id = -2 );
	536	#endif
	537
	538	wxSize GetPrimarySize() const
	539	{
	540	return wxSize(m_fullEditorSize.x - m_buttonsWidth, m_fullEditorSize.y);
	541	}
	542
7a344f1b	543	void Finalize( wxPropertyGrid* propGrid, const wxPoint& pos );
1c4293cb	544
1c4293cb VZ	545	protected:
1c4293cb VZ	546
6086bcc8 JS	547	void DoAddButton( wxWindow* button, const wxSize& sz );
6086bcc8 JS	548
1c4293cb VZ	549	int GenId( int id ) const;
	550
	551	wxArrayPtrVoid m_buttons;
	552	wxSize m_fullEditorSize;
	553	int m_buttonsWidth;
1c4293cb VZ	554	};
	555
	556	// -----------------------------------------------------------------------
	557
f4bc1aa2 JS	558	#endif // wxUSE_PROPGRID
f4bc1aa2 JS	559
1c4293cb	560	#endif // _WX_PROPGRID_EDITORS_H_