no tabs please\!

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@22568 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/xti.h b/include/wx/xti.h
index 04187f55194eef10950b0b42567232c5caa4ac2e..b76f2c0ce03ed4e3f00e6e332a6c70cb6e653a20 100644 (file)
--- a/include/wx/xti.h
+++ b/include/wx/xti.h
@@ -66,58 +66,58 @@ typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
 
 struct WXDLLIMPEXP_BASE wxEnumMemberData
 {
 
 struct WXDLLIMPEXP_BASE wxEnumMemberData
 {

-    const wxChar*      m_name;
-    int                                m_value;
+    const wxChar*   m_name;
+    int             m_value;

 };
 
 class WXDLLIMPEXP_BASE wxEnumData
 {
 public :
 };
 
 class WXDLLIMPEXP_BASE wxEnumData
 {
 public :

-       wxEnumData( wxEnumMemberData* data ) ;
+    wxEnumData( wxEnumMemberData* data ) ;

 
 

-       // returns true if the member has been found and sets the int value
-       // pointed to accordingly (if ptr != null )
-       // if not found returns false, value left unchanged
-       bool HasEnumMemberValue( const wxChar *name , int *value = NULL ) ;
+    // returns true if the member has been found and sets the int value
+    // pointed to accordingly (if ptr != null )
+    // if not found returns false, value left unchanged
+    bool HasEnumMemberValue( const wxChar *name , int *value = NULL ) ;

 
 

-       // returns the value of the member, if not found in debug mode an
-       // assert is issued, in release 0 is returned
-       int GetEnumMemberValue(const wxChar *name );
+    // returns the value of the member, if not found in debug mode an
+    // assert is issued, in release 0 is returned
+    int GetEnumMemberValue(const wxChar *name );

 
 

-       // returns the name of the enum member having the passed in value
-       // returns an emtpy string if not found
+    // returns the name of the enum member having the passed in value
+    // returns an emtpy string if not found

     const wxChar *GetEnumMemberName(int value);
 
     const wxChar *GetEnumMemberName(int value);
 

-       // returns the number of members in this enum
-       int GetEnumCount() { return m_count ; }
+    // returns the number of members in this enum
+    int GetEnumCount() { return m_count ; }

 
 

-       // returns the value of the nth member
-       int GetEnumMemberValueByIndex( int n ) ;
+    // returns the value of the nth member
+    int GetEnumMemberValueByIndex( int n ) ;

 
 

-       // returns the value of the nth member
-       const wxChar *GetEnumMemberNameByIndex( int n ) ;
+    // returns the value of the nth member
+    const wxChar *GetEnumMemberNameByIndex( int n ) ;

 private :
     wxEnumMemberData *m_members;
 private :
     wxEnumMemberData *m_members;

-       int m_count ;
+    int m_count ;

 };
 
 #define WX_BEGIN_ENUM( e ) \
 };
 
 #define WX_BEGIN_ENUM( e ) \

-       wxEnumMemberData s_enumDataMembers##e[] = {
+    wxEnumMemberData s_enumDataMembers##e[] = {

 
 #define WX_ENUM_MEMBER( v ) { #v, v } ,
 
 #define WX_END_ENUM( e ) { NULL , 0 } } ; \
 
 #define WX_ENUM_MEMBER( v ) { #v, v } ,
 
 #define WX_END_ENUM( e ) { NULL , 0 } } ; \

