propgrid.h

这是一个GPS相关的程序

    virtual wxVariant GenerateVariant( wxPGVariant value, const wxString& name ) const = 0;

    /** Creates new property instance with "proper" class. Initial value is set
        to default.
    */
    virtual wxPGProperty* GenerateProperty( const wxString& label, const wxString& name ) const = 0;

    /** Sets property value from wxVariant.
    */
    virtual void SetValueFromVariant( wxPGProperty* property, wxVariant& value ) const = 0;

    /** Returns type that can be passed to CreatePropertyByType.
    */
    inline wxPG_CONST_WXCHAR_PTR GetType() const
    {
        return GetCustomTypeName();
    }

protected:
};


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

// wxVariant definition macro (sans functional eq-operator)
#define WX_PG_DECLARE_VARIANT_DATA(CLASSNAME, DATATYPE, DECL) \
class DECL CLASSNAME : public wxVariantData \
{ \
    DECLARE_DYNAMIC_CLASS(CLASSNAME) \
public: \
    CLASSNAME() { } \
    CLASSNAME(const DATATYPE& value) { m_value = value; } \
    inline DATATYPE GetValue() const { return m_value; } \
    inline const DATATYPE& GetValueRef() const { return m_value; } \
    inline void SetValue(const DATATYPE& value) { m_value = value; } \
    virtual bool Eq(wxVariantData&) const { return false; } \
    virtual wxString GetType() const { return wxT(#DATATYPE); } \
    virtual wxVariantData* Clone() { return new CLASSNAME; } \
    virtual void Copy(wxVariantData &data) { ((CLASSNAME&)data).SetValue(m_value); } \
    virtual bool Read(wxString &) { return false; } \
    virtual bool Write(wxString &) const { return true; } \
protected: \
    DATATYPE m_value; \
};


#define WX_PG_DECLARE_VARIANT_DATA_PTR(CLASSNAME, DATATYPE, DECL) \
class DECL CLASSNAME : public wxVariantData \
{ \
    DECLARE_DYNAMIC_CLASS(CLASSNAME) \
public: \
    CLASSNAME() { } \
    CLASSNAME(DATATYPE* value) { m_value = value; } \
    inline void SetValue(DATATYPE* value) { m_value = value; } \
    inline DATATYPE* GetValue() const { return m_value; } \
    virtual bool Eq(wxVariantData&) const { return false; } \
    virtual wxString GetType() const { return wxT(#DATATYPE); } \
    virtual wxVariantData* Clone() { return new CLASSNAME; } \
    virtual void Copy(wxVariantData &data) { ((CLASSNAME&)data).SetValue(m_value); } \
    virtual bool Read(wxString &) { return false; } \
    virtual bool Write(wxString &) const { return true; } \
protected: \
    DATATYPE* m_value; \
};


#if wxPG_PGVARIANT_IS_VARIANT

    #define wxPGVariantToWxObjectPtr(A,B)   wxDynamicCast(A.GetWxObjectPtr(),B);
    #define wxPGVariantGetWxObjectPtr(A)    A.GetWxObjectPtr()
    #define wxPGVariantToWxObject(A)        (*A.GetWxObjectPtr())
    #define wxPGVariantToDateTime(A)        A.GetDateTime()
    #define wxPGVariantToWxPoint(A)         ((wxPGVariantDataPoint*)(A.GetData()))->GetValueRef()
    #define wxPGVariantToWxSize(A)          ((wxPGVariantDataSize*)(A.GetData()))->GetValueRef()
    #define wxPGVariantToWxLongLong(A)      ((wxPGVariantDataLongLong*)(A.GetData()))->GetValueRef()
    #define wxPGVariantToWxULongLong(A)     ((wxPGVariantDataULongLong*)(A.GetData()))->GetValueRef()
    #define wxPGVariantToArrayInt(A)        ((wxPGVariantDataArrayInt*)(A.GetData()))->GetValueRef()
    #define wxPGVariantToPyObject(A)        ((wxPGVariantDataPyObject*)(A.GetData()))->GetValue()
    #define wxPGVariantFromWxObject(A)      wxVariant((wxObject*)A)
    #define wxPGVariantFromLong(A)          wxVariant(((long)A))

  #if !defined(SWIG)

    WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataPoint, wxPoint, WXDLLIMPEXP_PG)
    WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataSize, wxSize, WXDLLIMPEXP_PG)
    WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataArrayInt, wxArrayInt, WXDLLIMPEXP_PG)
    WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataLongLong, wxLongLong, WXDLLIMPEXP_PG)
    WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataULongLong, wxULongLong, WXDLLIMPEXP_PG)
   #ifdef __WXPYTHON__
    WX_PG_DECLARE_VARIANT_DATA_PTR(wxPGVariantDataPyObject, PyObject, WXDLLIMPEXP_PG)
   #endif

    // We need this because wxVariant lacks all necessary constructors
    inline wxVariant wxPGVariantCreator(long a) { return wxVariant((long)a); }
    inline wxVariant wxPGVariantCreator(int a) { return wxVariant((long)a); }
    inline wxVariant wxPGVariantCreator(bool a) { return wxVariant(a); }
    inline wxVariant wxPGVariantCreator(const double& a) { return wxVariant(a); }
    inline wxVariant wxPGVariantCreator(const wxString& a) { return wxVariant(a); }

    // NB: This may look dangerous. However, the wxVariant lives only a very short
    //     time, so it is very unlikely they value will be modified by some
    //     "third party".
    inline wxVariant wxPGVariantCreator(const wxObject* a) { return wxVariant((wxObject*)a); }
    inline wxVariant wxPGVariantCreator(const wxObject& a) { return wxVariant((wxObject*)(&a)); }

    inline wxVariant wxPGVariantCreator(wxObject* a) { return wxVariant(a); }
    inline wxVariant wxPGVariantCreator(wxObject& a) { return wxVariant(&a); }
    inline wxVariant wxPGVariantCreator(void* a) { return wxVariant(a); }
    inline wxVariant wxPGVariantCreator(const wxArrayString& a) { return wxVariant((wxArrayString&)a); }
    inline wxVariant wxPGVariantCreator(const wxArrayInt& a) { return wxVariant(new wxPGVariantDataArrayInt(a)); }
    inline wxVariant wxPGVariantCreator(const wxPoint& a) { return wxVariant(new wxPGVariantDataPoint(a)); }
    inline wxVariant wxPGVariantCreator(const wxSize& a) { return wxVariant(new wxPGVariantDataSize(a)); }
    inline wxVariant wxPGVariantCreator(const wxLongLong& a) { return wxVariant(new wxPGVariantDataLongLong(a)); }
    inline wxVariant wxPGVariantCreator(const wxULongLong& a) { return wxVariant(new wxPGVariantDataULongLong(a)); }
   #ifdef __WXPYTHON__
    inline wxVariant wxPGVariantCreator(PyObject* a) { return wxVariant(new wxPGVariantDataPyObject(a)); }
   #endif
   #if wxUSE_DATETIME
    inline wxVariant wxPGVariantCreator(const wxDateTime& a) { return wxVariant(a); }
   #endif
  #endif // !defined(SWIG)

