[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_

#if wxUSE_PROPGRID

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