propdev.h

非常好用的可移植的多平台C/C++源代码编辑器

/////////////////////////////////////////////////////////////////////////////
// Name:        propdev.h
// Purpose:     wxPropertyGrid Internal/Property Developer Header
// Author:      Jaakko Salli
// Modified by:
// Created:     Nov-23-2004
// RCS-ID:      $Id:
// Copyright:   (c) Jaakko Salli
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_PROPGRID_PROPDEV_H_
#define _WX_PROPGRID_PROPDEV_H_

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

#ifdef _WX_PROPGRID_ADVPROPS_H_
# error "propdev.h must be included *before* advprops.h"
#endif

//#if wxPG_USE_CUSTOM_CONTROLS
//# include "wx/propertygrid/custctrl.h"
//#endif

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

// wxWidgets < 2.5.4 compatibility.
// TODO: After officially included in library, remove this section.
#if wxMINOR_VERSION < 5 || ( wxMINOR_VERSION == 5 && wxRELEASE_NUMBER < 3 )
# if wxUSE_UNICODE
    #include <string.h> //for mem funcs

    inline wxChar* wxTmemcpy(wxChar* szOut, const wxChar* szIn, size_t len)
    {
        return (wxChar*) memcpy(szOut, szIn, len * sizeof(wxChar));
    }
# else
    #define wxTmemcpy memcpy
# endif
# ifndef wxFIXED_MINSIZE
#  define wxFIXED_MINSIZE    0
# endif
#elif ( wxMINOR_VERSION == 5 && wxRELEASE_NUMBER < 4 )
    #define wxTmemcpy wxMemcpy
#endif

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


// This is required for sharing common global variables.
// TODO: Automatic locking mechanism?
class WXDLLIMPEXP_PG wxPGGlobalVarsClass
{
public:

    wxPGGlobalVarsClass();
    ~wxPGGlobalVarsClass();

    wxString            m_pDefaultImageWildcard; // Used by advprops, but here to make things easier.

    wxArrayPtrVoid      m_arrEditorClasses; // List of editor class instances.

    wxPGHashMapS2P      m_dictValueType; // Valuename -> Value type object instance.

    wxPGHashMapS2P      m_dictPropertyClassInfo; // PropertyName -> ClassInfo

    // void* so we don't have to declare class in headers
    void*               m_dictConstants;

    wxString            m_boolChoices[2]; // default is ["False", "True"]

    wxPGConstants       m_emptyConstants;

    bool                m_autoGetTranslation; // If true then some things are automatically translated

    int                 m_offline; // > 0 if errors cannot or should not be shown in statusbar etc.
};

extern WXDLLIMPEXP_PG wxPGGlobalVarsClass* wxPGGlobalVars;

#define wxPGUnRefChoices(PCHOICES) \
    wxASSERT ( PCHOICES ); \
    if ( PCHOICES != &wxPGGlobalVars->m_emptyConstants && PCHOICES->UnRef() ) \
        delete PCHOICES

// -----------------------------------------------------------------------
// wxPGEditor class.

/** \class wxPGEditor
    \ingroup classes
    \brief Base for property editor classes.
    See propgrid.cpp for how builtin editors works (starting from wxPGTextCtrlEditor).
*/
class WXDLLIMPEXP_PG wxPGEditor
{
public:

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

    /** Instantiates editor controls. */
    virtual wxPGCtrlClass* CreateControls ( wxPropertyGrid* propgrid, wxPGProperty* property,
        const wxPoint& pos, const wxSize& sz, wxPGCtrlClass** psecondary ) const = 0;

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

    /** Used to draw the value when control is hidden. Default is to draw a string.
        Note that some margin above and below has been taken into account, to make
        drawing text easier without giving loads parameters. If Pen is changed,
        it must be returned to *wxTRANSPARENT_PEN.
    */
    virtual void DrawValue ( wxDC& dc, wxPGProperty* property, const wxRect& rect ) const;