-       wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
-       wxEnumData *wxGetEnumData(e) { return &s_enumData##e ; } \
-       template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxEnumTypeInfo s_typeInfo(wxT_ENUM , &s_enumData##e) ; return &s_typeInfo ; } \
-       template<> void wxStringReadValue(const wxString& s , e &data ) \
-       { \
-               data = (e) s_enumData##e.GetEnumMemberValue(s) ; \
-       } \
-       template<> void wxStringWriteValue(wxString &s , const e &data ) \
-       { \
-               s =  s_enumData##e.GetEnumMemberName((int)data) ; \
-       }
+    wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
+    wxEnumData *wxGetEnumData(e) { return &s_enumData##e ; } \
+    template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxEnumTypeInfo s_typeInfo(wxT_ENUM , &s_enumData##e) ; return &s_typeInfo ; } \
+    template<> void wxStringReadValue(const wxString& s , e &data ) \
+    { \
+        data = (e) s_enumData##e.GetEnumMemberValue(s) ; \
+    } \
+    template<> void wxStringWriteValue(wxString &s , const e &data ) \
+    { \
+        s =  s_enumData##e.GetEnumMemberName((int)data) ; \
+    }

 
 // ----------------------------------------------------------------------------
 // Set Support
 
 // ----------------------------------------------------------------------------
 // Set Support


@@ -126,9 +126,9 @@ private :
 //
 // enum wxFlavor
 // {
 //
 // enum wxFlavor
 // {

-//     Vanilla,
-//     Chocolate,
-//     Strawberry,
+//  Vanilla,
+//  Chocolate,
+//  Strawberry,

 // };
 //
 // typedef wxSet<wxFlavor> wxCoupe ;
 // };
 //
 // typedef wxSet<wxFlavor> wxCoupe ;


@@ -136,9 +136,9 @@ private :
 // in the implementation file :
 //
 // WX_BEGIN_ENUM( wxFlavor )
 // in the implementation file :
 //
 // WX_BEGIN_ENUM( wxFlavor )

-//     WX_ENUM_MEMBER( Vanilla )
-//     WX_ENUM_MEMBER( Chocolate )
-//     WX_ENUM_MEMBER( Strawberry )
+//  WX_ENUM_MEMBER( Vanilla )
+//  WX_ENUM_MEMBER( Chocolate )
+//  WX_ENUM_MEMBER( Strawberry )

 // WX_END_ENUM( wxFlavor )
 //
 // WX_IMPLEMENT_SET_STREAMING( wxCoupe , wxFlavor )
 // WX_END_ENUM( wxFlavor )
 //
 // WX_IMPLEMENT_SET_STREAMING( wxCoupe , wxFlavor )


@@ -154,55 +154,55 @@ void wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
 template<typename e>
 void wxSetFromString(const wxString &s , wxSet<e> &data )
 {
 template<typename e>
 void wxSetFromString(const wxString &s , wxSet<e> &data )
 {

-       wxEnumData* edata = wxGetEnumData((e) 0) ;
-       data.Clear() ;
+    wxEnumData* edata = wxGetEnumData((e) 0) ;
+    data.Clear() ;

 
 

-       wxArrayString array ;
-       wxSetStringToArray( s , array ) ;
+    wxArrayString array ;
+    wxSetStringToArray( s , array ) ;

     wxString flag;
     for ( int i = 0 ; i < array.Count() ; ++i )
     {
         flag = array[i] ;
     wxString flag;
     for ( int i = 0 ; i < array.Count() ; ++i )
     {
         flag = array[i] ;

-               int ivalue ;
-               if ( edata->HasEnumMemberValue( flag , &ivalue ) )
-               {
-                       data.Set( (e) ivalue ) ;
-               }
+        int ivalue ;
+        if ( edata->HasEnumMemberValue( flag , &ivalue ) )
+        {
+            data.Set( (e) ivalue ) ;
+        }

     }
 }
 
 template<typename e>
 void wxSetToString( wxString &s , const wxSet<e> &data )
 {
     }
 }
 
 template<typename e>
 void wxSetToString( wxString &s , const wxSet<e> &data )
 {

-       wxEnumData* edata = wxGetEnumData((e) 0) ;
-       int count = edata->GetEnumCount() ;
-       int i ;
-       s.Clear() ;
-       for ( i = 0 ; i < count ; i++ )
-       {
-               e value = (e) edata->GetEnumMemberValueByIndex(i) ;
-               if ( data.Contains( value ) )
-               {
-                       // this could also be done by the templated calls
-                       if ( !s.IsEmpty() )
-                               s +="|" ;
-                       s += edata->GetEnumMemberNameByIndex(i) ;
-               }
-       }
+    wxEnumData* edata = wxGetEnumData((e) 0) ;
+    int count = edata->GetEnumCount() ;
+    int i ;
+    s.Clear() ;
+    for ( i = 0 ; i < count ; i++ )
+    {
+        e value = (e) edata->GetEnumMemberValueByIndex(i) ;
+        if ( data.Contains( value ) )
+        {
+            // this could also be done by the templated calls
+            if ( !s.IsEmpty() )
+                s +="|" ;
+            s += edata->GetEnumMemberNameByIndex(i) ;
+        }
+    }

 }
 
 //  if the wxSet specialization above does not work for all compilers, add this to the WX_IMPLEMENT_SET_STREAMING macro
 }
 
 //  if the wxSet specialization above does not work for all compilers, add this to the WX_IMPLEMENT_SET_STREAMING macro

-//     template<> const wxTypeInfo* wxGetTypeInfo( SetName * ){ static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e) ; return &s_typeInfo ; }
+//  template<> const wxTypeInfo* wxGetTypeInfo( SetName * ){ static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e) ; return &s_typeInfo ; }

 
 #define WX_IMPLEMENT_SET_STREAMING(SetName,e) \
 
 #define WX_IMPLEMENT_SET_STREAMING(SetName,e) \

-       template<> void wxStringReadValue(const wxString &s , wxSet<e> &data ) \
-       { \
-               wxSetFromString( s , data ) ; \
-       } \
-       template<> void wxStringWriteValue( wxString &s , const wxSet<e> &data ) \
-       { \
-               wxSetToString( s , data ) ; \
-       } \
+    template<> void wxStringReadValue(const wxString &s , wxSet<e> &data ) \
+    { \
+        wxSetFromString( s , data ) ; \
+    } \
+    template<> void wxStringWriteValue( wxString &s , const wxSet<e> &data ) \
+    { \
+        wxSetToString( s , data ) ; \
+    } \

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


@@ -226,54 +226,54 @@ enum wxTypeKind
     wxT_ENUM,
     wxT_OBJECT, // must be a component (pointer !!!)
     wxT_CUSTOM, // user defined type (e.g. wxPoint)
     wxT_ENUM,
     wxT_OBJECT, // must be a component (pointer !!!)
     wxT_CUSTOM, // user defined type (e.g. wxPoint)

-       wxT_DELEGATE , // for connecting against an event source
+    wxT_DELEGATE , // for connecting against an event source

     wxT_LAST_TYPE_KIND // sentinel for bad data, asserts, debugging
 };
 
 class WXDLLIMPEXP_BASE wxTypeInfo
 {
 public :
     wxT_LAST_TYPE_KIND // sentinel for bad data, asserts, debugging
 };
 
 class WXDLLIMPEXP_BASE wxTypeInfo
 {
 public :

-       wxTypeInfo() : m_kind( wxT_VOID) {}
-       virtual ~wxTypeInfo() {}
-       wxTypeKind GetKind() const { return m_kind ; }
+    wxTypeInfo() : m_kind( wxT_VOID) {}
+    virtual ~wxTypeInfo() {}
+    wxTypeKind GetKind() const { return m_kind ; }

 protected :
 protected :

-       wxTypeKind m_kind ;
+    wxTypeKind m_kind ;

 };
 
 class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo
 {
 public :
 };
 
 class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo
 {
 public :

-       wxBuiltInTypeInfo( wxTypeKind kind ) { wxASSERT_MSG( kind < wxT_SET , wxT("Illegal Kind for Base Type") ) ; m_kind = kind ;}
+    wxBuiltInTypeInfo( wxTypeKind kind ) { wxASSERT_MSG( kind < wxT_SET , wxT("Illegal Kind for Base Type") ) ; m_kind = kind ;}

 } ;
 
 class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo
 {
 public :
 } ;
 
 class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo
 {
 public :

-       wxCustomTypeInfo( const wxChar *typeName )
-       { m_kind = wxT_CUSTOM ; m_typeName = typeName ;}
-       const wxChar *GetTypeName() const { return m_typeName ; }
+    wxCustomTypeInfo( const wxChar *typeName )
+    { m_kind = wxT_CUSTOM ; m_typeName = typeName ;}
+    const wxChar *GetTypeName() const { return m_typeName ; }

 private :
 private :

-       const wxChar *m_typeName; // Kind == wxT_CUSTOM
+    const wxChar *m_typeName; // Kind == wxT_CUSTOM

 } ;
 
 class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo
 {
 public :
 } ;
 
 class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo
 {
 public :

-       wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo )
-       { wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET , wxT("Illegal Kind for Enum Type")) ; m_kind = kind ; m_enumInfo = enumInfo ;}
-       const wxEnumData* GetEnumData() const { return m_enumInfo ; }
+    wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo )
+    { wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET , wxT("Illegal Kind for Enum Type")) ; m_kind = kind ; m_enumInfo = enumInfo ;}
+    const wxEnumData* GetEnumData() const { return m_enumInfo ; }

 private :
 private :

-       wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET
+    wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET

 } ;
 
 class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
 {
 public :
 } ;
 
 class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
 {
 public :

-       wxClassTypeInfo( wxClassInfo* classInfo )
-       { m_kind = wxT_OBJECT ; m_classInfo = classInfo ;}
-       const wxClassInfo *GetClassInfo() const { return m_classInfo ; }
+    wxClassTypeInfo( wxClassInfo* classInfo )
+    { m_kind = wxT_OBJECT ; m_classInfo = classInfo ;}
+    const wxClassInfo *GetClassInfo() const { return m_classInfo ; }

 private :
 private :

-       wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL
+    wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL

 } ;
 
 // a delegate is an exposed event source
 } ;
 
 // a delegate is an exposed event source


@@ -281,26 +281,26 @@ private :
 class WXDLLIMPEXP_BASE wxDelegateTypeInfo : public wxTypeInfo
 {
 public :
 class WXDLLIMPEXP_BASE wxDelegateTypeInfo : public wxTypeInfo
 {
 public :

-       wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass )
-       { m_kind = wxT_DELEGATE ; m_eventClass = eventClass ; m_eventType = eventType ;}
-       const wxClassInfo *GetEventClass() const { assert( m_kind == wxT_DELEGATE ) ; return m_eventClass ; }
-       int GetEventType() const { return m_eventType ; }
+    wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass )
+    { m_kind = wxT_DELEGATE ; m_eventClass = eventClass ; m_eventType = eventType ;}
+    const wxClassInfo *GetEventClass() const { assert( m_kind == wxT_DELEGATE ) ; return m_eventClass ; }
+    int GetEventType() const { return m_eventType ; }

 private :
 private :

