[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,
        wxPG_EDITOR(TextCtrl) has name "TextCtrl". This method is autogenerated
        for custom editors.
    */
    virtual wxString GetName() const = 0;

    /**
        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.
        - Implementation shoud use connect all necessary events to the
          wxPropertyGrid::OnCustomEditorEvent. For Example:
            @code
                // Relays wxEVT_COMMAND_TEXT_UPDATED events of primary editor
                // control to the OnEvent.
                // NOTE: This event in particular is actually automatically
                // conveyed, but it is just used as an example.
                propgrid->Connect(wxPG_SUBID1, wxEVT_COMMAND_TEXT_UPDATED,
                                  wxCommandEventHandler(
                                    wxPropertyGrid::OnCustomEditorEvent));
            @endcode
            OnCustomEditorEvent will then forward events, first to
            wxPGEditor::OnEvent and then to wxPGProperty::OnEvent.

    */
    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
                                          wxPGProperty* property,
                                          const wxPoint& pos,
                                          const wxSize& size) const = 0;
    #define wxPG_DECLARE_CREATECONTROLS \
        virtual wxPGWindowList \
            CreateControls( wxPropertyGrid* propgrid, wxPGProperty* property, \
        const wxPoint& pos, const wxSize& sz ) const;

    /** 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).
    */
    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;
};


//
// Note that we don't use this macro in this file because
// otherwise doxygen gets confused.
//
#define WX_PG_DECLARE_EDITOR_CLASS(CLASSNAME) \
    DECLARE_DYNAMIC_CLASS(CLASSNAME) \
public: \
    virtual wxString GetName() const; \
private:


#define WX_PG_IMPLEMENT_EDITOR_CLASS(EDITOR,CLASSNAME,BASECLASS) \
IMPLEMENT_DYNAMIC_CLASS(CLASSNAME, BASECLASS) \
wxString CLASSNAME::GetName() const \
{ \
    return wxS(#EDITOR); \
} \
wxPGEditor* wxPGEditor_##EDITOR = (wxPGEditor*) NULL; \
wxPGEditor* wxPGConstruct##EDITOR##EditorClass() \
{ \
    wxASSERT( !wxPGEditor_##EDITOR ); \
    return new CLASSNAME(); \
}


#define WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS() \
wxPG_DECLARE_CREATECONTROLS \
virtual void UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const; \
virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property, \
    wxWindow* primary, wxEvent& event ) const; \
virtual bool GetValueFromControl( wxVariant& variant, \
                                  wxPGProperty* property, \
                                  wxWindow* ctrl ) const; \
virtual void SetValueToUnspecified( wxPGProperty* property, \
                                    wxWindow* ctrl ) const;


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

class WXDLLIMPEXP_PROPGRID wxPGTextCtrlEditor : public wxPGEditor
{
#ifndef SWIG
    DECLARE_DYNAMIC_CLASS(wxPGTextCtrlEditor)
#endif
public:
    wxPGTextCtrlEditor() {}
    virtual ~wxPGTextCtrlEditor();

    WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS()
    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();

    WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS()
    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();

    // Macro is used for convenience due to different signature with wxPython
    wxPG_DECLARE_CREATECONTROLS

    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;

    // Macro is used for convenience due to different signature with wxPython
    wxPG_DECLARE_CREATECONTROLS

    DECLARE_DYNAMIC_CLASS(wxPGChoiceAndButtonEditor)
};

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

    DECLARE_DYNAMIC_CLASS(wxPGTextCtrlAndButtonEditor)
};

#endif  // !SWIG


#if wxPG_INCLUDE_CHECKBOX || defined(DOXYGEN)

//
// 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;
    WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS()

    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 macros

