[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 license
/////////////////////////////////////////////////////////////////////////////

#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;

#ifndef SWIG
    wxPGWindowList( wxWindow* a )
    {
        m_primary = a;
        m_secondary = NULL;
    };
    wxPGWindowList( wxWindow* a, wxWindow* b )
    {
        m_primary = a;
        m_secondary = b;
    };
#endif
};

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

/** @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;

#if !defined(SWIG) || defined(CREATE_VCW)
    /** 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;
#endif

    /**
        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;

};


// Exclude classes from being able to be derived from in wxPython bindings
#ifndef SWIG

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)
};

#endif  // !SWIG


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