-       const wxClassInfo *m_eventClass; // (extended will merge into classinfo)
-       int m_eventType ;
+    const wxClassInfo *m_eventClass; // (extended will merge into classinfo)
+    int m_eventType ;

 } ;
 
 template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) ;
 
 template<typename T> const wxTypeInfo* wxGetTypeInfo( wxSet<T> * )
 {
 } ;
 
 template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) ;
 
 template<typename T> const wxTypeInfo* wxGetTypeInfo( wxSet<T> * )
 {

-       static wxEnumTypeInfo s_typeInfo(wxT_SET , wxGetEnumData((T) 0) ) ; return &s_typeInfo ;
+    static wxEnumTypeInfo s_typeInfo(wxT_SET , wxGetEnumData((T) 0) ) ; return &s_typeInfo ;

 }
 
 // this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
 
 #define WX_CUSTOM_TYPE_INFO( e ) \
 }
 
 // this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
 
 #define WX_CUSTOM_TYPE_INFO( e ) \

-       template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxCustomTypeInfo s_typeInfo(#e) ; return &s_typeInfo ; } \
+    template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxCustomTypeInfo s_typeInfo(#e) ; return &s_typeInfo ; } \

 
 // ----------------------------------------------------------------------------
 // value streaming
 
 // ----------------------------------------------------------------------------
 // value streaming


@@ -329,15 +329,15 @@ void wxStringWriteValue( wxString &s , const T &data) ;
 template<typename T>
 void wxXmlReadValue( wxXmlNode *node , T &data )
 {
 template<typename T>
 void wxXmlReadValue( wxXmlNode *node , T &data )
 {

-       wxStringReadValue<T>( wxXmlGetContentFromNode( node ) , data ) ;
+    wxStringReadValue<T>( wxXmlGetContentFromNode( node ) , data ) ;

 }
 
 template<typename T>
 void wxXmlWriteValue( wxXmlNode *node , const T &data)
 {
 }
 
 template<typename T>
 void wxXmlWriteValue( wxXmlNode *node , const T &data)
 {

-       wxString s ;
-       wxStringWriteValue<T>( s, data ) ;
-       wxXmlAddContentToNode( node ,s ) ;
+    wxString s ;
+    wxStringWriteValue<T>( s, data ) ;
+    wxXmlAddContentToNode( node ,s ) ;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -347,56 +347,56 @@ void wxXmlWriteValue( wxXmlNode *node , const T &data)
 class WXDLLIMPEXP_BASE wxxVariantData
 {
 public:
 class WXDLLIMPEXP_BASE wxxVariantData
 {
 public:

-       virtual ~wxxVariantData() {}
+    virtual ~wxxVariantData() {}

 
 

-       // return a heap allocated duplicate
-       virtual wxxVariantData* Clone() const = 0 ;
+    // return a heap allocated duplicate
+    virtual wxxVariantData* Clone() const = 0 ;

 
 

-       // returns the type info of the contentc
-       virtual const wxTypeInfo* GetTypeInfo() const = 0 ;
+    // returns the type info of the contentc
+    virtual const wxTypeInfo* GetTypeInfo() const = 0 ;

 
 

-       // write the value into an xml node
-       virtual void Write( wxXmlNode* node ) const = 0 ;
+    // write the value into an xml node
+    virtual void Write( wxXmlNode* node ) const = 0 ;

 
 

-       // read the value from the xml node
-       virtual void Read( wxXmlNode* node ) = 0 ;
+    // read the value from the xml node
+    virtual void Read( wxXmlNode* node ) = 0 ;

 
 

-       // write the value into a string
-       virtual void Write( wxString &s ) const = 0 ;
+    // write the value into a string
+    virtual void Write( wxString &s ) const = 0 ;

 
 

-       // read the value from a string
-       virtual void Read( const wxString &s) = 0 ;
+    // read the value from a string
+    virtual void Read( const wxString &s) = 0 ;

 } ;
 
 template<typename T> class WXDLLIMPEXP_BASE wxxVariantDataT : public wxxVariantData
 {
 public:
     wxxVariantDataT(T d) : m_data(d) {}
 } ;
 
 template<typename T> class WXDLLIMPEXP_BASE wxxVariantDataT : public wxxVariantData
 {
 public:
     wxxVariantDataT(T d) : m_data(d) {}

-       virtual ~wxxVariantDataT() {}
+    virtual ~wxxVariantDataT() {}

 
 

-       // get a copy of the stored data
+    // get a copy of the stored data

     T Get() const { return m_data; }
 
     T Get() const { return m_data; }
 

-       // set the data
+    // set the data

     void Set(T d) { m_data =  d; }
 
     void Set(T d) { m_data =  d; }
 

-       // return a heap allocated duplicate
-       virtual wxxVariantData* Clone() const { return new wxxVariantDataT<T>( Get() ) ; }
+    // return a heap allocated duplicate
+    virtual wxxVariantData* Clone() const { return new wxxVariantDataT<T>( Get() ) ; }

 
 

-       // returns the type info of the contentc
-       virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ) ; }
+    // returns the type info of the contentc
+    virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ) ; }

 
 

-       // write the value into an xml node
-       virtual void Write( wxXmlNode* node ) const { wxXmlWriteValue( node , m_data ) ; }
+    // write the value into an xml node
+    virtual void Write( wxXmlNode* node ) const { wxXmlWriteValue( node , m_data ) ; }

 
 

-       // read the value from the xml node
-       virtual void Read( wxXmlNode* node ) { wxXmlReadValue( node , m_data ) ; }
+    // read the value from the xml node
+    virtual void Read( wxXmlNode* node ) { wxXmlReadValue( node , m_data ) ; }

 
 

-       // write the value into a string
-       virtual void Write( wxString &s ) const { wxStringWriteValue( s , m_data ) ; }
+    // write the value into a string
+    virtual void Write( wxString &s ) const { wxStringWriteValue( s , m_data ) ; }

 
 

-       // read the value from a string
-       virtual void Read( const wxString &s) { wxStringReadValue( s , m_data ) ; }
+    // read the value from a string
+    virtual void Read( const wxString &s) { wxStringReadValue( s , m_data ) ; }

 
 private:
     T m_data;
 
 private:
     T m_data;


@@ -405,66 +405,66 @@ private:
 class WXDLLIMPEXP_BASE wxxVariant
 {
 public :
 class WXDLLIMPEXP_BASE wxxVariant
 {
 public :

-       wxxVariant() { m_data = NULL ; }
-       wxxVariant( wxxVariantData* data , const wxString& name = wxT("") ) : m_data(data) , m_name(name) {}
-       wxxVariant( const wxxVariant &d ) { if ( d.m_data ) m_data = d.m_data->Clone() ; else m_data = NULL ; m_name = d.m_name ; }
-
-       template<typename T> wxxVariant( T data , const wxString& name = wxT("") ) :
-               m_data(new wxxVariantDataT<T>(data) ), m_name(name) {}
-       ~wxxVariant() { delete m_data ; }
-
-       // get a copy of the stored data
-       template<typename T> T Get() const
-       {
-               wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ;
-               wxASSERT_MSG( dataptr , "Cast not possible" ) ;
-               return dataptr->Get() ;
-       }
-
-       // stores the data
-       template<typename T> void Set(T data) const
-       {
-               delete m_data ;
-               m_data = new wxxVariantDataT<T>(data) ;
-       }
-
-       wxxVariant& operator=(const wxxVariant &d)
-       {
-               m_data = d.m_data->Clone() ;
-               m_name = d.m_name ;
-               return *this ;
-       }
-
-       // gets the stored data casted to a wxObject* , returning NULL if cast is not possible
-       wxObject* GetAsObject() const ;
-
-       // write the value into an xml node
-       void Write( wxXmlNode* node ) const { m_data->Write( node ) ; }
-
-       // read the value from the xml node
-       void Read( wxXmlNode* node ) { m_data->Read( node ) ; }
-
-       // write the value into a string
-       void Write( wxString &s ) const { m_data->Write( s ) ; }
-
-       // read the value from a string
-       void Read( const wxString &s) { m_data->Read( s ) ; }
-
-       // returns this value as string
-       wxString GetAsString() const
-       {
-               wxString s ;
-               Write( s ) ;
-               return s ;
-       }
-
-       void SetFromString( const wxString &s)
-       {
-               Read( s ) ;
-       }
+    wxxVariant() { m_data = NULL ; }
+    wxxVariant( wxxVariantData* data , const wxString& name = wxT("") ) : m_data(data) , m_name(name) {}
+    wxxVariant( const wxxVariant &d ) { if ( d.m_data ) m_data = d.m_data->Clone() ; else m_data = NULL ; m_name = d.m_name ; }
+
+    template<typename T> wxxVariant( T data , const wxString& name = wxT("") ) :
+        m_data(new wxxVariantDataT<T>(data) ), m_name(name) {}
+    ~wxxVariant() { delete m_data ; }
+
+    // get a copy of the stored data
+    template<typename T> T Get() const
+    {
+        wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ;
+        wxASSERT_MSG( dataptr , "Cast not possible" ) ;
+        return dataptr->Get() ;
+    }
+
+    // stores the data
+    template<typename T> void Set(T data) const
+    {
+        delete m_data ;
+        m_data = new wxxVariantDataT<T>(data) ;
+    }
+
+    wxxVariant& operator=(const wxxVariant &d)
+    {
+        m_data = d.m_data->Clone() ;
+        m_name = d.m_name ;
+        return *this ;
+    }
+
+    // gets the stored data casted to a wxObject* , returning NULL if cast is not possible
+    wxObject* GetAsObject() const ;
+
+    // write the value into an xml node
+    void Write( wxXmlNode* node ) const { m_data->Write( node ) ; }
+
+    // read the value from the xml node
+    void Read( wxXmlNode* node ) { m_data->Read( node ) ; }
+
+    // write the value into a string
+    void Write( wxString &s ) const { m_data->Write( s ) ; }
+
+    // read the value from a string
+    void Read( const wxString &s) { m_data->Read( s ) ; }
+
+    // returns this value as string
+    wxString GetAsString() const
+    {
+        wxString s ;
+        Write( s ) ;
+        return s ;
+    }
+
+    void SetFromString( const wxString &s)
+    {
+        Read( s ) ;
+    }

 private :
 private :

-       wxxVariantData* m_data ;
-       wxString m_name ;
+    wxxVariantData* m_data ;
+    wxString m_name ;

 } ;
 
 // ----------------------------------------------------------------------------
 } ;
 
 // ----------------------------------------------------------------------------


@@ -485,15 +485,15 @@ public :
     virtual wxxVariant GetProperty(wxObject *object) const = 0 ;
     virtual bool HasSetter() const = 0 ;
     virtual bool HasGetter() const = 0 ;
     virtual wxxVariant GetProperty(wxObject *object) const = 0 ;
     virtual bool HasSetter() const = 0 ;
     virtual bool HasGetter() const = 0 ;

-       const wxChar * GetGetterName() const { return m_setterName ; }
-       const wxChar * GetSetterName() const { return m_getterName ; }
-       virtual wxxVariant ReadValue( wxXmlNode* node ) const = 0 ;
-       virtual void WriteValue( wxXmlNode* node , wxObject *o ) const = 0 ;
-       virtual wxxVariant ReadValue( const wxString &value ) const = 0 ;
-       virtual void WriteValue( wxString& value , wxObject *o ) const = 0 ;
+    const wxChar * GetGetterName() const { return m_setterName ; }
+    const wxChar * GetSetterName() const { return m_getterName ; }
+    virtual wxxVariant ReadValue( wxXmlNode* node ) const = 0 ;
+    virtual void WriteValue( wxXmlNode* node , wxObject *o ) const = 0 ;
+    virtual wxxVariant ReadValue( const wxString &value ) const = 0 ;
+    virtual void WriteValue( wxString& value , wxObject *o ) const = 0 ;

 protected :
 protected :

-       const wxChar *m_setterName ;
-       const wxChar *m_getterName ;
+    const wxChar *m_setterName ;
+    const wxChar *m_getterName ;

 };
 
 template<typename T>
 };
 
 template<typename T>


