44a0071224
Use explicit c_str() calls in XTI code as implicit conversion to "const char *" doesn't exist in STL build. This fixes compilation problems when wxUSE_EXTENDED_RTTI && wxUSE_STL. Closes #13087. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@67342 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
973 lines
27 KiB
C++
973 lines
27 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: src/common/xti.cpp
|
|
// Purpose: runtime metadata information (extended class info)
|
|
// Author: Stefan Csomor
|
|
// Modified by:
|
|
// Created: 27/07/03
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) 1997 Julian Smart
|
|
// (c) 2003 Stefan Csomor
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// For compilers that support precompilation, includes "wx.h".
|
|
#include "wx/wxprec.h"
|
|
|
|
#ifdef __BORLANDC__
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
#if wxUSE_EXTENDED_RTTI
|
|
|
|
#ifndef WX_PRECOMP
|
|
#include "wx/object.h"
|
|
#include "wx/list.h"
|
|
#include "wx/hash.h"
|
|
#endif
|
|
|
|
#include "wx/xti.h"
|
|
#include "wx/xml/xml.h"
|
|
#include "wx/tokenzr.h"
|
|
#include "wx/range.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "wx/beforestd.h"
|
|
#include <map>
|
|
#include <string>
|
|
#include <list>
|
|
#include "wx/afterstd.h"
|
|
|
|
using namespace std;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxEnumData
|
|
// ----------------------------------------------------------------------------
|
|
|
|
wxEnumData::wxEnumData( wxEnumMemberData* data )
|
|
{
|
|
m_members = data;
|
|
for ( m_count = 0; m_members[m_count].m_name; m_count++)
|
|
{};
|
|
}
|
|
|
|
bool wxEnumData::HasEnumMemberValue(const wxChar *name, int *value) const
|
|
{
|
|
int i;
|
|
for (i = 0; m_members[i].m_name; i++ )
|
|
{
|
|
if (!wxStrcmp(name, m_members[i].m_name))
|
|
{
|
|
if ( value )
|
|
*value = m_members[i].m_value;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int wxEnumData::GetEnumMemberValue(const wxChar *name) const
|
|
{
|
|
int i;
|
|
for (i = 0; m_members[i].m_name; i++ )
|
|
{
|
|
if (!wxStrcmp(name, m_members[i].m_name))
|
|
{
|
|
return m_members[i].m_value;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const wxChar *wxEnumData::GetEnumMemberName(int value) const
|
|
{
|
|
int i;
|
|
for (i = 0; m_members[i].m_name; i++)
|
|
if (value == m_members[i].m_value)
|
|
return m_members[i].m_name;
|
|
|
|
return wxEmptyString;
|
|
}
|
|
|
|
int wxEnumData::GetEnumMemberValueByIndex( int idx ) const
|
|
{
|
|
// we should cache the count in order to avoid out-of-bounds errors
|
|
return m_members[idx].m_value;
|
|
}
|
|
|
|
const wxChar * wxEnumData::GetEnumMemberNameByIndex( int idx ) const
|
|
{
|
|
// we should cache the count in order to avoid out-of-bounds errors
|
|
return m_members[idx].m_name;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Type Information
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// value streaming
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// streamer specializations
|
|
// for all built-in types
|
|
|
|
// bool
|
|
|
|
template<> void wxStringReadValue(const wxString &s, bool &data )
|
|
{
|
|
int intdata;
|
|
wxSscanf(s, _T("%d"), &intdata );
|
|
data = (bool)(intdata != 0);
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const bool &data )
|
|
{
|
|
s = wxString::Format(_T("%d"), data );
|
|
}
|
|
|
|
// char
|
|
|
|
template<> void wxStringReadValue(const wxString &s, char &data )
|
|
{
|
|
int intdata;
|
|
wxSscanf(s, _T("%d"), &intdata );
|
|
data = char(intdata);
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const char &data )
|
|
{
|
|
s = wxString::Format(_T("%d"), data );
|
|
}
|
|
|
|
// unsigned char
|
|
|
|
template<> void wxStringReadValue(const wxString &s, unsigned char &data )
|
|
{
|
|
int intdata;
|
|
wxSscanf(s, _T("%d"), &intdata );
|
|
data = (unsigned char)(intdata);
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const unsigned char &data )
|
|
{
|
|
s = wxString::Format(_T("%d"), data );
|
|
}
|
|
|
|
// int
|
|
|
|
template<> void wxStringReadValue(const wxString &s, int &data )
|
|
{
|
|
wxSscanf(s, _T("%d"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const int &data )
|
|
{
|
|
s = wxString::Format(_T("%d"), data );
|
|
}
|
|
|
|
// unsigned int
|
|
|
|
template<> void wxStringReadValue(const wxString &s, unsigned int &data )
|
|
{
|
|
wxSscanf(s, _T("%d"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const unsigned int &data )
|
|
{
|
|
s = wxString::Format(_T("%d"), data );
|
|
}
|
|
|
|
// long
|
|
|
|
template<> void wxStringReadValue(const wxString &s, long &data )
|
|
{
|
|
wxSscanf(s, _T("%ld"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const long &data )
|
|
{
|
|
s = wxString::Format(_T("%ld"), data );
|
|
}
|
|
|
|
// unsigned long
|
|
|
|
template<> void wxStringReadValue(const wxString &s, unsigned long &data )
|
|
{
|
|
wxSscanf(s, _T("%ld"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const unsigned long &data )
|
|
{
|
|
s = wxString::Format(_T("%ld"), data );
|
|
}
|
|
|
|
#ifdef wxLongLong_t
|
|
template<> void wxStringReadValue(const wxString &s, wxLongLong_t &data )
|
|
{
|
|
wxSscanf(s, _T("%lld"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const wxLongLong_t &data )
|
|
{
|
|
s = wxString::Format(_T("%lld"), data );
|
|
}
|
|
|
|
template<> void wxStringReadValue(const wxString &s, wxULongLong_t &data )
|
|
{
|
|
wxSscanf(s, _T("%lld"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const wxULongLong_t &data )
|
|
{
|
|
s = wxString::Format(_T("%lld"), data );
|
|
}
|
|
#endif
|
|
// float
|
|
|
|
template<> void wxStringReadValue(const wxString &s, float &data )
|
|
{
|
|
wxSscanf(s, _T("%f"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const float &data )
|
|
{
|
|
s = wxString::Format(_T("%f"), data );
|
|
}
|
|
|
|
// double
|
|
|
|
template<> void wxStringReadValue(const wxString &s, double &data )
|
|
{
|
|
wxSscanf(s, _T("%lf"), &data );
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const double &data )
|
|
{
|
|
s = wxString::Format(_T("%lf"), data );
|
|
}
|
|
|
|
// wxString
|
|
|
|
template<> void wxStringReadValue(const wxString &s, wxString &data )
|
|
{
|
|
data = s;
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s, const wxString &data )
|
|
{
|
|
s = data;
|
|
}
|
|
|
|
|
|
// built-ins
|
|
//
|
|
|
|
#if wxUSE_FUNC_TEMPLATE_POINTER
|
|
#define wxBUILTIN_TYPE_INFO( element, type ) \
|
|
wxBuiltInTypeInfo \
|
|
s_typeInfo##type(element, &wxToStringConverter<type>, \
|
|
&wxFromStringConverter<type>, typeid(type).name());
|
|
#else
|
|
#define wxBUILTIN_TYPE_INFO( element, type ) \
|
|
void _toString##element( const wxAny& data, wxString &result ) \
|
|
{ wxToStringConverter<type, data, result); } \
|
|
void _fromString##element( const wxString& data, wxAny &result ) \
|
|
{ wxFromStringConverter<type, data, result); } \
|
|
wxBuiltInTypeInfo s_typeInfo##type(element, &_toString##element, \
|
|
&_fromString##element, typeid(type).name());
|
|
#endif
|
|
|
|
typedef unsigned char unsigned_char;
|
|
typedef unsigned int unsigned_int;
|
|
typedef unsigned long unsigned_long;
|
|
|
|
wxBuiltInTypeInfo s_typeInfovoid( wxT_VOID, NULL, NULL, typeid(void).name());
|
|
wxBUILTIN_TYPE_INFO( wxT_BOOL, bool);
|
|
wxBUILTIN_TYPE_INFO( wxT_CHAR, char);
|
|
wxBUILTIN_TYPE_INFO( wxT_UCHAR, unsigned_char);
|
|
wxBUILTIN_TYPE_INFO( wxT_INT, int);
|
|
wxBUILTIN_TYPE_INFO( wxT_UINT, unsigned_int);
|
|
wxBUILTIN_TYPE_INFO( wxT_LONG, long);
|
|
wxBUILTIN_TYPE_INFO( wxT_ULONG, unsigned_long);
|
|
wxBUILTIN_TYPE_INFO( wxT_FLOAT, float);
|
|
wxBUILTIN_TYPE_INFO( wxT_DOUBLE, double);
|
|
wxBUILTIN_TYPE_INFO( wxT_STRING, wxString);
|
|
|
|
#ifdef wxLongLong_t
|
|
wxBUILTIN_TYPE_INFO(wxT_LONGLONG, wxLongLong_t)
|
|
wxBUILTIN_TYPE_INFO(wxT_ULONGLONG, wxULongLong_t)
|
|
#endif
|
|
|
|
// this are compiler induced specialization which are never used anywhere
|
|
|
|
wxILLEGAL_TYPE_SPECIALIZATION( char const * )
|
|
wxILLEGAL_TYPE_SPECIALIZATION( char * )
|
|
wxILLEGAL_TYPE_SPECIALIZATION( unsigned char * )
|
|
wxILLEGAL_TYPE_SPECIALIZATION( int * )
|
|
wxILLEGAL_TYPE_SPECIALIZATION( bool * )
|
|
wxILLEGAL_TYPE_SPECIALIZATION( long * )
|
|
wxILLEGAL_TYPE_SPECIALIZATION( wxString * )
|
|
|
|
// wxRange
|
|
|
|
template<> void wxStringReadValue(const wxString &s , wxRange &data)
|
|
{
|
|
int minValue, maxValue;
|
|
wxSscanf(s, wxT("%d,%d"), &minValue , &maxValue);
|
|
data = wxRange(minValue, maxValue);
|
|
}
|
|
|
|
template<> void wxStringWriteValue(wxString &s , const wxRange &data)
|
|
{
|
|
s = wxString::Format(wxT("%d,%d"), data.GetMin() , data.GetMax());
|
|
}
|
|
|
|
wxCUSTOM_TYPE_INFO(wxRange, wxToStringConverter<wxRange> , wxFromStringConverter<wxRange>)
|
|
|
|
// other types
|
|
|
|
wxCOLLECTION_TYPE_INFO( wxString, wxArrayString );
|
|
|
|
template<> void wxCollectionToVariantArray( wxArrayString const &theArray,
|
|
wxAnyList &value)
|
|
{
|
|
wxArrayCollectionToVariantArray( theArray, value );
|
|
}
|
|
|
|
wxTypeInfoMap *wxTypeInfo::ms_typeTable = NULL;
|
|
|
|
wxTypeInfo *wxTypeInfo::FindType(const wxString& typeName)
|
|
{
|
|
wxTypeInfoMap::iterator iter = ms_typeTable->find(typeName);
|
|
|
|
if (iter == ms_typeTable->end())
|
|
return NULL;
|
|
|
|
return (wxTypeInfo *)iter->second;
|
|
}
|
|
|
|
wxClassTypeInfo::wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo,
|
|
wxVariant2StringFnc to,
|
|
wxString2VariantFnc from,
|
|
const wxString &name) :
|
|
wxTypeInfo( kind, to, from, name)
|
|
{
|
|
wxASSERT_MSG( kind == wxT_OBJECT_PTR || kind == wxT_OBJECT,
|
|
wxT("Illegal Kind for Enum Type")); m_classInfo = classInfo;
|
|
}
|
|
|
|
wxEventSourceTypeInfo::wxEventSourceTypeInfo( int eventType, wxClassInfo* eventClass,
|
|
wxVariant2StringFnc to,
|
|
wxString2VariantFnc from ) :
|
|
wxTypeInfo ( wxT_DELEGATE, to, from, wxEmptyString )
|
|
{
|
|
m_eventClass = eventClass;
|
|
m_eventType = eventType;
|
|
m_lastEventType = -1;
|
|
}
|
|
|
|
wxEventSourceTypeInfo::wxEventSourceTypeInfo( int eventType, int lastEventType,
|
|
wxClassInfo* eventClass,
|
|
wxVariant2StringFnc to,
|
|
wxString2VariantFnc from ) :
|
|
wxTypeInfo ( wxT_DELEGATE, to, from, wxEmptyString )
|
|
{
|
|
m_eventClass = eventClass;
|
|
m_eventType = eventType;
|
|
m_lastEventType = lastEventType;
|
|
}
|
|
|
|
void wxTypeInfo::Register()
|
|
{
|
|
if ( ms_typeTable == NULL )
|
|
ms_typeTable = new wxTypeInfoMap();
|
|
|
|
if( !m_name.empty() )
|
|
(*ms_typeTable)[m_name] = this;
|
|
}
|
|
|
|
void wxTypeInfo::Unregister()
|
|
{
|
|
if( !m_name.empty() )
|
|
ms_typeTable->erase(m_name);
|
|
}
|
|
|
|
// removing header dependancy on string tokenizer
|
|
|
|
void wxSetStringToArray( const wxString &s, wxArrayString &array )
|
|
{
|
|
wxStringTokenizer tokenizer(s, wxT("| \t\n"), wxTOKEN_STRTOK);
|
|
wxString flag;
|
|
array.Clear();
|
|
while (tokenizer.HasMoreTokens())
|
|
{
|
|
array.Add(tokenizer.GetNextToken());
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxPropertyInfo
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxPropertyInfo::Insert(wxPropertyInfo* &iter)
|
|
{
|
|
m_next = NULL;
|
|
if ( iter == NULL )
|
|
iter = this;
|
|
else
|
|
{
|
|
wxPropertyInfo* i = iter;
|
|
while( i->m_next )
|
|
i = i->m_next;
|
|
|
|
i->m_next = this;
|
|
}
|
|
}
|
|
|
|
void wxPropertyInfo::Remove()
|
|
{
|
|
if ( this == m_itsClass->m_firstProperty )
|
|
{
|
|
m_itsClass->m_firstProperty = m_next;
|
|
}
|
|
else
|
|
{
|
|
wxPropertyInfo *info = m_itsClass->m_firstProperty;
|
|
while (info)
|
|
{
|
|
if ( info->m_next == this )
|
|
{
|
|
info->m_next = m_next;
|
|
break;
|
|
}
|
|
|
|
info = info->m_next;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxHandlerInfo
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void wxHandlerInfo::Insert(wxHandlerInfo* &iter)
|
|
{
|
|
m_next = NULL;
|
|
if ( iter == NULL )
|
|
iter = this;
|
|
else
|
|
{
|
|
wxHandlerInfo* i = iter;
|
|
while( i->m_next )
|
|
i = i->m_next;
|
|
|
|
i->m_next = this;
|
|
}
|
|
}
|
|
|
|
void wxHandlerInfo::Remove()
|
|
{
|
|
if ( this == m_itsClass->m_firstHandler )
|
|
{
|
|
m_itsClass->m_firstHandler = m_next;
|
|
}
|
|
else
|
|
{
|
|
wxHandlerInfo *info = m_itsClass->m_firstHandler;
|
|
while (info)
|
|
{
|
|
if ( info->m_next == this )
|
|
{
|
|
info->m_next = m_next;
|
|
break;
|
|
}
|
|
|
|
info = info->m_next;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxClassInfo
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool wxClassInfo::Create(wxObject *object, int ParamCount, wxAny *Params) const
|
|
{
|
|
if ( ParamCount != m_constructorPropertiesCount )
|
|
{
|
|
// FIXME: shouldn't we just return false and let the caller handle it?
|
|
wxLogError( _("Illegal Parameter Count for Create Method") );
|
|
return false;
|
|
}
|
|
|
|
return m_constructor->Create( object, Params );
|
|
}
|
|
|
|
wxObject *wxClassInfo::ConstructObject(int ParamCount, wxAny *Params) const
|
|
{
|
|
if ( ParamCount != m_constructorPropertiesCount )
|
|
{
|
|
// FIXME: shouldn't we just return NULL and let the caller handle this case?
|
|
wxLogError( _("Illegal Parameter Count for ConstructObject Method") );
|
|
return NULL;
|
|
}
|
|
|
|
wxObject *object = NULL;
|
|
if (!m_constructor->Create( object, Params ))
|
|
return NULL;
|
|
return object;
|
|
}
|
|
|
|
bool wxClassInfo::IsKindOf(const wxClassInfo *info) const
|
|
{
|
|
if ( info != 0 )
|
|
{
|
|
if ( info == this )
|
|
return true;
|
|
|
|
for ( int i = 0; m_parents[i]; ++ i )
|
|
{
|
|
if ( m_parents[i]->IsKindOf( info ) )
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const wxPropertyAccessor *wxClassInfo::FindAccessor(const wxChar *PropertyName) const
|
|
{
|
|
const wxPropertyInfo* info = FindPropertyInfo( PropertyName );
|
|
|
|
if ( info )
|
|
return info->GetAccessor();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const wxChar *PropertyName) const
|
|
{
|
|
wxPropertyInfo* info = GetFirstProperty();
|
|
|
|
while( info )
|
|
{
|
|
if ( wxStrcmp( info->GetName(), PropertyName ) == 0 )
|
|
return info;
|
|
info = info->GetNext();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const wxChar *PropertyName) const
|
|
{
|
|
const wxPropertyInfo* info = FindPropertyInfoInThisClass( PropertyName );
|
|
if ( info )
|
|
return info;
|
|
|
|
const wxClassInfo** parents = GetParents();
|
|
for ( int i = 0; parents[i]; ++ i )
|
|
{
|
|
if ( ( info = parents[i]->FindPropertyInfo( PropertyName ) ) != NULL )
|
|
return info;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const wxChar *PropertyName) const
|
|
{
|
|
wxHandlerInfo* info = GetFirstHandler();
|
|
|
|
while( info )
|
|
{
|
|
if ( wxStrcmp( info->GetName(), PropertyName ) == 0 )
|
|
return info;
|
|
info = info->GetNext();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const wxChar *PropertyName) const
|
|
{
|
|
const wxHandlerInfo* info = FindHandlerInfoInThisClass( PropertyName );
|
|
|
|
if ( info )
|
|
return info;
|
|
|
|
const wxClassInfo** parents = GetParents();
|
|
for ( int i = 0; parents[i]; ++ i )
|
|
{
|
|
if ( ( info = parents[i]->FindHandlerInfo( PropertyName ) ) != NULL )
|
|
return info;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
wxObjectStreamingCallback wxClassInfo::GetStreamingCallback() const
|
|
{
|
|
if ( m_streamingCallback )
|
|
return m_streamingCallback;
|
|
|
|
wxObjectStreamingCallback retval = NULL;
|
|
const wxClassInfo** parents = GetParents();
|
|
for ( int i = 0; parents[i] && retval == NULL; ++ i )
|
|
{
|
|
retval = parents[i]->GetStreamingCallback();
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
bool wxClassInfo::BeforeWriteObject( const wxObject *obj, wxObjectWriter *streamer,
|
|
wxObjectWriterCallback *writercallback, const wxStringToAnyHashMap &metadata) const
|
|
{
|
|
wxObjectStreamingCallback sb = GetStreamingCallback();
|
|
if ( sb )
|
|
return (*sb)(obj, streamer, writercallback, metadata );
|
|
|
|
return true;
|
|
}
|
|
|
|
void wxClassInfo::SetProperty(wxObject *object, const wxChar *propertyName,
|
|
const wxAny &value) const
|
|
{
|
|
const wxPropertyAccessor *accessor;
|
|
|
|
accessor = FindAccessor(propertyName);
|
|
wxASSERT(accessor->HasSetter());
|
|
accessor->SetProperty( object, value );
|
|
}
|
|
|
|
wxAny wxClassInfo::GetProperty(wxObject *object, const wxChar *propertyName) const
|
|
{
|
|
const wxPropertyAccessor *accessor;
|
|
|
|
accessor = FindAccessor(propertyName);
|
|
wxASSERT(accessor->HasGetter());
|
|
wxAny result;
|
|
accessor->GetProperty(object,result);
|
|
return result;
|
|
}
|
|
|
|
wxAnyList wxClassInfo::GetPropertyCollection(wxObject *object,
|
|
const wxChar *propertyName) const
|
|
{
|
|
const wxPropertyAccessor *accessor;
|
|
|
|
accessor = FindAccessor(propertyName);
|
|
wxASSERT(accessor->HasGetter());
|
|
wxAnyList result;
|
|
accessor->GetPropertyCollection(object,result);
|
|
return result;
|
|
}
|
|
|
|
void wxClassInfo::AddToPropertyCollection(wxObject *object, const wxChar *propertyName,
|
|
const wxAny& value) const
|
|
{
|
|
const wxPropertyAccessor *accessor;
|
|
|
|
accessor = FindAccessor(propertyName);
|
|
wxASSERT(accessor->HasAdder());
|
|
accessor->AddToPropertyCollection( object, value );
|
|
}
|
|
|
|
// void wxClassInfo::GetProperties( wxPropertyInfoMap &map ) const
|
|
// The map parameter (the name map that is) seems something special
|
|
// to MSVC and so we use a other name.
|
|
void wxClassInfo::GetProperties( wxPropertyInfoMap &infomap ) const
|
|
{
|
|
const wxPropertyInfo *pi = GetFirstProperty();
|
|
while( pi )
|
|
{
|
|
if ( infomap.find( pi->GetName() ) == infomap.end() )
|
|
infomap[pi->GetName()] = (wxPropertyInfo*) pi;
|
|
|
|
pi = pi->GetNext();
|
|
}
|
|
|
|
const wxClassInfo** parents = GetParents();
|
|
for ( int i = 0; parents[i]; ++ i )
|
|
{
|
|
parents[i]->GetProperties( infomap );
|
|
}
|
|
}
|
|
|
|
wxObject* wxClassInfo::AnyToObjectPtr( const wxAny &data) const
|
|
{
|
|
return m_variantOfPtrToObjectConverter(data);
|
|
}
|
|
|
|
void wxClassInfo::CallOnAny( const wxAny &data, wxObjectFunctor* functor ) const
|
|
{
|
|
if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
|
|
return m_variantToObjectConverter(data, functor);
|
|
else
|
|
return (*functor)(m_variantOfPtrToObjectConverter(data));
|
|
}
|
|
|
|
wxAny wxClassInfo::ObjectPtrToAny( wxObject* obj) const
|
|
{
|
|
return m_objectToVariantConverter(obj);
|
|
}
|
|
|
|
bool wxClassInfo::NeedsDirectConstruction() const
|
|
{
|
|
return wx_dynamic_cast(wxObjectAllocator*, m_constructor) != NULL;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxDynamicObject support
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Dynamic Objects are objects that have a real superclass instance and carry their
|
|
// own attributes in a hash map. Like this it is possible to create the objects and
|
|
// stream them, as if their class information was already available from compiled data
|
|
|
|
struct wxDynamicObject::wxDynamicObjectInternal
|
|
{
|
|
wxDynamicObjectInternal() {}
|
|
|
|
wxStringToAnyHashMap m_properties;
|
|
};
|
|
|
|
typedef list< wxDynamicObject* > wxDynamicObjectList;
|
|
|
|
struct wxDynamicClassInfo::wxDynamicClassInfoInternal
|
|
{
|
|
wxDynamicObjectList m_dynamicObjects;
|
|
};
|
|
|
|
// instantiates this object with an instance of its superclass
|
|
wxDynamicObject::wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info)
|
|
{
|
|
m_superClassInstance = superClassInstance;
|
|
m_classInfo = info;
|
|
m_data = new wxDynamicObjectInternal;
|
|
}
|
|
|
|
wxDynamicObject::~wxDynamicObject()
|
|
{
|
|
wx_dynamic_cast(const wxDynamicClassInfo*, m_classInfo)->
|
|
m_data->m_dynamicObjects.remove( this );
|
|
delete m_data;
|
|
delete m_superClassInstance;
|
|
}
|
|
|
|
void wxDynamicObject::SetProperty (const wxChar *propertyName, const wxAny &value)
|
|
{
|
|
wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),
|
|
wxT("Accessing Unknown Property in a Dynamic Object") );
|
|
m_data->m_properties[propertyName] = value;
|
|
}
|
|
|
|
wxAny wxDynamicObject::GetProperty (const wxChar *propertyName) const
|
|
{
|
|
wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),
|
|
wxT("Accessing Unknown Property in a Dynamic Object") );
|
|
return m_data->m_properties[propertyName];
|
|
}
|
|
|
|
void wxDynamicObject::RemoveProperty( const wxChar *propertyName )
|
|
{
|
|
wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),
|
|
wxT("Removing Unknown Property in a Dynamic Object") );
|
|
m_data->m_properties.erase( propertyName );
|
|
}
|
|
|
|
void wxDynamicObject::RenameProperty( const wxChar *oldPropertyName,
|
|
const wxChar *newPropertyName )
|
|
{
|
|
wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(oldPropertyName),
|
|
wxT("Renaming Unknown Property in a Dynamic Object") );
|
|
|
|
wxAny value = m_data->m_properties[oldPropertyName];
|
|
m_data->m_properties.erase( oldPropertyName );
|
|
m_data->m_properties[newPropertyName] = value;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxDynamicClassInfo
|
|
// ----------------------------------------------------------------------------
|
|
|
|
wxDynamicClassInfo::wxDynamicClassInfo( const wxChar *unitName,
|
|
const wxChar *className,
|
|
const wxClassInfo* superClass ) :
|
|
wxClassInfo( unitName, className, new const wxClassInfo*[2])
|
|
{
|
|
GetParents()[0] = superClass;
|
|
GetParents()[1] = NULL;
|
|
m_data = new wxDynamicClassInfoInternal;
|
|
}
|
|
|
|
wxDynamicClassInfo::~wxDynamicClassInfo()
|
|
{
|
|
delete[] GetParents();
|
|
delete m_data;
|
|
}
|
|
|
|
wxObject *wxDynamicClassInfo::AllocateObject() const
|
|
{
|
|
wxObject* parent = GetParents()[0]->AllocateObject();
|
|
wxDynamicObject *obj = new wxDynamicObject( parent, this );
|
|
m_data->m_dynamicObjects.push_back( obj );
|
|
return obj;
|
|
}
|
|
|
|
bool wxDynamicClassInfo::Create (wxObject *object, int paramCount, wxAny *params) const
|
|
{
|
|
wxDynamicObject *dynobj = wx_dynamic_cast( wxDynamicObject *, object );
|
|
wxASSERT_MSG( dynobj,
|
|
wxT("cannot call wxDynamicClassInfo::Create on ")
|
|
wxT("an object other than wxDynamicObject") );
|
|
|
|
return GetParents()[0]->Create( dynobj->GetSuperClassInstance(), paramCount, params );
|
|
}
|
|
|
|
// get number of parameters for constructor
|
|
int wxDynamicClassInfo::GetCreateParamCount() const
|
|
{
|
|
return GetParents()[0]->GetCreateParamCount();
|
|
}
|
|
|
|
// get i-th constructor parameter
|
|
const wxChar* wxDynamicClassInfo::GetCreateParamName(int i) const
|
|
{
|
|
return GetParents()[0]->GetCreateParamName( i );
|
|
}
|
|
|
|
void wxDynamicClassInfo::SetProperty(wxObject *object, const wxChar *propertyName, const wxAny &value) const
|
|
{
|
|
wxDynamicObject* dynobj = wx_dynamic_cast(wxDynamicObject*, object);
|
|
wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
|
|
if ( FindPropertyInfoInThisClass(propertyName) )
|
|
dynobj->SetProperty( propertyName, value );
|
|
else
|
|
GetParents()[0]->SetProperty( dynobj->GetSuperClassInstance(), propertyName, value );
|
|
}
|
|
|
|
wxAny wxDynamicClassInfo::GetProperty(wxObject *object, const wxChar *propertyName) const
|
|
{
|
|
wxDynamicObject* dynobj = wx_dynamic_cast(wxDynamicObject*, object);
|
|
wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
|
|
if ( FindPropertyInfoInThisClass(propertyName) )
|
|
return dynobj->GetProperty( propertyName );
|
|
else
|
|
return GetParents()[0]->GetProperty( dynobj->GetSuperClassInstance(), propertyName );
|
|
}
|
|
|
|
void wxDynamicClassInfo::AddProperty( const wxChar *propertyName, const wxTypeInfo* typeInfo )
|
|
{
|
|
EnsureInfosInited();
|
|
new wxPropertyInfo( m_firstProperty, this, propertyName, typeInfo->GetTypeName(), new wxGenericPropertyAccessor( propertyName ), wxAny() );
|
|
}
|
|
|
|
void wxDynamicClassInfo::AddHandler( const wxChar *handlerName, wxObjectEventFunction address, const wxClassInfo* eventClassInfo )
|
|
{
|
|
EnsureInfosInited();
|
|
new wxHandlerInfo( m_firstHandler, this, handlerName, address, eventClassInfo );
|
|
}
|
|
|
|
// removes an existing runtime-property
|
|
void wxDynamicClassInfo::RemoveProperty( const wxChar *propertyName )
|
|
{
|
|
for ( wxDynamicObjectList::iterator iter = m_data->m_dynamicObjects.begin(); iter != m_data->m_dynamicObjects.end(); ++iter )
|
|
(*iter)->RemoveProperty( propertyName );
|
|
delete FindPropertyInfoInThisClass(propertyName);
|
|
}
|
|
|
|
// removes an existing runtime-handler
|
|
void wxDynamicClassInfo::RemoveHandler( const wxChar *handlerName )
|
|
{
|
|
delete FindHandlerInfoInThisClass(handlerName);
|
|
}
|
|
|
|
// renames an existing runtime-property
|
|
void wxDynamicClassInfo::RenameProperty( const wxChar *oldPropertyName, const wxChar *newPropertyName )
|
|
{
|
|
wxPropertyInfo* pi = FindPropertyInfoInThisClass(oldPropertyName);
|
|
wxASSERT_MSG( pi,wxT("not existing property") );
|
|
pi->m_name = newPropertyName;
|
|
wx_dynamic_cast(wxGenericPropertyAccessor*, pi->GetAccessor())->RenameProperty( oldPropertyName, newPropertyName );
|
|
for ( wxDynamicObjectList::iterator iter = m_data->m_dynamicObjects.begin(); iter != m_data->m_dynamicObjects.end(); ++iter )
|
|
(*iter)->RenameProperty( oldPropertyName, newPropertyName );
|
|
}
|
|
|
|
// renames an existing runtime-handler
|
|
void wxDynamicClassInfo::RenameHandler( const wxChar *oldHandlerName, const wxChar *newHandlerName )
|
|
{
|
|
wxASSERT_MSG(FindHandlerInfoInThisClass(oldHandlerName),wxT("not existing handler") );
|
|
FindHandlerInfoInThisClass(oldHandlerName)->m_name = newHandlerName;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxGenericPropertyAccessor
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct wxGenericPropertyAccessor::wxGenericPropertyAccessorInternal
|
|
{
|
|
char filler;
|
|
};
|
|
|
|
wxGenericPropertyAccessor::wxGenericPropertyAccessor( const wxString& propertyName )
|
|
: wxPropertyAccessor( NULL, NULL, NULL, NULL )
|
|
{
|
|
m_data = new wxGenericPropertyAccessorInternal;
|
|
m_propertyName = propertyName;
|
|
m_getterName = wxT("Get")+propertyName;
|
|
m_setterName = wxT("Set")+propertyName;
|
|
}
|
|
|
|
wxGenericPropertyAccessor::~wxGenericPropertyAccessor()
|
|
{
|
|
delete m_data;
|
|
}
|
|
|
|
void wxGenericPropertyAccessor::SetProperty(wxObject *object, const wxAny &value) const
|
|
{
|
|
wxDynamicObject* dynobj = wx_dynamic_cast(wxDynamicObject*, object);
|
|
wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
|
|
dynobj->SetProperty(m_propertyName.c_str(), value );
|
|
}
|
|
|
|
void wxGenericPropertyAccessor::GetProperty(const wxObject *object, wxAny& value) const
|
|
{
|
|
const wxDynamicObject* dynobj = wx_dynamic_cast( const wxDynamicObject * , object );
|
|
wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
|
|
value = dynobj->GetProperty( m_propertyName.c_str() );
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxGenericPropertyAccessor
|
|
// ----------------------------------------------------------------------------
|
|
|
|
wxString wxAnyGetAsString( const wxAny& data)
|
|
{
|
|
if ( data.IsNull() || data.GetTypeInfo()==NULL )
|
|
return wxEmptyString;
|
|
|
|
wxString s;
|
|
data.GetTypeInfo()->ConvertToString(data,s);
|
|
return s;
|
|
}
|
|
|
|
const wxObject* wxAnyGetAsObjectPtr( const wxAny& data)
|
|
{
|
|
if ( !data.IsNull() )
|
|
{
|
|
const wxClassTypeInfo* ti = wx_dynamic_cast(const wxClassTypeInfo*, data.GetTypeInfo());
|
|
if( ti )
|
|
return ti->GetClassInfo()->AnyToObjectPtr(data);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
wxObjectFunctor::~wxObjectFunctor()
|
|
{};
|
|
|
|
#endif // wxUSE_EXTENDED_RTTI
|