    /** Handles events. Returns TRUE if processed and value modified
        (same retval and args as in wxPGProperty::OnEvent).
    */
    virtual bool OnEvent ( wxPropertyGrid* propgrid, wxPGProperty* property,
        wxPGCtrlClass* wnd_primary, wxEvent& event ) const = 0;

    /** Copies value from ctrl to property's internal storage.
        Returns TRUE if value was different.
    */
    virtual bool CopyValueFromControl ( wxPGProperty* property, wxPGCtrlClass* ctrl ) const = 0;

    /** Sets value in control to unspecified. */
    virtual void SetValueToUnspecified ( wxPGCtrlClass* ctrl ) const = 0;

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

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

    /** Appends item to a existing control. Default implementation
        does nothing. Returns index of item added.
    */
    virtual int AppendItem ( wxPGCtrlClass* ctrl, const wxString& label ) const;

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

protected:
};

#define WX_PG_IMPLEMENT_EDITOR_CLASS_CONSTFUNC(EDITOR,CLASSNAME,PARENTCLASS) \
wxPGEditor* wxPGEditor_##EDITOR = (wxPGEditor*) NULL; \
wxPGEditor* wxPGConstruct##EDITOR##EditorClass() \
{ \
    wxASSERT ( !wxPGEditor_##EDITOR ); \
    return new CLASSNAME(); \
}

#define WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS() \
virtual wxPGCtrlClass* CreateControls ( wxPropertyGrid* propgrid, wxPGProperty* property, \
    const wxPoint& pos, const wxSize& sz, wxPGCtrlClass** psecondary ) const; \
virtual void UpdateControl ( wxPGProperty* property, wxPGCtrlClass* ctrl ) const; \
virtual bool OnEvent ( wxPropertyGrid* propgrid, wxPGProperty* property, \
    wxPGCtrlClass* primary, wxEvent& event ) const; \
virtual bool CopyValueFromControl ( wxPGProperty* property, wxPGCtrlClass* ctrl ) const; \
virtual void SetValueToUnspecified ( wxPGCtrlClass* ctrl ) const;

#define WX_PG_IMPLEMENT_EDITOR_CLASS(EDITOR,CLASSNAME,PARENTCLASS) \
class CLASSNAME; \
class CLASSNAME : public PARENTCLASS \
{ \
public: \
    virtual ~CLASSNAME(); \
    WX_PG_IMPLEMENT_EDITOR_CLASS_STD_METHODS() \
}; \
WX_PG_IMPLEMENT_EDITOR_CLASS_CONSTFUNC(EDITOR,CLASSNAME,PARENTCLASS)


// -----------------------------------------------------------------------
// Variant setter macros.
// TODO: When sure this is feature is out, remove these.

#if wxPG_EMBED_VARIANT
# define wxPG_SetVariantValue(VALUE) \
    ((wxVariant&)*this) = VALUE
# define wxPG_SetVariantWxObjectValue() \
    ((wxVariant&)*this) = wxVariant((wxObject*)DoGetValue().GetRawPtr(),m_name);
# define wxPG_SetVariantValueVoidPtr() \
    ((wxVariant&)*this) = wxPGVariantToVoidPtr(DoGetValue())
#else
# define wxPG_SetVariantValue(VALUE)            { }
# define wxPG_SetVariantWxObjectValue()         { }
# define wxPG_SetVariantValueVoidPtr()          { }
#endif

// -----------------------------------------------------------------------
// Value type registeration macros

// -----------------------------------------------------------------------
// Value type registeration macros

#define wxPGRegisterValueType(TYPENAME) \
    if ( wxPGValueType_##TYPENAME == (wxPGValueType*) NULL ) \
    { \
        wxPGValueType_##TYPENAME = wxPropertyGrid::RegisterValueType( wxPGNewVT##TYPENAME() ); \
    }

// Use this in RegisterDefaultValues.
#define wxPGRegisterDefaultValueType(TYPENAME) \
    if ( wxPGValueType_##TYPENAME == (wxPGValueType*) NULL ) \
    { \
        wxPGValueType_##TYPENAME = wxPropertyGrid::RegisterValueType( new wxPGValueType##TYPENAME##Class, true ); \
    }

#define wxPG_INIT_REQUIRED_TYPE(T) \
    wxPGRegisterValueType(T)

// Use this with 'simple' value types (derived)
#define wxPG_INIT_REQUIRED_TYPE2(T) \
    if ( wxPGValueType_##T == (wxPGValueType*) NULL ) \
    { \
        wxPGValueType_##T = wxPropertyGrid::RegisterValueType( new wxPGValueType##T##Class ); \
    }

// -----------------------------------------------------------------------
// Editor class registeration macros

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

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

#define wxPG_INIT_REQUIRED_EDITOR(T) \
    wxPGRegisterEditorClass(T)

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

#define WX_PG_IMPLEMENT_SUBTYPE(VALUETYPE,CVALUETYPE,DEFPROPERTY,TYPESTRING,GETTER,DEFVAL) \
const wxPGValueType *wxPGValueType_##VALUETYPE = (wxPGValueType*) NULL; \
class wxPGValueType##VALUETYPE##Class : public wxPGValueType \
{ \
public: \
    virtual const wxChar* GetTypeName() const { return TYPESTRING; } \
    virtual wxPGVariant GetDefaultValue () const { return wxPGVariant(m_default); } \
    virtual wxVariant GenerateVariant ( wxPGVariant value, const wxString& name ) const \
    { return wxVariant ( value.GETTER(), name ); } \
    virtual wxPGProperty* GenerateProperty ( const wxString& label, const wxString& name ) const \
    { \
        return wxPG_CONSTFUNC(DEFPROPERTY)(label,name); \
    } \
    virtual void SetValueFromVariant ( wxPGProperty* property, wxVariant& value ) const \
    { \
        wxASSERT_MSG( wxStrcmp(GetTypeName(),value.GetType().c_str()) == 0, \
            wxT("SetValueFromVariant: wxVariant type mismatch.") ); \
        property->DoSetValue(value.GETTER()); \
    } \
    wxPGValueType##VALUETYPE##Class(); \
    virtual ~wxPGValueType##VALUETYPE##Class(); \
protected: \
    CVALUETYPE m_default; \
}; \
wxPGValueType##VALUETYPE##Class::wxPGValueType##VALUETYPE##Class() { m_default = DEFVAL; } \
wxPGValueType##VALUETYPE##Class::~wxPGValueType##VALUETYPE##Class() { }

#define WX_PG_IMPLEMENT_VALUE_TYPE(VALUETYPE,DEFPROPERTY,TYPESTRING,GETTER,DEFVAL) \
WX_PG_IMPLEMENT_SUBTYPE(VALUETYPE,VALUETYPE,DEFPROPERTY,TYPESTRING,GETTER,DEFVAL)

//
// Implements wxVariantData for the type.
//
#define WX_PG_IMPLEMENT_VALUE_TYPE_VDC(VDCLASS,VALUETYPE) \
IMPLEMENT_DYNAMIC_CLASS(VDCLASS,wxVariantData) \
VDCLASS::VDCLASS() { } \
VDCLASS::VDCLASS(const VALUETYPE& value) \
{ \
    m_value = value; \
} \
void VDCLASS::Copy(wxVariantData& data) \
{ \
    wxASSERT_MSG( data.GetType() == GetType(), wxT(#VDCLASS) wxT("::Copy: Can't copy to this type of data") ); \
    VDCLASS& otherData = (VDCLASS&) data; \
    otherData.m_value = m_value; \
} \
wxString VDCLASS::GetType() const \
{ \
    return wxString(wxT(#VALUETYPE)); \
} \
bool VDCLASS::Eq(wxVariantData& data) const \
{ \
    wxASSERT_MSG( data.GetType() == GetType(), wxT(#VDCLASS) wxT("::Eq: argument mismatch") ); \
    VDCLASS& otherData = (VDCLASS&) data; \
    return otherData.m_value == m_value; \
} \
void* VDCLASS::GetValuePtr() { return (void*)&m_value; }

// TODO: When ready, remove GetValueClassInfo
#define WX_PG_IMPLEMENT_VALUE_TYPE_WXOBJ_BASE(VALUETYPE,DEFPROPERTY,DEFVAL) \
class WX_PG_DECLARE_VALUE_TYPE_VDC(VALUETYPE) \
    virtual wxClassInfo* GetValueClassInfo(); \
}; \
WX_PG_IMPLEMENT_VALUE_TYPE_VDC(wxVariantData_##VALUETYPE,VALUETYPE) \
wxClassInfo* wxVariantData_##VALUETYPE::GetValueClassInfo() \
{ \
    return m_value.GetClassInfo(); \
} \
const wxPGValueType *wxPGValueType_##VALUETYPE = (wxPGValueType*) NULL; \
class wxPGValueType##VALUETYPE##Class : public wxPGValueType \
{ \
public: \
    virtual const wxChar* GetTypeName() const { return CLASSINFO(VALUETYPE)->GetClassName(); } \
    virtual wxVariant GenerateVariant ( wxPGVariant value, const wxString& name ) const \
    { return wxVariant ( new wxVariantData_##VALUETYPE( (*(VALUETYPE*)value.GetRawPtr()) ), name ); } \
    virtual wxPGProperty* GenerateProperty ( const wxString& label, const wxString& name ) const \
    { \
        return wxPG_CONSTFUNC(DEFPROPERTY)(label,name); \
    } \
    virtual void SetValueFromVariant ( wxPGProperty* property, wxVariant& value ) const \
    { \
        const VALUETYPE* real_value; \
        wxASSERT_MSG( wxStrcmp(GetTypeName(),value.GetType().c_str()) == 0, \
            wxT("GetPtrFromVariant: wxVariant type mismatch.") ); \
        wxVariantData_##VALUETYPE* vd = (wxVariantData_##VALUETYPE*)value.GetData(); \
        if ( vd->IsKindOf(CLASSINFO(wxVariantData_##VALUETYPE)) ) \
            real_value = &vd->GetValue(); \
        else \
            real_value  = ((const VALUETYPE*)value.GetWxObjectPtr()); \
        property->DoSetValue( *real_value ); \
    }

// This should not be used by built-in types (advprops.cpp types should use it though)
#define WX_PG_IMPLEMENT_VALUE_TYPE_CREATOR(VALUETYPE) \
wxPGValueType* wxPGNewVT##VALUETYPE() { return new wxPGValueType##VALUETYPE##Class; }

#define WX_PG_IMPLEMENT_VALUE_TYPE_WXOBJ(VALUETYPE,DEFPROPERTY,DEFVAL) \
WX_PG_IMPLEMENT_VALUE_TYPE_WXOBJ_BASE(VALUETYPE,DEFPROPERTY,DEFVAL) \
    virtual wxPGVariant GetDefaultValue () const { return wxPGVariant(DEFVAL); } \
}; \
WX_PG_IMPLEMENT_VALUE_TYPE_CREATOR(VALUETYPE)

#define WX_PG_IMPLEMENT_VALUE_TYPE_WXOBJ_OWNDEFAULT(VALUETYPE,DEFPROPERTY,DEFVAL) \
WX_PG_IMPLEMENT_VALUE_TYPE_WXOBJ_BASE(VALUETYPE,DEFPROPERTY,DEFVAL) \
    wxPGValueType##VALUETYPE##Class() { m_default = DEFVAL; } \
    virtual ~wxPGValueType##VALUETYPE##Class() { } \