@@ -519,13 +519,13 @@ public:
         : m_setter(NULL), m_setter_ref(NULL), m_getter(getter) ,m_getter_ref(NULL) {m_setterName = "";m_getterName=g ;}
 
     wxPropertyAccessorT(SetByRef*, setter_ref_t setter, getter_t getter, const wxChar *g, const wxChar *s)
         : m_setter(NULL), m_setter_ref(NULL), m_getter(getter) ,m_getter_ref(NULL) {m_setterName = "";m_getterName=g ;}
 
     wxPropertyAccessorT(SetByRef*, setter_ref_t setter, getter_t getter, const wxChar *g, const wxChar *s)

-       : m_setter(NULL), m_setter_ref(setter), m_getter(getter) , m_getter_ref(NULL){m_setterName = s;m_getterName=g ;}
+        : m_setter(NULL), m_setter_ref(setter), m_getter(getter) , m_getter_ref(NULL){m_setterName = s;m_getterName=g ;}

 
  //   wxPropertyAccessorT(setter_ref_t setter, getter_t getter, const wxChar *g, const wxChar *s)
  //       : m_setter(NULL), m_setter_ref(setter), m_getter(getter) , m_getter_ref(NULL){m_setterName = s;m_getterName=g ;}
 
     wxPropertyAccessorT(SetAndGetByRef*, setter_ref_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)
 
  //   wxPropertyAccessorT(setter_ref_t setter, getter_t getter, const wxChar *g, const wxChar *s)
  //       : m_setter(NULL), m_setter_ref(setter), m_getter(getter) , m_getter_ref(NULL){m_setterName = s;m_getterName=g ;}
 
     wxPropertyAccessorT(SetAndGetByRef*, setter_ref_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)

-       : m_setter(NULL), m_setter_ref(setter), m_getter(NULL) , m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
+        : m_setter(NULL), m_setter_ref(setter), m_getter(NULL) , m_getter_ref(getter){m_setterName = s;m_getterName=g ;}

 
  //   wxPropertyAccessorT(setter_ref_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)
  //       : m_setter(NULL), m_setter_ref(setter), m_getter(NULL) , m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
 
  //   wxPropertyAccessorT(setter_ref_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)
  //       : m_setter(NULL), m_setter_ref(setter), m_getter(NULL) , m_getter_ref(getter){m_setterName = s;m_getterName=g ;}


