[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
{
#ifndef SWIG
    DECLARE_ABSTRACT_CLASS(wxPGEditor)
#endif
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 value in control to unspecified. */
    virtual void SetValueToUnspecified( wxPGProperty* property,
                                        wxWindow* ctrl ) const = 0;

    /** 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
{
#ifndef SWIG
    DECLARE_DYNAMIC_CLASS(wxPGTextCtrlEditor)
#endif
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 void SetValueToUnspecified( 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
{
#ifndef SWIG
    DECLARE_DYNAMIC_CLASS(wxPGChoiceEditor)
#endif
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
{
#ifndef SWIG
    DECLARE_DYNAMIC_CLASS(wxPGComboBoxEditor)
#endif
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
{
#ifndef SWIG
    DECLARE_DYNAMIC_CLASS(wxPGCheckBoxEditor)
#endif
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
{
#ifndef SWIG
    DECLARE_ABSTRACT_CLASS(wxPGEditorDialogAdapter)
#endif
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 );

    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:

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