#define wxPGRegisterEditorClass(EDITOR) \
    if ( wxPGEditor_##EDITOR == (wxPGEditor*) NULL ) \
    { \
        wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
                wxPGConstruct##EDITOR##EditorClass(), wxS(#EDITOR) ); \
    }

// Use this in RegisterDefaultEditors.
#define wxPGRegisterDefaultEditorClass(EDITOR) \
if ( wxPGEditor_##EDITOR == (wxPGEditor*) NULL ) \
    { \
        wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
                wxPGConstruct##EDITOR##EditorClass(), wxS(#EDITOR), true ); \
    }

#define wxPG_INIT_REQUIRED_EDITOR(T) \
    wxPGRegisterEditorClass(T)


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

/** @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(). For instance, here we add three buttons to
    a textctrl editor:

    @code

    #include <wx/propgrid/editors.h>

    class wxMultiButtonTextCtrlEditor : public wxPGTextCtrlEditor
    {
        WX_PG_DECLARE_EDITOR_CLASS(wxMultiButtonTextCtrlEditor)
    public:
        wxMultiButtonTextCtrlEditor() {}
        virtual ~wxMultiButtonTextCtrlEditor() {}

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

    };

    WX_PG_IMPLEMENT_EDITOR_CLASS(MultiButtonTextCtrlEditor,
                                 wxMultiButtonTextCtrlEditor,
                                 wxPGTextCtrlEditor)

    wxPGWindowList
    wxMultiButtonTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
                                                 wxPGProperty* property,
                                                 const wxPoint& pos,
                                                 const wxSize& sz ) const
    {
        // Create and populate buttons-subwindow
        wxPGMultiButton* buttons = new wxPGMultiButton( propGrid, sz );

        // Add two regular buttons
        buttons->Add( "..." );
        buttons->Add( "A" );
        // Add a bitmap button
        buttons->Add( wxArtProvider::GetBitmap(wxART_FOLDER) );

        // Create the 'primary' editor control (textctrl in this case)
        wxPGWindowList wndList = wxPGTextCtrlEditor::CreateControls(
                                    propGrid,
                                    property,
                                    pos,
                                    buttons->GetPrimarySize()
                                 );

        // Finally, move buttons-subwindow to correct position and make sure
        // returned wxPGWindowList contains our custom button list.
        buttons->FinalizePosition(pos);

        wndList.SetSecondary( buttons );
        return wndList;
    }

    bool wxMultiButtonTextCtrlEditor::OnEvent( wxPropertyGrid* propGrid,
                                               wxPGProperty* property,
                                               wxWindow* ctrl,
                                               wxEvent& event ) const
    {
        if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
        {
            wxPGMultiButton* buttons = (wxPGMultiButton*)
                propGrid->GetEditorControlSecondary();

            if ( event.GetId() == buttons->GetButtonId(0) )
            {
                // Do something when first button is pressed
                return true;
            }
            if ( event.GetId() == buttons->GetButtonId(1) )
            {
                // Do something when first button is pressed
                return true;
            }
            if ( event.GetId() == buttons->GetButtonId(2) )
            {
                // Do something when second button is pressed
                return true;
            }
        }
        return wxPGTextCtrlEditor::OnEvent(propGrid, property, ctrl, event);
    }

    @endcode

    Further to use this editor, code like this can be used:

    @code

        // Register editor class - needs only to be called once
        wxPGRegisterEditorClass( MultiButtonTextCtrlEditor );

        // Insert the property that will have multiple buttons
        propGrid->Append( new wxLongStringProperty("MultipleButtons",
                                                    wxPG_LABEL) );

        // Change property to use editor created in the previous code segment
        propGrid->SetPropertyEditor( "MultipleButtons",
                                     wxPG_EDITOR(MultiButtonTextCtrlEditor) );

    @endcode

    @library{wxpropgrid}
    @category{propgrid}
*/
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.
    */
    int GetCount() const { return m_buttons.Count(); }

    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 FinalizePosition( const wxPoint& pos )
    {
        Move( pos.x + m_fullEditorSize.x - m_buttonsWidth, pos.y );
    }

#ifndef DOXYGEN
protected:

    int GenId( int id ) const;

    wxArrayPtrVoid  m_buttons;
    wxSize          m_fullEditorSize;
    int             m_buttonsWidth;
#endif // !DOXYGEN
};

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

#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
	7	// RCS-ID: $Id:
	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,
95	wxPG_EDITOR(TextCtrl) has name "TextCtrl". This method is autogenerated
96	for custom editors.
97	*/
98	virtual wxString GetName() const = 0;
99
100	/**
101	Instantiates editor controls.
102
103	@param propgrid
104	wxPropertyGrid to which the property belongs (use as parent for
105	control).
106	@param property
107	Property for which this method is called.
108	@param pos
109	Position, inside wxPropertyGrid, to create control(s) to.
110	@param size
111	Initial size for control(s).
112
113	@remarks
114	- Primary control shall use id wxPG_SUBID1, and secondary (button)
115	control shall use wxPG_SUBID2.
116	- Implementation shoud use connect all necessary events to the
117	wxPropertyGrid::OnCustomEditorEvent. For Example:
118	@code
119	// Relays wxEVT_COMMAND_TEXT_UPDATED events of primary editor
120	// control to the OnEvent.
121	// NOTE: This event in particular is actually automatically
122	// conveyed, but it is just used as an example.
123	propgrid->Connect(wxPG_SUBID1, wxEVT_COMMAND_TEXT_UPDATED,
124	wxCommandEventHandler(
125	wxPropertyGrid::OnCustomEditorEvent));
126	@endcode
127	OnCustomEditorEvent will then forward events, first to
128	wxPGEditor::OnEvent and then to wxPGProperty::OnEvent.
129
130	*/
131	virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
132	wxPGProperty* property,
133	const wxPoint& pos,
134	const wxSize& size) const = 0;
135	#define wxPG_DECLARE_CREATECONTROLS \
136	virtual wxPGWindowList \
137	CreateControls( wxPropertyGrid* propgrid, wxPGProperty* property, \
138	const wxPoint& pos, const wxSize& sz ) const;
139
140	/** Loads value from property to the control. */
141	virtual void UpdateControl( wxPGProperty* property,
142	wxWindow* ctrl ) const = 0;
143
144	/**
145	Used to get the renderer to draw the value with when the control is
146	hidden.
147
148	Default implementation returns g_wxPGDefaultRenderer.
149	*/
150	//virtual wxPGCellRenderer* GetCellRenderer() const;
151
152	/** Draws value for given property.
153	*/
154	virtual void DrawValue( wxDC& dc,
155	const wxRect& rect,
156	wxPGProperty* property,
157	const wxString& text ) const;
158
159	/** Handles events. Returns true if value in control was modified
160	(see wxPGProperty::OnEvent for more information).
161	*/
162	virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
163	wxWindow* wnd_primary, wxEvent& event ) const = 0;
164
165	#if !defined(SWIG) \|\| defined(CREATE_VCW)
166	/** Returns value from control, via parameter 'variant'.
167	Usually ends up calling property's StringToValue or IntToValue.
168	Returns true if value was different.
169	*/
170	virtual bool GetValueFromControl( wxVariant& variant,
171	wxPGProperty* property,
172	wxWindow* ctrl ) const;
173	#endif
174
175	/** Sets value in control to unspecified. */
176	virtual void SetValueToUnspecified( wxPGProperty* property,
177	wxWindow* ctrl ) const = 0;
178
179	/** Sets control's value specifically from string. */
180	virtual void SetControlStringValue( wxPGProperty* property,
181	wxWindow* ctrl,
182	const wxString& txt ) const;
183
184	/** Sets control's value specifically from int (applies to choice etc.). */
185	virtual void SetControlIntValue( wxPGProperty* property,
186	wxWindow* ctrl,
187	int value ) const;
188
189	/** Inserts item to existing control. Index -1 means appending.
190	Default implementation does nothing. Returns index of item added.
191	*/
192	virtual int InsertItem( wxWindow* ctrl,
193	const wxString& label,
194	int index ) const;
195
196	/** Deletes item from existing control.
197	Default implementation does nothing.
198	*/
199	virtual void DeleteItem( wxWindow* ctrl, int index ) const;
200
201	/** Extra processing when control gains focus. For example, wxTextCtrl
202	based controls should select all text.
203	*/
204	virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;
205
206	/** Returns true if control itself can contain the custom image. Default is
207	to return false.
208	*/
209	virtual bool CanContainCustomImage() const;
210
211	//
212	// This member is public so scripting language bindings
213	// wrapper code can access it freely.
214	void* m_clientData;
215	};
216
217
218	//
219	// Note that we don't use this macro in this file because
220	// otherwise doxygen gets confused.
221	//
222	#define WX_PG_DECLARE_EDITOR_CLASS(CLASSNAME) \
223	DECLARE_DYNAMIC_CLASS(CLASSNAME) \
224	public: \
225	virtual wxString GetName() const; \
226	private:
227
228
229	#define WX_PG_IMPLEMENT_EDITOR_CLASS(EDITOR,CLASSNAME,BASECLASS) \
230	IMPLEMENT_DYNAMIC_CLASS(CLASSNAME, BASECLASS) \
231	wxString CLASSNAME::GetName() const \
232	{ \
233	return wxS(#EDITOR); \
234	} \
235	wxPGEditor* wxPGEditor_##EDITOR = (wxPGEditor*) NULL; \
236	wxPGEditor* wxPGConstruct##EDITOR##EditorClass() \
237	{ \
238	wxASSERT( !wxPGEditor_##EDITOR ); \
239	return new CLASSNAME(); \
240	}
241
242
243	#define WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS() \
244	wxPG_DECLARE_CREATECONTROLS \
245	virtual void UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const; \
246	virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property, \
247	wxWindow* primary, wxEvent& event ) const; \
248	virtual bool GetValueFromControl( wxVariant& variant, \
249	wxPGProperty* property, \
250	wxWindow* ctrl ) const; \
251	virtual void SetValueToUnspecified( wxPGProperty* property, \
252	wxWindow* ctrl ) const;
253
254
255	//
256	// Following are the built-in editor classes.
257	//
258
259	class WXDLLIMPEXP_PROPGRID wxPGTextCtrlEditor : public wxPGEditor
260	{
261	#ifndef SWIG
262	DECLARE_DYNAMIC_CLASS(wxPGTextCtrlEditor)
263	#endif
264	public:
265	wxPGTextCtrlEditor() {}
266	virtual ~wxPGTextCtrlEditor();
267
268	WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS()
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	{
293	#ifndef SWIG
294	DECLARE_DYNAMIC_CLASS(wxPGChoiceEditor)
295	#endif
296	public:
297	wxPGChoiceEditor() {}
298	virtual ~wxPGChoiceEditor();
299
300	WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS()
301	virtual wxString GetName() const;
302
303	virtual void SetControlIntValue( wxPGProperty* property,
304	wxWindow* ctrl,
305	int value ) const;
306	virtual void SetControlStringValue( wxPGProperty* property,
307	wxWindow* ctrl,
308	const wxString& txt ) const;
309
310	virtual int InsertItem( wxWindow* ctrl,
311	const wxString& label,
312	int index ) const;
313	virtual void DeleteItem( wxWindow* ctrl, int index ) const;
314	virtual bool CanContainCustomImage() const;
315
316	// CreateControls calls this with CB_READONLY in extraStyle
317	wxWindow* CreateControlsBase( wxPropertyGrid* propgrid,
318	wxPGProperty* property,
319	const wxPoint& pos,
320	const wxSize& sz,
321	long extraStyle ) const;
322
323	};
324
325
326	class WXDLLIMPEXP_PROPGRID wxPGComboBoxEditor : public wxPGChoiceEditor
327	{
328	#ifndef SWIG
329	DECLARE_DYNAMIC_CLASS(wxPGComboBoxEditor)
330	#endif
331	public:
332	wxPGComboBoxEditor() {}
333	virtual ~wxPGComboBoxEditor();
334
335	// Macro is used for convenience due to different signature with wxPython
336	wxPG_DECLARE_CREATECONTROLS
337
338	virtual wxString GetName() const;
339
340	virtual void UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const;
341
342	virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
343	wxWindow* ctrl, wxEvent& event ) const;
344
345	virtual bool GetValueFromControl( wxVariant& variant,
346	wxPGProperty* property,
347	wxWindow* ctrl ) const;
348
349	virtual void OnFocus( wxPGProperty* property, wxWindow* wnd ) const;
350
351	};
352
353
354	// Exclude classes from being able to be derived from in wxPython bindings
355	#ifndef SWIG
356
357	class WXDLLIMPEXP_PROPGRID wxPGChoiceAndButtonEditor : public wxPGChoiceEditor
358	{
359	public:
360	wxPGChoiceAndButtonEditor() {}
361	virtual ~wxPGChoiceAndButtonEditor();
362	virtual wxString GetName() const;
363
364	// Macro is used for convenience due to different signature with wxPython
365	wxPG_DECLARE_CREATECONTROLS
366
367	DECLARE_DYNAMIC_CLASS(wxPGChoiceAndButtonEditor)
368	};
369
370	class WXDLLIMPEXP_PROPGRID
371	wxPGTextCtrlAndButtonEditor : public wxPGTextCtrlEditor
372	{
373	public:
374	wxPGTextCtrlAndButtonEditor() {}
375	virtual ~wxPGTextCtrlAndButtonEditor();
376	virtual wxString GetName() const;
377	wxPG_DECLARE_CREATECONTROLS
378
379	DECLARE_DYNAMIC_CLASS(wxPGTextCtrlAndButtonEditor)
380	};
381
382	#endif // !SWIG
383
384
385	#if wxPG_INCLUDE_CHECKBOX \|\| defined(DOXYGEN)
386
387	//
388	// Use custom check box code instead of native control
389	// for cleaner (ie. more integrated) look.
390	//
391	class WXDLLIMPEXP_PROPGRID wxPGCheckBoxEditor : public wxPGEditor
392	{
393	#ifndef SWIG
394	DECLARE_DYNAMIC_CLASS(wxPGCheckBoxEditor)
395	#endif
396	public:
397	wxPGCheckBoxEditor() {}
398	virtual ~wxPGCheckBoxEditor();
399
400	virtual wxString GetName() const;
401	WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS()
402
403	virtual void DrawValue( wxDC& dc,
404	const wxRect& rect,
405	wxPGProperty* property,
406	const wxString& text ) const;
407	//virtual wxPGCellRenderer* GetCellRenderer() const;
408
409	virtual void SetControlIntValue( wxPGProperty* property,
410	wxWindow* ctrl,
411	int value ) const;
412	};
413
414	#endif
415
416
417	// -----------------------------------------------------------------------
418	// Editor class registeration macros
419
420	#define wxPGRegisterEditorClass(EDITOR) \
421	if ( wxPGEditor_##EDITOR == (wxPGEditor*) NULL ) \
422	{ \
423	wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
424	wxPGConstruct##EDITOR##EditorClass(), wxS(#EDITOR) ); \
425	}
426
427	// Use this in RegisterDefaultEditors.
428	#define wxPGRegisterDefaultEditorClass(EDITOR) \
429	if ( wxPGEditor_##EDITOR == (wxPGEditor*) NULL ) \
430	{ \
431	wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
432	wxPGConstruct##EDITOR##EditorClass(), wxS(#EDITOR), true ); \
433	}
434
435	#define wxPG_INIT_REQUIRED_EDITOR(T) \
436	wxPGRegisterEditorClass(T)
437
438
439	// -----------------------------------------------------------------------
440
441	/** @class wxPGEditorDialogAdapter
442
443	Derive a class from this to adapt an existing editor dialog or function to
444	be used when editor button of a property is pushed.
445
446	You only need to derive class and implement DoShowDialog() to create and
447	show the dialog, and finally submit the value returned by the dialog
448	via SetValue().
449
450	@library{wxpropgrid}
451	@category{propgrid}
452	*/
453	class WXDLLIMPEXP_PROPGRID wxPGEditorDialogAdapter : public wxObject
454	{
455	#ifndef SWIG
456	DECLARE_ABSTRACT_CLASS(wxPGEditorDialogAdapter)
457	#endif
458	public:
459	wxPGEditorDialogAdapter()
460	: wxObject()
461	{
462	m_clientData = NULL;
463	}
464
465	virtual ~wxPGEditorDialogAdapter() { }
466
467	bool ShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property );
468
469	virtual bool DoShowDialog( wxPropertyGrid* propGrid,
470	wxPGProperty* property ) = 0;
471
472	void SetValue( wxVariant value )
473	{
474	m_value = value;
475	}
476
477	/**
478	This method is typically only used if deriving class from existing
479	adapter with value conversion purposes.
480	*/
481	wxVariant& GetValue() { return m_value; }
482
483	//
484	// This member is public so scripting language bindings
485	// wrapper code can access it freely.
486	void* m_clientData;
487
488	private:
489	wxVariant m_value;
490	};
491
492	// -----------------------------------------------------------------------
493
494
495	/** @class wxPGMultiButton
496
497	This class can be used to have multiple buttons in a property editor.
498	You will need to create a new property editor class, override
499	CreateControls, and have it return wxPGMultiButton instance in
500	wxPGWindowList::SetSecondary(). For instance, here we add three buttons to
501	a textctrl editor:
502
503	@code
504
505	#include <wx/propgrid/editors.h>
506
507	class wxMultiButtonTextCtrlEditor : public wxPGTextCtrlEditor
508	{
509	WX_PG_DECLARE_EDITOR_CLASS(wxMultiButtonTextCtrlEditor)
510	public:
511	wxMultiButtonTextCtrlEditor() {}
512	virtual ~wxMultiButtonTextCtrlEditor() {}
513
514	wxPG_DECLARE_CREATECONTROLS
515	virtual bool OnEvent( wxPropertyGrid* propGrid,
516	wxPGProperty* property,
517	wxWindow* ctrl,
518	wxEvent& event ) const;
519
520	};
521
522	WX_PG_IMPLEMENT_EDITOR_CLASS(MultiButtonTextCtrlEditor,
523	wxMultiButtonTextCtrlEditor,
524	wxPGTextCtrlEditor)
525
526	wxPGWindowList
527	wxMultiButtonTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
528	wxPGProperty* property,
529	const wxPoint& pos,
530	const wxSize& sz ) const
531	{
532	// Create and populate buttons-subwindow
533	wxPGMultiButton* buttons = new wxPGMultiButton( propGrid, sz );
534
535	// Add two regular buttons
536	buttons->Add( "..." );
537	buttons->Add( "A" );
538	// Add a bitmap button
539	buttons->Add( wxArtProvider::GetBitmap(wxART_FOLDER) );
540
541	// Create the 'primary' editor control (textctrl in this case)
542	wxPGWindowList wndList = wxPGTextCtrlEditor::CreateControls(
543	propGrid,
544	property,
545	pos,
546	buttons->GetPrimarySize()
547	);
548
549	// Finally, move buttons-subwindow to correct position and make sure
550	// returned wxPGWindowList contains our custom button list.
551	buttons->FinalizePosition(pos);
552
553	wndList.SetSecondary( buttons );
554	return wndList;
555	}
556
557	bool wxMultiButtonTextCtrlEditor::OnEvent( wxPropertyGrid* propGrid,
558	wxPGProperty* property,
559	wxWindow* ctrl,
560	wxEvent& event ) const
561	{
562	if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
563	{
564	wxPGMultiButton* buttons = (wxPGMultiButton*)
565	propGrid->GetEditorControlSecondary();
566
567	if ( event.GetId() == buttons->GetButtonId(0) )
568	{
569	// Do something when first button is pressed
570	return true;
571	}
572	if ( event.GetId() == buttons->GetButtonId(1) )
573	{
574	// Do something when first button is pressed
575	return true;
576	}
577	if ( event.GetId() == buttons->GetButtonId(2) )
578	{
579	// Do something when second button is pressed
580	return true;
581	}
582	}
583	return wxPGTextCtrlEditor::OnEvent(propGrid, property, ctrl, event);
584	}
585
586	@endcode
587
588	Further to use this editor, code like this can be used:
589
590	@code
591
592	// Register editor class - needs only to be called once
593	wxPGRegisterEditorClass( MultiButtonTextCtrlEditor );
594
595	// Insert the property that will have multiple buttons
596	propGrid->Append( new wxLongStringProperty("MultipleButtons",
597	wxPG_LABEL) );
598
599	// Change property to use editor created in the previous code segment
600	propGrid->SetPropertyEditor( "MultipleButtons",
601	wxPG_EDITOR(MultiButtonTextCtrlEditor) );
602
603	@endcode
604
605	@library{wxpropgrid}
606	@category{propgrid}
607	*/
608	class WXDLLIMPEXP_PROPGRID wxPGMultiButton : public wxWindow
609	{
610	public:
611	wxPGMultiButton( wxPropertyGrid* pg, const wxSize& sz );
612
613	wxWindow* GetButton( unsigned int i ) { return (wxWindow*) m_buttons[i]; }
614	const wxWindow* GetButton( unsigned int i ) const
615	{ return (const wxWindow*) m_buttons[i]; }
616
617	/** Utility function to be used in event handlers.
618	*/
619	int GetButtonId( unsigned int i ) const { return GetButton(i)->GetId(); }
620
621	/** Returns number of buttons.
622	*/
623	int GetCount() const { return m_buttons.Count(); }
624
625	void Add( const wxString& label, int id = -2 );
626	#if wxUSE_BMPBUTTON
627	void Add( const wxBitmap& bitmap, int id = -2 );
628	#endif
629
630	wxSize GetPrimarySize() const
631	{
632	return wxSize(m_fullEditorSize.x - m_buttonsWidth, m_fullEditorSize.y);
633	}
634
635	void FinalizePosition( const wxPoint& pos )
636	{
637	Move( pos.x + m_fullEditorSize.x - m_buttonsWidth, pos.y );
638	}
639
640	#ifndef DOXYGEN
641	protected:
642
643	int GenId( int id ) const;
644
645	wxArrayPtrVoid m_buttons;
646	wxSize m_fullEditorSize;
647	int m_buttonsWidth;
648	#endif // !DOXYGEN
649	};
650
651	// -----------------------------------------------------------------------
652
f4bc1aa2 JS	653	#endif // wxUSE_PROPGRID
f4bc1aa2 JS	654
1c4293cb	655	#endif // _WX_PROPGRID_EDITORS_H_