@@ -534,19 +534,19 @@ public:
  //       : m_setter(NULL), m_setter(setter), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
 
     wxPropertyAccessorT(GetByRef*, setter_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)
  //       : m_setter(NULL), m_setter(setter), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
 
     wxPropertyAccessorT(GetByRef*, setter_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)

-       : m_setter(NULL), m_setter(setter), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
+        : m_setter(NULL), m_setter(setter), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}

 
  //   wxPropertyAccessorT( getter_ref_t getter, const wxChar *g)
  //       : m_setter(NULL), m_setter(NULL), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = "";m_getterName=g ;}
 
 
  //   wxPropertyAccessorT( getter_ref_t getter, const wxChar *g)
  //       : m_setter(NULL), m_setter(NULL), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = "";m_getterName=g ;}
 

-       // returns true if this accessor has a setter
-       bool HasSetter() const { return m_setter != NULL || m_setter_ref != NULL ; }
+    // returns true if this accessor has a setter
+    bool HasSetter() const { return m_setter != NULL || m_setter_ref != NULL ; }

 
 

-       // return true if this accessor has a getter
-       bool HasGetter() const { return m_getter != NULL || m_getter_ref != NULL ; }
+    // return true if this accessor has a getter
+    bool HasGetter() const { return m_getter != NULL || m_getter_ref != NULL ; }

 
 

-       // set the property this accessor is responsible for in an object
-       void SetProperty(wxObject *o, const wxxVariant &v) const
+    // set the property this accessor is responsible for in an object
+    void SetProperty(wxObject *o, const wxxVariant &v) const

     {
         Klass *obj = dynamic_cast<Klass*>(o);
         T value = v.Get<T>();
     {
         Klass *obj = dynamic_cast<Klass*>(o);
         T value = v.Get<T>();


@@ -556,131 +556,131 @@ public:
             (obj->*(m_setter_ref))(value);
     }
 
             (obj->*(m_setter_ref))(value);
     }
 

-       // gets the property this accessor is responsible for from an object
+    // gets the property this accessor is responsible for from an object

     wxxVariant GetProperty(wxObject *o) const
     {
     wxxVariant GetProperty(wxObject *o) const
     {

-               return wxxVariant( (wxxVariantData* ) DoGetProperty( o ) ) ;
+        return wxxVariant( (wxxVariantData* ) DoGetProperty( o ) ) ;

      }
 
      }
 

-       // write the property this accessor is responsible for from an object into
-       // a xml node
-       void WriteValue( wxXmlNode* node , wxObject *o ) const
-       {
-               DoGetProperty( o )->Write( node ) ;
-       }
-
-       // write the property this accessor is responsible for from an object into
-       // a string
-       void WriteValue( wxString& s , wxObject *o ) const
-       {
-               DoGetProperty( o )->Write( s ) ;
-       }
-
-       // read a wxxVariant having the correct type for the property this accessor
-       // is responsible for from an xml node
-       wxxVariant ReadValue( wxXmlNode* node ) const
-       {
-               T data ;
-               wxXmlReadValue( node , data ) ;
-               return wxxVariant( data ) ;
-       }
-
-       // read a wxxVariant having the correct type for the property this accessor
-       // is responsible for from a string
-       wxxVariant ReadValue( const wxString &value ) const
-       {
-               T data ;
-               wxStringReadValue( value , data ) ;
-               return wxxVariant( data ) ;
-       }
+    // write the property this accessor is responsible for from an object into
+    // a xml node
+    void WriteValue( wxXmlNode* node , wxObject *o ) const
+    {
+        DoGetProperty( o )->Write( node ) ;
+    }
+
+    // write the property this accessor is responsible for from an object into
+    // a string
+    void WriteValue( wxString& s , wxObject *o ) const
+    {
+        DoGetProperty( o )->Write( s ) ;
+    }
+
+    // read a wxxVariant having the correct type for the property this accessor
+    // is responsible for from an xml node
+    wxxVariant ReadValue( wxXmlNode* node ) const
+    {
+        T data ;
+        wxXmlReadValue( node , data ) ;
+        return wxxVariant( data ) ;
+    }
+
+    // read a wxxVariant having the correct type for the property this accessor
+    // is responsible for from a string
+    wxxVariant ReadValue( const wxString &value ) const
+    {
+        T data ;
+        wxStringReadValue( value , data ) ;
+        return wxxVariant( data ) ;
+    }

 
 private :
     wxxVariantDataT<T>* DoGetProperty(wxObject *o) const
     {
         Klass *obj = dynamic_cast<Klass*>(o);
 
 private :
     wxxVariantDataT<T>* DoGetProperty(wxObject *o) const
     {
         Klass *obj = dynamic_cast<Klass*>(o);

-               if ( m_getter )
-                       return new wxxVariantDataT<T>( (obj->*(m_getter))() ) ;
-               else
-                       return new wxxVariantDataT<T>( (obj->*(m_getter_ref))() ) ;
+        if ( m_getter )
+            return new wxxVariantDataT<T>( (obj->*(m_getter))() ) ;
+        else
+            return new wxxVariantDataT<T>( (obj->*(m_getter_ref))() ) ;

     }
 
     setter_t m_setter;
     setter_ref_t m_setter_ref;
     getter_t m_getter;
     }
 
     setter_t m_setter;
     setter_ref_t m_setter_ref;
     getter_t m_getter;