#else // !wxPG_PGVARIANT_IS_VARIANT

union wxPGVariantUnion
{
    long        m_long;
    void*       m_ptr;
    bool        m_bool;
};

//
// Very simple value wrapper class
//
// NB: It only holds the pointers for a short period, so don't
//     worry about it not making copies.
class WXDLLIMPEXP_PG wxPGVariant
{
public:

    /** Constructor for none. */
    wxPGVariant()
    {
        m_v.m_ptr = (void*)NULL;
    }
#ifndef SWIG
    /** Constructor for long integer. */
    wxPGVariant( long v_long )
    {
        m_v.m_long = v_long;
    }
    /** Constructor for integer. */
    wxPGVariant( int v_long )
    {
        m_v.m_long = v_long;
    }
    /** Constructor for bool. */
    wxPGVariant( bool value )
    {
        m_v.m_bool = value;
    }
    /** Constructor for float. */
    wxPGVariant( const double& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxString*. */
    wxPGVariant( const wxString& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxArrayString*. */
    wxPGVariant( const wxArrayString& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxArrayInt. */
    wxPGVariant( const wxArrayInt& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxPoint. */
    wxPGVariant( const wxPoint& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxSize. */
    wxPGVariant( const wxSize& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxLongLong. */
    wxPGVariant( const wxLongLong& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxULongLong. */
    wxPGVariant( const wxULongLong& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxObject&. */
    wxPGVariant( const wxObject& v_ptr )
    {
        m_v.m_ptr = (void*)&v_ptr;
    }
    /** Constructor for wxObject*. */
    wxPGVariant( const wxObject* v_ptr )
    {
        m_v.m_ptr = (void*)v_ptr;
    }
    /** Constructor for void*. */
    wxPGVariant( void* v_ptr )
    {
        m_v.m_ptr = v_ptr;
    }
#if wxUSE_DATETIME
    /** Constructor for wxDateTime ptr. */
    wxPGVariant( const wxDateTime& dt )
    {
        m_v.m_ptr = (void*) &dt;
    }
#endif

    /** Returns value as long integer. */
    inline long GetLong() const
    {
        return m_v.m_long;
    }
    /** Returns value as boolean integer. */
    inline bool GetBool() const
    {
        return m_v.m_bool;
    }
    /** Returns value as floating point number. */
    inline double GetDouble() const
    {
        return *((double*)m_v.m_ptr);
    }
    /** Returns value as floating point number ptr. */
    inline double* GetDoublePtr() const
    {
        return (double*) m_v.m_ptr;
    }
    /** Returns value as a wxString. */
    inline const wxString& GetString() const
    {
        return *((const wxString*)m_v.m_ptr);
    }
    /** Returns value as a reference to a wxArrayString. */
    inline wxArrayString& GetArrayString() const
    {
        wxArrayString* temp = (wxArrayString*)m_v.m_ptr;
        return *temp;
    }

    inline const wxObject& GetWxObject() const
    {
        return *((const wxObject*)m_v.m_ptr);
    }

    inline wxObject* GetWxObjectPtr() const
    {
        return (wxObject*)m_v.m_ptr;
    }

    /** Returns value as void*. */
    inline void* GetVoidPtr() const
    {
        return m_v.m_ptr;
    }
#if wxUSE_DATETIME
    /** Returns value as const wxDateTime&. */
    inline const wxDateTime& GetDateTime() const
    {
        return *((const wxDateTime*)m_v.m_ptr);
    }
#endif

#endif // #ifndef SWIG

    /** Returns value as long integer without type checking. */
    inline long GetRawLong() const { return m_v.m_long; }

    /** Returns value as void* without type checking. */
    inline void* GetRawPtr() const { return m_v.m_ptr; }

#undef wxPG_ASSERT_VARIANT_GET

    /** Value in portable format. */
    wxPGVariantUnion          m_v;
};

    #define wxPGVariantGetWxObjectPtr(A)    ((wxObject*)A.GetRawPtr())
    #define wxPGVariantToWxObjectPtr(A,B)   wxDynamicCast((wxObject*)A.GetRawPtr(),B);
    #define wxPGVariantToWxObject(A)        A.GetWxObject()
    #define wxPGVariantToDateTime(A)        *((wxDateTime*)A.GetVoidPtr())
    #define wxPGVariantToWxPoint(A)         *((wxPoint*)wxPGVariantToVoidPtr(A))
    #define wxPGVariantToWxSize(A)          *((wxSize*)wxPGVariantToVoidPtr(A))
    #define wxPGVariantToWxLongLong(A)      *((wxLongLong*)wxPGVariantToVoidPtr(A))
    #define wxPGVariantToWxULongLong(A)     *((wxULongLong*)wxPGVariantToVoidPtr(A))
    #define wxPGVariantToArrayInt(A)        *((wxArrayInt*)A.GetVoidPtr())
    #define wxPGVariantFromWxObject(A)      *((const wxObject*)A)
    #define wxPGVariantFromLong(A)          wxPGVariant(A)
    #define wxPGVariantCreator              wxPGVariant

#endif // !wxPG_PGVARIANT_IS_VARIANT

// Helper macros
#define wxPGVariantToString(A)      A.GetString()
#define wxPGVariantToLong(A)        A.GetLong()
#define wxPGVariantToBool(A)        A.GetBool()
#define wxPGVariantToDouble(A)      A.GetDouble()
#define wxPGVariantToArrayString(A) A.GetArrayString()
#define wxPGVariantToVoidPtr(A)     A.GetVoidPtr()

#define wxPGVariantFromString(A)        A
#define wxPGVariantFromDouble(A)        A
#define wxPGVariantFromArrayString(A)   A
#define wxPGVariantFromBool(A)          A


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

//
// Property class declaration helper macros
// (wxPGRootPropertyClass and wxPropertyCategory require this).
//

#define WX_PG_DECLARE_CLASSINFO() \
    WX_PG_DECLARE_GETCLASSNAME \
    WX_PG_DECLARE_GETCLASSINFO \

// We don't want to create SWIG interface for DoGetEditorClass (we'll use GetEditor instead)
#ifndef SWIG
    #define WX_PG_DECLARE_DOGETEDITORCLASS  virtual const wxPGEditor* DoGetEditorClass() const;
#else
    #define WX_PG_DECLARE_DOGETEDITORCLASS
#endif

#define WX_PG_DECLARE_PROPERTY_CLASS() \
public: \
    virtual wxPG_VALUETYPE_MSGVAL GetValueType() const; \
    WX_PG_DECLARE_DOGETEDITORCLASS \
    WX_PG_DECLARE_CLASSINFO() \
private:


// Added for SWIG (which apparently doesn't support 0-argument macros)
// NB: Othwise, this is *identical* to WX_PG_DECLARE_PROPERTY_CLASS()
#define WX_PG_DECLARE_PROPERTY_CLASS_NOPARENS \
public: \
    virtual wxPG_VALUETYPE_MSGVAL GetValueType() const; \
    WX_PG_DECLARE_DOGETEDITORCLASS \
    WX_PG_DECLARE_CLASSINFO() \
private:



#ifndef SWIG

// -----------------------------------------------------------------------
// wxPGPropertyClassInfo


typedef wxPGProperty* (*wxPGPropertyConstructor) (const wxString&,const wxString&);

/** \class wxPGPropertyClassInfo
	\ingroup classes
    \brief Class info structure for wxPGProperty derivatives (may be deprecated
    in a future release).
*/
struct wxPGPropertyClassInfo
{