wx/tokenzr.h \
wx/tracker.h \
wx/txtstrm.h \
+ wx/typeinfo.h \
wx/types.h \
wx/unichar.h \
wx/uri.h \
wx/tokenzr.h \
wx/tracker.h \
wx/txtstrm.h \
+ wx/typeinfo.h \
wx/types.h \
wx/unichar.h \
wx/uri.h \
wx/tokenzr.h
wx/tracker.h
wx/txtstrm.h
+ wx/typeinfo.h
wx/types.h
wx/unichar.h
wx/uri.h
# End Source File\r
# Begin Source File\r
\r
+SOURCE=..\..\include\wx\typeinfo.h\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=..\..\include\wx\types.h\r
# End Source File\r
# Begin Source File\r
<File\r
RelativePath="..\..\include\wx\txtstrm.h">\r
</File>\r
+ <File\r
+ RelativePath="..\..\include\wx\typeinfo.h">\r
+ </File>\r
<File\r
RelativePath="..\..\include\wx\types.h">\r
</File>\r
RelativePath="..\..\include\wx\txtstrm.h"\r
>\r
</File>\r
+ <File\r
+ RelativePath="..\..\include\wx\typeinfo.h"\r
+ >\r
+ </File>\r
<File\r
RelativePath="..\..\include\wx\types.h"\r
>\r
RelativePath="..\..\include\wx\txtstrm.h"\r
>\r
</File>\r
+ <File\r
+ RelativePath="..\..\include\wx\typeinfo.h"\r
+ >\r
+ </File>\r
<File\r
RelativePath="..\..\include\wx\types.h"\r
>\r
#include "wx/string.h"
#include "wx/meta/movable.h"
#include "wx/meta/if.h"
+#include "wx/typeinfo.h"
// Size of the wxAny value buffer.
wxByte m_buffer[WX_ANY_VALUE_BUFFER_SIZE];
};
-typedef void (*wxAnyClassInfo)();
-
-
//
// wxAnyValueType is base class for value type functionality for C++ data
// types used with wxAny. Usually the default template (wxAnyValueTypeImpl<>)
//
class WXDLLIMPEXP_BASE wxAnyValueType
{
+ WX_DECLARE_ABSTRACT_TYPEINFO(wxAnyValueType)
public:
/**
Default constructor.
{
}
- /**
- This function is used for internal type matching.
- */
- virtual wxAnyClassInfo GetClassInfo() const = 0;
-
/**
This function is used for internal type matching.
*/
#define wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) \
wxAnyValueTypeImpl<T>::IsSameClass(valueTypePtr)
- //valueTypePtr->CheckType(static_cast<T*>(NULL))
-
/**
Helper macro for defining user value types.
- NB: We really cannot compare sm_classInfo directly in IsSameClass(),
- but instead call sm_instance->GetClassInfo(). The former technique
- broke at least on GCC 4.2 (but worked on VC8 shared build).
+ Even though C++ RTTI would be fully available to use, we'd have to to
+ facilitate sub-type system which allows, for instance, wxAny with
+ signed short '15' to be treated equal to wxAny with signed long long '15'.
+ Having sm_instance is important here.
*/
#define WX_DECLARE_ANY_VALUE_TYPE(CLS) \
friend class wxAny; \
+ WX_DECLARE_TYPEINFO_INLINE(CLS) \
public: \
- static void sm_classInfo() {} \
- \
- virtual wxAnyClassInfo GetClassInfo() const \
- { \
- return sm_classInfo; \
- } \
static bool IsSameClass(const wxAnyValueType* otherType) \
{ \
- return sm_instance->GetClassInfo() == otherType->GetClassInfo(); \
+ return wxTypeId(*sm_instance) == wxTypeId(*otherType); \
} \
virtual bool IsSameType(const wxAnyValueType* otherType) const \
{ \
#ifdef wxHAS_EVENT_BIND
+#include "wx/typeinfo.h"
+
// The tag is a type associated to the event type (which is an integer itself,
// in spite of its name) value. It exists in order to be used as a template
// parameter and provide a mapping between the event type values and their
// compiler we can restore its old definition for it.
typedef wxEventFunction wxObjectEventFunction;
-
-// wxEventFunctorClassInfo is used as a unique identifier for wxEventFunctor-
-// derived classes; it is more light weight than wxClassInfo and can be used in
-// template classes
-typedef void (*wxEventFunctorClassInfo)();
-
-// this macro must be used in wxEventFunctor-derived classes
-#define wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( classInfoName ) \
- static void classInfoName() {}
-
// The event functor which is stored in the static and dynamic event tables:
class WXDLLIMPEXP_BASE wxEventFunctor
{
// finding it in an event table in Unbind(), by the given functor:
virtual bool IsMatching(const wxEventFunctor& functor) const = 0;
- // Test whether the given class info is the same as from this functor. This
- // allows us in IsMatching to safely downcast the given wxEventFunctor without
- // the usage of dynamic_cast<>().
- virtual bool IsSameClass(wxEventFunctorClassInfo classInfo) const = 0;
-
// If the functor holds an wxEvtHandler, then get access to it and track
// its lifetime with wxEventConnectionRef:
virtual wxEvtHandler *GetEvtHandler() const
// wxEventFunction:
virtual wxEventFunction GetEvtMethod() const
{ return NULL; }
+
+private:
+ WX_DECLARE_ABSTRACT_TYPEINFO(wxEventFunctor)
};
// A plain method functor for the untyped legacy event types:
virtual bool IsMatching(const wxEventFunctor& functor) const
{
- if ( functor.IsSameClass( sm_classInfo ))
+ if ( wxTypeId(functor) == wxTypeId(*this) )
{
const wxObjectEventFunctor &other =
static_cast< const wxObjectEventFunctor & >( functor );
return false;
}
- virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
- { return sm_classInfo == otherClassInfo; }
-
virtual wxEvtHandler *GetEvtHandler() const
{ return m_handler; }
wxEvtHandler *m_handler;
wxEventFunction m_method;
- wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+ // Provide a dummy default ctor for type info purposes
+ wxObjectEventFunctor() { }
+
+ WX_DECLARE_TYPEINFO_INLINE(wxObjectEventFunctor)
};
// Create a functor for the legacy events: used by Connect()
virtual bool IsMatching(const wxEventFunctor& functor) const
{
- if ( !functor.IsSameClass(sm_classInfo) )
+ if ( wxTypeId(functor) != wxTypeId(*this) )
return false;
typedef wxEventFunctorMethod<EventTag, Class, EventArg, EventHandler>
ThisFunctor;
- // the cast is valid because IsSameClass() returned true above
+ // the cast is valid because wxTypeId()s matched above
const ThisFunctor& other = static_cast<const ThisFunctor &>(functor);
return (m_method == other.m_method || other.m_method == NULL) &&
(m_handler == other.m_handler || other.m_handler == NULL);
}
- virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
- { return sm_classInfo == otherClassInfo; }
-
virtual wxEvtHandler *GetEvtHandler() const
{ return this->ConvertToEvtHandler(m_handler); }
EventHandler *m_handler;
void (Class::*m_method)(EventArg&);
- wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+ // Provide a dummy default ctor for type info purposes
+ wxEventFunctorMethod() { }
+
+ typedef wxEventFunctorMethod<EventTag, Class,
+ EventArg, EventHandler> thisClass;
+ WX_DECLARE_TYPEINFO_INLINE(thisClass)
};
virtual bool IsMatching(const wxEventFunctor &functor) const
{
- if ( !functor.IsSameClass(sm_classInfo) )
+ if ( wxTypeId(functor) != wxTypeId(*this) )
return false;
typedef wxEventFunctorFunction<EventTag, EventArg> ThisFunctor;
return m_handler == other.m_handler;
}
- virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
- { return sm_classInfo == otherClassInfo; }
-
private:
void (*m_handler)(EventArg&);
- wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+ // Provide a dummy default ctor for type info purposes
+ wxEventFunctorFunction() { }
+
+ typedef wxEventFunctorFunction<EventTag, EventArg> thisClass;
+ WX_DECLARE_TYPEINFO_INLINE(thisClass)
};
virtual bool IsMatching(const wxEventFunctor &functor) const
{
- if ( !functor.IsSameClass(sm_classInfo) )
+ if ( wxTypeId(functor) != wxTypeId(*this) )
return false;
typedef wxEventFunctorFunctor<EventTag, Functor> FunctorThis;
return m_handlerAddr == other.m_handlerAddr;
}
- virtual bool IsSameClass( wxEventFunctorClassInfo otherClassInfo ) const
- { return sm_classInfo == otherClassInfo; }
-
private:
// Store a copy of the functor to prevent using/calling an already
// destroyed instance:
// Use the address of the original functor for comparison in IsMatching:
const void *m_handlerAddr;
- wxDEFINE_EVENT_FUNCTOR_CLASS_INFO( sm_classInfo );
+ // Provide a dummy default ctor for type info purposes
+ wxEventFunctorFunctor() { }
+
+ typedef wxEventFunctorFunctor<EventTag, Functor> thisClass;
+ WX_DECLARE_TYPEINFO_INLINE(thisClass)
};
// Create functors for the templatized events, either allocated on the heap for
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/typeinfo.h
+// Purpose: wxTypeId implementation
+// Author: Jaakko Salli
+// Created: 2009-11-19
+// RCS-ID: $Id$
+// Copyright: (c) wxWidgets Team
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_TYPEINFO_H_
+#define _WX_TYPEINFO_H_
+
+//
+// This file defines wxTypeId macro that should be used internally in
+// wxWidgets instead of typeid(), for compatibility with builds that do
+// not implement C++ RTTI. Also, type defining macros in this file are also
+// intended for internal use only at this time and may change in future
+// versions.
+//
+
+#include "wx/defs.h"
+
+#ifndef wxNO_RTTI
+
+#include <typeinfo>
+#include <string.h>
+
+#define _WX_DECLARE_TYPEINFO_CUSTOM(CLS, IDENTFUNC)
+#define WX_DECLARE_TYPEINFO_INLINE(CLS)
+#define WX_DECLARE_TYPEINFO(CLS)
+#define WX_DEFINE_TYPEINFO(CLS)
+#define WX_DECLARE_ABSTRACT_TYPEINFO(CLS)
+
+//
+// For improved type-safety, let's make the check using class name
+// comparison. Most modern compilers already do this, but we cannot
+// rely on all supported compilers to work this well. However, in
+// cases where we'd know that typeid() would be flawless (as such),
+// wxTypeId could of course simply be defined as typeid.
+//
+
+class wxTypeInfo
+{
+public:
+ wxTypeInfo(const char* className)
+ {
+ m_className = className;
+ }
+
+ bool operator==(const wxTypeInfo& other)
+ {
+ return strcmp(m_className, other.m_className) == 0;
+ }
+
+ bool operator!=(const wxTypeInfo& other)
+ {
+ return strcmp(m_className, other.m_className) != 0;
+ }
+private:
+ const char* m_className;
+};
+
+#define wxTypeId(OBJ) wxTypeInfo(typeid(OBJ).name())
+
+#else // if !wxNO_RTTI
+
+//
+// When C++ RTTI is not available, we will have to make the type comparison
+// using pointer to a dummy static member function. This will fail if
+// declared type is used across DLL boundaries, although using
+// WX_DECLARE_TYPEINFO() and WX_DEFINE_TYPEINFO() pair instead of
+// WX_DECLARE_TYPEINFO_INLINE() should fix this. However, that approach is
+// usually not possible when type info needs to be declared for a template
+// class.
+//
+
+typedef void (*wxTypeIdentifier)();
+
+// Use this macro to declare type info with specified static function
+// IDENTFUNC used as type identifier. Usually you should only use
+// WX_DECLARE_TYPEINFO() or WX_DECLARE_TYPEINFO_INLINE() however.
+#define _WX_DECLARE_TYPEINFO_CUSTOM(CLS, IDENTFUNC) \
+public: \
+ virtual wxTypeIdentifier GetWxTypeId() const \
+ { \
+ return reinterpret_cast<wxTypeIdentifier> \
+ (&IDENTFUNC); \
+ }
+
+// Use this macro to declare type info with externally specified
+// type identifier, defined with WX_DEFINE_TYPEINFO().
+#define WX_DECLARE_TYPEINFO(CLS) \
+private: \
+ static CLS sm_wxClassInfo(); \
+_WX_DECLARE_TYPEINFO_CUSTOM(CLS, sm_wxClassInfo)
+
+// Use this macro to implement type identifier function required by
+// WX_DECLARE_TYPEINFO().
+// NOTE: CLS is required to have default ctor. If it doesn't
+// already, you should provide a private dummy one.
+#define WX_DEFINE_TYPEINFO(CLS) \
+CLS CLS::sm_wxClassInfo() { return CLS(); }
+
+// Use this macro to declare type info fully inline in class.
+// NOTE: CLS is required to have default ctor. If it doesn't
+// already, you should provide a private dummy one.
+#define WX_DECLARE_TYPEINFO_INLINE(CLS) \
+private: \
+ static CLS sm_wxClassInfo() { return CLS(); } \
+_WX_DECLARE_TYPEINFO_CUSTOM(CLS, sm_wxClassInfo)
+
+#define wxTypeId(OBJ) (OBJ).GetWxTypeId()
+
+// Because abstract classes cannot be instantiated, we use
+// this macro to define pure virtual type interface for them.
+#define WX_DECLARE_ABSTRACT_TYPEINFO(CLS) \
+public: \
+ virtual wxTypeIdentifier GetWxTypeId() const = 0;
+
+#endif // wxNO_RTTI/!wxNO_RTTI
+
+#endif // _WX_TYPEINFO_H_
Note that pointers to any and all classes are already automatically
declared as movable data.
- @warning Caveat with shared libraries (DLLs): If you have a scenario where
- you use wxAny across application's shared library and application
- itself (or, with another of your shared libraries), then you must
- use wxDECLARE_ANY_TYPE() macro in your shared library code to
- correctly make sure that the wxAnyValueType implementation is
- generated correctly. Failure to do this will result in breakage
- of the wxAny type recognition with type in question. Below is an
- example how to use the macro.
- @code
- // In your shared library/DLL-only
- wxDECLARE_ANY_TYPE(MyClass, WXEXPORT)
-
- // In your shared library/DLL source code
- WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)
-
- // In code using said shared library/DLL
- wxDECLARE_ANY_TYPE(MyClass, WXIMPORT)
- @endcode
-
@library{wxbase}
@category{data}
*/
virtual void DeleteValue(wxAnyValueBuffer& buf) const = 0;
- /**
- This function is used for internal type matching.
- */
- virtual wxAnyClassInfo GetClassInfo() const = 0;
-
/**
This function is used for internal type matching.
*/
test_convautotest.o \
test_mbconvtest.o \
test_misctests.o \
+ test_typeinfotest.o \
test_ipc.o \
test_socket.o \
test_regextest.o \
test_misctests.o: $(srcdir)/misc/misctests.cpp $(TEST_ODEP)
$(CXXC) -c -o $@ $(TEST_CXXFLAGS) $(srcdir)/misc/misctests.cpp
+test_typeinfotest.o: $(srcdir)/misc/typeinfotest.cpp $(TEST_ODEP)
+ $(CXXC) -c -o $@ $(TEST_CXXFLAGS) $(srcdir)/misc/typeinfotest.cpp
+
test_ipc.o: $(srcdir)/net/ipc.cpp $(TEST_ODEP)
$(CXXC) -c -o $@ $(TEST_CXXFLAGS) $(srcdir)/net/ipc.cpp
CPPUNIT_ASSERT(wxANY_AS(m_anyWxObjectPtr2, wxObject*)
== dummyWxObjectPointer);
CPPUNIT_ASSERT(wxANY_AS(m_anyVoidPtr2, void*) == dummyVoidPointer);
+
+ // Test sub-type system type compatibility
+ CPPUNIT_ASSERT(m_anySignedShort1.GetType()->
+ IsSameType(m_anySignedLongLong1.GetType()));
+ CPPUNIT_ASSERT(m_anyUnsignedShort1.GetType()->
+ IsSameType(m_anyUnsignedLongLong1.GetType()));
}
void wxAnyTestCase::As()
// Test dynamic conversion
bool res;
long l = 0;
+ short int si = 0;
unsigned long ul = 0;
wxString s;
// Let's test against float instead of double, since the former
bool b = false;
// Conversions from signed long type
+ // The first check should be enough to make sure that the sub-type system
+ // has not failed.
+ res = m_anySignedLong1.GetAs(&si);
+ CPPUNIT_ASSERT(res);
+ CPPUNIT_ASSERT_EQUAL(si, 15);
res = m_anySignedLong1.GetAs(&ul);
CPPUNIT_ASSERT(res);
- CPPUNIT_ASSERT_EQUAL(ul, static_cast<unsigned long>(15));
+ CPPUNIT_ASSERT_EQUAL(ul, 15UL);
res = m_anySignedLong1.GetAs(&s);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(s == "15");
$(OBJS)\test_convautotest.obj \\r
$(OBJS)\test_mbconvtest.obj \\r
$(OBJS)\test_misctests.obj \\r
+ $(OBJS)\test_typeinfotest.obj \\r
$(OBJS)\test_ipc.obj \\r
$(OBJS)\test_socket.obj \\r
$(OBJS)\test_regextest.obj \\r
$(OBJS)\test_misctests.obj: .\misc\misctests.cpp\r
$(CXX) -q -c -P -o$@ $(TEST_CXXFLAGS) .\misc\misctests.cpp\r
\r
+$(OBJS)\test_typeinfotest.obj: .\misc\typeinfotest.cpp\r
+ $(CXX) -q -c -P -o$@ $(TEST_CXXFLAGS) .\misc\typeinfotest.cpp\r
+\r
$(OBJS)\test_ipc.obj: .\net\ipc.cpp\r
$(CXX) -q -c -P -o$@ $(TEST_CXXFLAGS) .\net\ipc.cpp\r
\r
$(OBJS)\test_convautotest.o \\r
$(OBJS)\test_mbconvtest.o \\r
$(OBJS)\test_misctests.o \\r
+ $(OBJS)\test_typeinfotest.o \\r
$(OBJS)\test_ipc.o \\r
$(OBJS)\test_socket.o \\r
$(OBJS)\test_regextest.o \\r
$(OBJS)\test_misctests.o: ./misc/misctests.cpp\r
$(CXX) -c -o $@ $(TEST_CXXFLAGS) $(CPPDEPS) $<\r
\r
+$(OBJS)\test_typeinfotest.o: ./misc/typeinfotest.cpp\r
+ $(CXX) -c -o $@ $(TEST_CXXFLAGS) $(CPPDEPS) $<\r
+\r
$(OBJS)\test_ipc.o: ./net/ipc.cpp\r
$(CXX) -c -o $@ $(TEST_CXXFLAGS) $(CPPDEPS) $<\r
\r
$(OBJS)\test_convautotest.obj \\r
$(OBJS)\test_mbconvtest.obj \\r
$(OBJS)\test_misctests.obj \\r
+ $(OBJS)\test_typeinfotest.obj \\r
$(OBJS)\test_ipc.obj \\r
$(OBJS)\test_socket.obj \\r
$(OBJS)\test_regextest.obj \\r
$(OBJS)\test_misctests.obj: .\misc\misctests.cpp\r
$(CXX) /c /nologo /TP /Fo$@ $(TEST_CXXFLAGS) .\misc\misctests.cpp\r
\r
+$(OBJS)\test_typeinfotest.obj: .\misc\typeinfotest.cpp\r
+ $(CXX) /c /nologo /TP /Fo$@ $(TEST_CXXFLAGS) .\misc\typeinfotest.cpp\r
+\r
$(OBJS)\test_ipc.obj: .\net\ipc.cpp\r
$(CXX) /c /nologo /TP /Fo$@ $(TEST_CXXFLAGS) .\net\ipc.cpp\r
\r
$(OBJS)\test_convautotest.obj &\r
$(OBJS)\test_mbconvtest.obj &\r
$(OBJS)\test_misctests.obj &\r
+ $(OBJS)\test_typeinfotest.obj &\r
$(OBJS)\test_ipc.obj &\r
$(OBJS)\test_socket.obj &\r
$(OBJS)\test_regextest.obj &\r
$(OBJS)\test_misctests.obj : .AUTODEPEND .\misc\misctests.cpp\r
$(CXX) -bt=nt -zq -fo=$^@ $(TEST_CXXFLAGS) $<\r
\r
+$(OBJS)\test_typeinfotest.obj : .AUTODEPEND .\misc\typeinfotest.cpp\r
+ $(CXX) -bt=nt -zq -fo=$^@ $(TEST_CXXFLAGS) $<\r
+\r
$(OBJS)\test_ipc.obj : .AUTODEPEND .\net\ipc.cpp\r
$(CXX) -bt=nt -zq -fo=$^@ $(TEST_CXXFLAGS) $<\r
\r
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: tests/misc/typeinfotest.cpp
+// Purpose: Test typeinfo.h
+// Author: Jaakko Salli
+// RCS-ID: $Id$
+// Copyright: (c) the wxWidgets team
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#include "testprec.h"
+
+#ifdef __BORLANDC__
+# pragma hdrstop
+#endif
+
+#include "wx/typeinfo.h"
+
+// ----------------------------------------------------------------------------
+// test class
+// ----------------------------------------------------------------------------
+
+class TypeInfoTestCase : public CppUnit::TestCase
+{
+public:
+ TypeInfoTestCase() { }
+
+private:
+ CPPUNIT_TEST_SUITE( TypeInfoTestCase );
+ CPPUNIT_TEST( Test );
+ CPPUNIT_TEST_SUITE_END();
+
+ void Test();
+
+ DECLARE_NO_COPY_CLASS(TypeInfoTestCase)
+};
+
+// register in the unnamed registry so that these tests are run by default
+CPPUNIT_TEST_SUITE_REGISTRATION( TypeInfoTestCase );
+
+// also include in it's own registry so that these tests can be run alone
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TypeInfoTestCase, "TypeInfoTestCase" );
+
+
+namespace UserNameSpace {
+ class UserType1
+ {
+ WX_DECLARE_TYPEINFO_INLINE(UserType1)
+ public:
+ virtual ~UserType1() { }
+ };
+}
+
+class UserType1
+{
+ WX_DECLARE_TYPEINFO_INLINE(UserType1)
+public:
+ virtual ~UserType1() { }
+};
+
+class UserType2
+{
+ WX_DECLARE_TYPEINFO(UserType2)
+public:
+ virtual ~UserType2() { }
+};
+
+WX_DEFINE_TYPEINFO(UserType2)
+
+void TypeInfoTestCase::Test()
+{
+ UserNameSpace::UserType1 uns_ut1;
+ UserNameSpace::UserType1* uns_ut1_p = new UserNameSpace::UserType1();
+ UserType1 ut1;
+ UserType1* ut1_p = new UserType1();
+ UserType2 ut2;
+ UserType2* ut2_p = new UserType2();
+
+ // These type comparison should match
+ CPPUNIT_ASSERT(wxTypeId(uns_ut1) == wxTypeId(*uns_ut1_p));
+ CPPUNIT_ASSERT(wxTypeId(ut1) == wxTypeId(*ut1_p));
+ CPPUNIT_ASSERT(wxTypeId(ut2) == wxTypeId(*ut2_p));
+
+ // These type comparison should not match
+ CPPUNIT_ASSERT(wxTypeId(uns_ut1) != wxTypeId(ut1));
+ CPPUNIT_ASSERT(wxTypeId(uns_ut1) != wxTypeId(ut2));
+ CPPUNIT_ASSERT(wxTypeId(ut1) != wxTypeId(ut2));
+
+ delete uns_ut1_p;
+ delete ut1_p;
+ delete ut2_p;
+}
+
mbconv/convautotest.cpp
mbconv/mbconvtest.cpp
misc/misctests.cpp
+ misc/typeinfotest.cpp
net/ipc.cpp
net/socket.cpp
regex/regextest.cpp
# End Source File\r
# Begin Source File\r
\r
+SOURCE=.\misc\typeinfotest.cpp\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=.\strings\unichar.cpp\r
# End Source File\r
# Begin Source File\r
<File\r
RelativePath=".\strings\tokenizer.cpp">\r
</File>\r
+ <File\r
+ RelativePath=".\misc\typeinfotest.cpp">\r
+ </File>\r
<File\r
RelativePath=".\strings\unichar.cpp">\r
</File>\r
RelativePath=".\strings\tokenizer.cpp"\r
>\r
</File>\r
+ <File\r
+ RelativePath=".\misc\typeinfotest.cpp"\r
+ >\r
+ </File>\r
<File\r
RelativePath=".\strings\unichar.cpp"\r
>\r
RelativePath=".\strings\tokenizer.cpp"\r
>\r
</File>\r
+ <File\r
+ RelativePath=".\misc\typeinfotest.cpp"\r
+ >\r
+ </File>\r
<File\r
RelativePath=".\strings\unichar.cpp"\r
>\r
wx/tokenzr.h
wx/tracker.h
wx/txtstrm.h
+wx/typeinfo.h
wx/types.h
wx/unichar.h
wx/uri.h
wx/tokenzr.h
wx/tracker.h
wx/txtstrm.h
+wx/typeinfo.h
wx/types.h
wx/unichar.h
wx/uri.h
wx/tokenzr.h
wx/tracker.h
wx/txtstrm.h
+wx/typeinfo.h
wx/types.h
wx/unichar.h
wx/uri.h
projects / wxWidgets.git / commitdiff