-       getter_ref_t m_getter_ref ;
+    getter_ref_t m_getter_ref ;

 };
 
 class WXDLLIMPEXP_BASE wxPropertyInfo
 {
 public :
 };
 
 class WXDLLIMPEXP_BASE wxPropertyInfo
 {
 public :

-       wxPropertyInfo( wxPropertyInfo* &iter , const wxChar *name , const wxChar *typeName , const wxTypeInfo* typeInfo , wxPropertyAccessor *accessor , wxxVariant dv ) :
-          m_name( name ) , m_typeName(typeName) , m_typeInfo( typeInfo ) , m_accessor( accessor ) , m_defaultValue( dv )
-       {
-               m_next = NULL ;
-               if ( iter == NULL )
-                       iter = this ;
-               else
-               {
-                       wxPropertyInfo* i = iter ;
-                       while( i->m_next )
-                               i = i->m_next ;
-
-                       i->m_next = this ;
-               }
-       }
-       // return the name of this property
-       const wxChar *          GetName() const { return m_name ; }
-
-       // return the typename of this property
-       const wxChar *          GetTypeName() const { return m_typeName ; }
-
-       // return the type info of this property
-       const wxTypeInfo *      GetTypeInfo() const { return m_typeInfo ; }
-
-       // return the accessor for this property
-       wxPropertyAccessor* GetAccessor() const { return m_accessor ; }
-
-       // returns NULL if this is the last property of this class
-       wxPropertyInfo*     GetNext() const { return m_next ; }
-
-       // returns the default value of this property, its kind may be wxT_VOID if it is not valid
-       wxxVariant                      GetDefaultValue() const { return m_defaultValue ; }
+    wxPropertyInfo( wxPropertyInfo* &iter , const wxChar *name , const wxChar *typeName , const wxTypeInfo* typeInfo , wxPropertyAccessor *accessor , wxxVariant dv ) :
+       m_name( name ) , m_typeName(typeName) , m_typeInfo( typeInfo ) , m_accessor( accessor ) , m_defaultValue( dv )
+    {
+        m_next = NULL ;
+        if ( iter == NULL )
+            iter = this ;
+        else
+        {
+            wxPropertyInfo* i = iter ;
+            while( i->m_next )
+                i = i->m_next ;
+
+            i->m_next = this ;
+        }
+    }
+    // return the name of this property
+    const wxChar *      GetName() const { return m_name ; }
+
+    // return the typename of this property
+    const wxChar *      GetTypeName() const { return m_typeName ; }
+
+    // return the type info of this property
+    const wxTypeInfo *  GetTypeInfo() const { return m_typeInfo ; }
+
+    // return the accessor for this property
+    wxPropertyAccessor* GetAccessor() const { return m_accessor ; }
+
+    // returns NULL if this is the last property of this class
+    wxPropertyInfo*     GetNext() const { return m_next ; }
+
+    // returns the default value of this property, its kind may be wxT_VOID if it is not valid
+    wxxVariant          GetDefaultValue() const { return m_defaultValue ; }

 private :
 private :

-       const wxChar *          m_name;
-       const wxChar *          m_typeName ;
-       const wxTypeInfo*       m_typeInfo ;
-       wxPropertyAccessor* m_accessor ;
+    const wxChar *      m_name;
+    const wxChar *      m_typeName ;
+    const wxTypeInfo*   m_typeInfo ;
+    wxPropertyAccessor* m_accessor ;

     wxxVariant m_defaultValue;
     wxxVariant m_defaultValue;

-       // string representation of the default value
-       //  to be assigned by the designer to the property
-       //  when the component is dropped on the container.
-       wxPropertyInfo*         m_next ;
+    // string representation of the default value
+    //  to be assigned by the designer to the property
+    //  when the component is dropped on the container.
+    wxPropertyInfo*     m_next ;

 };
 
 #define WX_BEGIN_PROPERTIES_TABLE(theClass) \
     const wxPropertyInfo *theClass::GetPropertiesStatic()  \
     {  \
         typedef theClass class_t; \
 };
 
 #define WX_BEGIN_PROPERTIES_TABLE(theClass) \
     const wxPropertyInfo *theClass::GetPropertiesStatic()  \
     {  \
         typedef theClass class_t; \

-               static wxPropertyInfo* first = NULL ;
+        static wxPropertyInfo* first = NULL ;

 
 #define WX_END_PROPERTIES_TABLE() \
 
 #define WX_END_PROPERTIES_TABLE() \

-               return first ; }
+        return first ; }

 
 #define WX_PROPERTY( name , type , setter , getter ,defaultValue ) \
 
 #define WX_PROPERTY( name , type , setter , getter ,defaultValue ) \

-       static wxPropertyAccessorT<class_t , type> _accessor##name( &setter , &getter , #setter , #getter ) ; \
-       static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
+    static wxPropertyAccessorT<class_t , type> _accessor##name( &setter , &getter , #setter , #getter ) ; \
+    static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;

 
 #define WX_PROPERTY_SET_BY_REF( name , type , setter , getter ,defaultValue ) \
         static wxPropertyAccessorT<class_t , type> _accessor##name( (wxPropertyAccessor::SetByRef*)NULL, &setter , &getter , #setter , #getter ) ; \
         static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
 
 #define WX_READONLY_PROPERTY( name , type , getter ,defaultValue ) \
 
 #define WX_PROPERTY_SET_BY_REF( name , type , setter , getter ,defaultValue ) \
         static wxPropertyAccessorT<class_t , type> _accessor##name( (wxPropertyAccessor::SetByRef*)NULL, &setter , &getter , #setter , #getter ) ; \
         static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
 
 #define WX_READONLY_PROPERTY( name , type , getter ,defaultValue ) \

-       static wxPropertyAccessorT<class_t , type> _accessor##name( &getter , #getter ) ; \
-       static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
+    static wxPropertyAccessorT<class_t , type> _accessor##name( &getter , #getter ) ; \
+    static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;

 
 #define WX_DELEGATE( name , eventType , eventClass ) \
 
 #define WX_DELEGATE( name , eventType , eventClass ) \

-       static wxDelegateTypeInfo _typeInfo##name( eventType , CLASSINFO( eventClass ) ) ; \
-       static wxPropertyInfo _propertyInfo##name( first , #name , NULL , &_typeInfo##name , NULL , wxxVariant() ) ; \
+    static wxDelegateTypeInfo _typeInfo##name( eventType , CLASSINFO( eventClass ) ) ; \
+    static wxPropertyInfo _propertyInfo##name( first , #name , NULL , &_typeInfo##name , NULL , wxxVariant() ) ; \

 
 // ----------------------------------------------------------------------------
 // Handler Info
 
 // ----------------------------------------------------------------------------
 // Handler Info


@@ -691,51 +691,51 @@ private :
 class wxHandlerInfo
 {
 public :
 class wxHandlerInfo
 {
 public :

-       wxHandlerInfo( wxHandlerInfo* &iter , const wxChar *name , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) :
-          m_eventFunction( address ) , m_name( name ) , m_eventClassInfo( eventClassInfo )
-       {
-               m_next = NULL ;
-               if ( iter == NULL )
-                       iter = this ;
-               else
-               {
-                       wxHandlerInfo* i = iter ;
-                       while( i->m_next )
-                               i = i->m_next ;
-
-                       i->m_next = this ;
-               }
-       }
-
-       // get the name of the handler method
-       const wxChar *          GetName() const { return m_name ; }
-
-       // return the class info of the event
-       const wxClassInfo *     GetEventClassInfo() const { return m_eventClassInfo ; }
-
-       // get the handler function pointer
-       wxObjectEventFunction   GetEventFunction() const { return m_eventFunction ; }
-
-       // returns NULL if this is the last handler of this class
-       wxHandlerInfo*     GetNext() const { return m_next ; }
+    wxHandlerInfo( wxHandlerInfo* &iter , const wxChar *name , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) :
+       m_eventFunction( address ) , m_name( name ) , m_eventClassInfo( eventClassInfo )
+    {
+        m_next = NULL ;
+        if ( iter == NULL )
+            iter = this ;
+        else
+        {
+            wxHandlerInfo* i = iter ;
+            while( i->m_next )
+                i = i->m_next ;
+
+            i->m_next = this ;
+        }
+    }
+
+    // get the name of the handler method
+    const wxChar *      GetName() const { return m_name ; }
+
+    // return the class info of the event
+    const wxClassInfo * GetEventClassInfo() const { return m_eventClassInfo ; }
+
+    // get the handler function pointer
+    wxObjectEventFunction   GetEventFunction() const { return m_eventFunction ; }
+
+    // returns NULL if this is the last handler of this class
+    wxHandlerInfo*     GetNext() const { return m_next ; }

 private :
 private :

-       wxObjectEventFunction m_eventFunction ;
-       const wxChar *          m_name;
-       const wxClassInfo*      m_eventClassInfo ;
-       wxHandlerInfo*          m_next ;
+    wxObjectEventFunction m_eventFunction ;
+    const wxChar *      m_name;
+    const wxClassInfo*  m_eventClassInfo ;
+    wxHandlerInfo*      m_next ;

 };
 
 #define WX_HANDLER(name,eventClassType) \
 };
 
 #define WX_HANDLER(name,eventClassType) \

-       static wxHandlerInfo _handlerInfo##name( first , #name , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;
+    static wxHandlerInfo _handlerInfo##name( first , #name , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;

 
 #define WX_BEGIN_HANDLERS_TABLE(theClass) \
     const wxHandlerInfo *theClass::GetHandlersStatic()  \
     {  \
         typedef theClass class_t; \
 
 #define WX_BEGIN_HANDLERS_TABLE(theClass) \
     const wxHandlerInfo *theClass::GetHandlersStatic()  \
     {  \
         typedef theClass class_t; \

-               static wxHandlerInfo* first = NULL ;
+        static wxHandlerInfo* first = NULL ;

 
 #define WX_END_HANDLERS_TABLE() \
 
 #define WX_END_HANDLERS_TABLE() \

-               return first ; }
+        return first ; }

 
 // ----------------------------------------------------------------------------
 // Constructor Bridges
 
 // ----------------------------------------------------------------------------
 // Constructor Bridges


@@ -771,16 +771,16 @@ struct wxConstructorBridge_Dummy : public wxConstructorBridge
 } ;
 
 #define WX_CONSTRUCTOR_0(klass) \
 } ;
 
 #define WX_CONSTRUCTOR_0(klass) \

-       wxConstructorBridge_0<klass> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 0 ;
+    wxConstructorBridge_0<klass> constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 0 ;

 
 #define WX_CONSTRUCTOR_DUMMY(klass) \
 
 #define WX_CONSTRUCTOR_DUMMY(klass) \

-       wxConstructorBridge_Dummy constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 0 ;
+    wxConstructorBridge_Dummy constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 0 ;

 
 // 1 param
 
 
 // 1 param
 


@@ -797,10 +797,10 @@ struct wxConstructorBridge_1 : public wxConstructorBridge
 };
 
 #define WX_CONSTRUCTOR_1(klass,t0,v0) \
 };
 
 #define WX_CONSTRUCTOR_1(klass,t0,v0) \

-       wxConstructorBridge_1<klass,t0> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 1 ;
+    wxConstructorBridge_1<klass,t0> constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { #v0 } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 1 ;

 
 // 2 params
 
 
 // 2 params
 


@@ -819,10 +819,10 @@ struct wxConstructorBridge_2 : public wxConstructorBridge
 };
 
 #define WX_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
 };
 
 #define WX_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \

-       wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 2;
+    wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 2;

 
 // 3 params
 
 
 // 3 params
 


@@ -842,10 +842,10 @@ struct wxConstructorBridge_3 : public wxConstructorBridge
 };
 
 #define WX_CONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
 };
 
 #define WX_CONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \

-       wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 3 ;
+    wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 3 ;

 
 // 4 params
 
 
 // 4 params
 


@@ -866,10 +866,10 @@ struct wxConstructorBridge_4 : public wxConstructorBridge
 };
 
 #define WX_CONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \
 };
 
 #define WX_CONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \

-       wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 4 ;
+    wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 4 ;

 
 // 5 params
 
 
 // 5 params
 


@@ -891,10 +891,10 @@ struct wxConstructorBridge_5 : public wxConstructorBridge
 };
 
 #define WX_CONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
 };
 
 #define WX_CONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \

-       wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 , #v4 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 5;
+    wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
+    wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
+    const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 , #v4 } ; \
+    const int klass::sm_constructorPropertiesCount##klass = 5;

 
 // ----------------------------------------------------------------------------
 // wxClassInfo
 
 // ----------------------------------------------------------------------------
 // wxClassInfo


@@ -908,30 +908,30 @@ class WXDLLIMPEXP_BASE wxClassInfo
 {
 public:
     wxClassInfo(const wxClassInfo **_Parents,
 {
 public:
     wxClassInfo(const wxClassInfo **_Parents,

-                       const wxChar *_UnitName,
-                       const wxChar *_ClassName,
+            const wxChar *_UnitName,
+            const wxChar *_ClassName,

             int size,
             wxObjectConstructorFn ctor ,
             int size,
             wxObjectConstructorFn ctor ,

-                       const wxPropertyInfo *_Props ,
-                       const wxHandlerInfo *_Handlers ,
-                       wxConstructorBridge* _Constructor ,
-                       const wxChar ** _ConstructorProperties ,
-                       const int _ConstructorPropertiesCount ,
-                       wxVariantToObjectConverter _Converter1 ,
-                       wxObjectToVariantConverter _Converter2
-                       ) : m_className(_ClassName), m_objectSize(size),
+            const wxPropertyInfo *_Props ,
+            const wxHandlerInfo *_Handlers ,
+            wxConstructorBridge* _Constructor ,
+            const wxChar ** _ConstructorProperties ,
+            const int _ConstructorPropertiesCount ,
+            wxVariantToObjectConverter _Converter1 ,
+            wxObjectToVariantConverter _Converter2
+            ) : m_className(_ClassName), m_objectSize(size),

                             m_objectConstructor(ctor), m_next(sm_first),
                             m_parents(_Parents), m_firstProperty(_Props ),
                             m_firstHandler(_Handlers), m_unitName(_UnitName),
                             m_objectConstructor(ctor), m_next(sm_first),
                             m_parents(_Parents), m_firstProperty(_Props ),
                             m_firstHandler(_Handlers), m_unitName(_UnitName),

-                           m_constructor( _Constructor ),
-                           m_constructorProperties(_ConstructorProperties),
+                m_constructor( _Constructor ),
+                m_constructorProperties(_ConstructorProperties),

                             m_constructorPropertiesCount(_ConstructorPropertiesCount),
                             m_variantToObjectConverter( _Converter1 ),
                             m_objectToVariantConverter( _Converter2 ) 
                             m_constructorPropertiesCount(_ConstructorPropertiesCount),
                             m_variantToObjectConverter( _Converter1 ),
                             m_objectToVariantConverter( _Converter2 ) 

-       {
-               sm_first = this;
-               Register( m_className , this ) ;
-       }
+    {
+        sm_first = this;
+        Register( m_className , this ) ;
+    }

 
     virtual ~wxClassInfo() ;
 
 
     virtual ~wxClassInfo() ;
 


@@ -951,23 +951,23 @@ public:
 
     bool IsKindOf(const wxClassInfo *info) const
     {
 
     bool 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 ;
+        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 ;

     }
 
     // Initializes parent pointers and hash table for fast searching.
     }
 
     // Initializes parent pointers and hash table for fast searching.

-       // this is going to be removed by Register/Unregister calls
-       // in Constructor / Destructor together with making the hash map private
+    // this is going to be removed by Register/Unregister calls
+    // in Constructor / Destructor together with making the hash map private

 
     static void     InitializeClasses();
 
 
     static void     InitializeClasses();
 


@@ -975,37 +975,37 @@ public:
 
     static void     CleanUpClasses();
 
 
     static void     CleanUpClasses();
 

-       // returns the first property
-       const wxPropertyInfo* GetFirstProperty() const { return m_firstProperty ; }
+    // returns the first property
+    const wxPropertyInfo* GetFirstProperty() const { return m_firstProperty ; }

 
 

-       // returns the first handler
-       const wxHandlerInfo* GetFirstHandler() const { return m_firstHandler ; }
+    // returns the first handler
+    const wxHandlerInfo* GetFirstHandler() const { return m_firstHandler ; }

 
     // Call the Create method for a class
     virtual void Create (wxObject *object, int ParamCount, wxxVariant *Params)
 
     // Call the Create method for a class
     virtual void Create (wxObject *object, int ParamCount, wxxVariant *Params)

-       {
-               wxASSERT_MSG( ParamCount == m_constructorPropertiesCount , wxT("Illegal Parameter Count for Create Method")) ;
-               m_constructor->Create( object , Params ) ;
-       }
+    {
+        wxASSERT_MSG( ParamCount == m_constructorPropertiesCount , wxT("Illegal Parameter Count for Create Method")) ;
+        m_constructor->Create( object , Params ) ;
+    }

 
 

-       // get number of parameters for constructor
-       virtual int GetCreateParamCount() const { return m_constructorPropertiesCount; }
+    // get number of parameters for constructor
+    virtual int GetCreateParamCount() const { return m_constructorPropertiesCount; }

 
 

-       // get i-th constructor parameter
-       virtual const wxChar* GetCreateParamName(int i) const { return m_constructorProperties[i] ; }
+    // get i-th constructor parameter
+    virtual const wxChar* GetCreateParamName(int i) const { return m_constructorProperties[i] ; }

 
    // Runtime access to objects by property name, and variant data
     virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value);
     virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName);
 
 
    // Runtime access to objects by property name, and variant data
     virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value);
     virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName);
 

-       // we must be able to cast variants to wxObject pointers, templates seem not to be suitable
-       wxObject* VariantToInstance( const wxxVariant &data ) const { return m_variantToObjectConverter( data ) ; }
-       wxxVariant InstanceToVariant( wxObject *object ) const { return m_objectToVariantConverter( object ) ; }
+    // we must be able to cast variants to wxObject pointers, templates seem not to be suitable
+    wxObject* VariantToInstance( const wxxVariant &data ) const { return m_variantToObjectConverter( data ) ; }
+    wxxVariant InstanceToVariant( wxObject *object ) const { return m_objectToVariantConverter( object ) ; }

 
 

-       // find property by name
+    // find property by name

     virtual const wxPropertyInfo *FindPropertyInfo (const wxChar *PropertyName) const ;
 
     virtual const wxPropertyInfo *FindPropertyInfo (const wxChar *PropertyName) const ;
 

-       // find handler by name
+    // find handler by name

     virtual const wxHandlerInfo *FindHandlerInfo (const wxChar *PropertyName) const ;
 
 public:
     virtual const wxHandlerInfo *FindHandlerInfo (const wxChar *PropertyName) const ;
 
 public:


@@ -1019,30 +1019,30 @@ public:
     static wxClassInfo      *sm_first;
     wxClassInfo             *m_next;
 
     static wxClassInfo      *sm_first;
     wxClassInfo             *m_next;
 

-       // FIXME: this should be private (currently used directly by way too
+    // FIXME: this should be private (currently used directly by way too

     //        many clients)
     static wxHashTable      *sm_classTable;
 
 private:
     //        many clients)
     static wxHashTable      *sm_classTable;
 
 private:

-       const wxClassInfo**             m_parents ;
-       const wxPropertyInfo *  m_firstProperty ;
-       const wxHandlerInfo *   m_firstHandler ;
-    const wxChar*                      m_unitName;
+    const wxClassInfo**     m_parents ;
+    const wxPropertyInfo *  m_firstProperty ;
+    const wxHandlerInfo *   m_firstHandler ;
+    const wxChar*           m_unitName;

 
 

-       wxConstructorBridge*    m_constructor ;
-       const wxChar **                 m_constructorProperties ;
-       const int                               m_constructorPropertiesCount ;
-       wxVariantToObjectConverter m_variantToObjectConverter ;
-       wxObjectToVariantConverter m_objectToVariantConverter ;
+    wxConstructorBridge*    m_constructor ;
+    const wxChar **         m_constructorProperties ;
+    const int               m_constructorPropertiesCount ;
+    wxVariantToObjectConverter m_variantToObjectConverter ;
+    wxObjectToVariantConverter m_objectToVariantConverter ;

 
     const wxPropertyAccessor *FindAccessor (const wxChar *propertyName);
 
 
     const wxPropertyAccessor *FindAccessor (const wxChar *propertyName);
 

-       // registers the class
-       static void Register(const wxChar *name, wxClassInfo *info);
+    // registers the class
+    static void Register(const wxChar *name, wxClassInfo *info);

 
 

-       static void Unregister(const wxChar *name);
+    static void Unregister(const wxChar *name);

 
 

-       // InitializeClasses() helper
+    // InitializeClasses() helper

     static wxClassInfo *GetBaseByName(const wxChar *name);
 
     DECLARE_NO_COPY_CLASS(wxClassInfo)
     static wxClassInfo *GetBaseByName(const wxChar *name);
 
     DECLARE_NO_COPY_CLASS(wxClassInfo)


@@ -1064,10 +1064,10 @@ WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
    { return &name::sm_class##name; }
 
 #define DECLARE_DYNAMIC_CLASS(name)           \
    { return &name::sm_class##name; }
 
 #define DECLARE_DYNAMIC_CLASS(name)           \

-       _DECLARE_DYNAMIC_CLASS(name) \
-       static wxConstructorBridge* sm_constructor##name ; \
-       static const wxChar * sm_constructorProperties##name[] ; \
-       static const int sm_constructorPropertiesCount##name ;
+    _DECLARE_DYNAMIC_CLASS(name) \
+    static wxConstructorBridge* sm_constructor##name ; \
+    static const wxChar * sm_constructorProperties##name[] ; \
+    static const int sm_constructorPropertiesCount##name ;

 
 #define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name)   \
     DECLARE_NO_ASSIGN_CLASS(name)               \
 
 #define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name)   \
     DECLARE_NO_ASSIGN_CLASS(name)               \


@@ -1095,8 +1095,8 @@ WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) wxConstructorFor##name   ,   \
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) wxConstructorFor##name   ,   \

-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name ,     \
-                       name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \
+            name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name ,     \
+            name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \

  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") ) ;}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") ) ;}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }


@@ -1117,8 +1117,8 @@ _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit )
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) 0   ,   \
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) 0   ,   \

-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
-                       0 , 0 , 0 );    \
+            name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
+            0 , 0 , 0 );    \

  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }


@@ -1130,8 +1130,8 @@ _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit )
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) 0   ,   \
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) 0   ,   \

-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
-                       0 , 0 , 0 );    \
+            name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
+            0 , 0 , 0 );    \

  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }


@@ -1147,8 +1147,8 @@ _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit )
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) wxConstructorFor##name   ,   \
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) wxConstructorFor##name   ,   \

-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name ,     \
-                       name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \
+            name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name ,     \
+            name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \

  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }


@@ -1160,7 +1160,7 @@ const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ;
 WX_CONSTRUCTOR_DUMMY( name )
 
 #define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
 WX_CONSTRUCTOR_DUMMY( name )
 
 #define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \

-       _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit)
+    _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit)

 
 // -----------------------------------
 // for abstract classes
 
 // -----------------------------------
 // for abstract classes


@@ -1175,8 +1175,8 @@ WX_CONSTRUCTOR_DUMMY( name )
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) 0   ,   \
  wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
             (int) sizeof(name),                              \
             (wxObjectConstructorFn) 0   ,   \

-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
-                       0 , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \
+            name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
+            0 , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \

  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
  template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
  template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }