PLUGINS_INST_DIR = $(libdir)/wx/$(PLUGIN_VERSION0)
ALL_BASE_HEADERS = \
wx/afterstd.h \
+ wx/any.h \
wx/anystr.h \
wx/app.h \
wx/apptrait.h \
$(ALL_GUI_HEADERS)
ALL_PORTS_BASE_HEADERS = \
wx/afterstd.h \
+ wx/any.h \
wx/anystr.h \
wx/app.h \
wx/apptrait.h \
wx/xml/xml.h \
wx/xtixml.h
ALL_BASE_SOURCES = \
+ src/common/any.cpp \
src/common/appbase.cpp \
src/common/arcall.cpp \
src/common/arcfind.cpp \
-I$(top_srcdir)/src/stc/scintilla/src -D__WX__ -DSCI_LEXER -DLINK_LEXERS \
$(PIC_FLAG) $(CPPFLAGS) $(OBJCXXFLAGS)
MONODLL_OBJECTS = \
+ monodll_any.o \
monodll_appbase.o \
monodll_arcall.o \
monodll_arcfind.o \
-I$(top_srcdir)/src/stc/scintilla/src -D__WX__ -DSCI_LEXER -DLINK_LEXERS \
$(CPPFLAGS) $(OBJCXXFLAGS)
MONOLIB_OBJECTS = \
+ monolib_any.o \
monolib_appbase.o \
monolib_arcall.o \
monolib_arcfind.o \
-DwxUSE_BASE=1 $(PIC_FLAG) $(CPPFLAGS) $(OBJCXXFLAGS)
BASEDLL_OBJECTS = \
$(__basedll___win32rc) \
+ basedll_any.o \
basedll_appbase.o \
basedll_arcall.o \
basedll_arcfind.o \
$(__INC_REGEX_p) $(__INC_EXPAT_p) -DwxUSE_GUI=0 -DwxUSE_BASE=1 $(CPPFLAGS) \
$(OBJCXXFLAGS)
BASELIB_OBJECTS = \
+ baselib_any.o \
baselib_appbase.o \
baselib_arcall.o \
baselib_arcfind.o \
wxscintilla_XPM.o: $(srcdir)/src/stc/scintilla/src/XPM.cxx
$(CXXC) -c -o $@ $(WXSCINTILLA_CXXFLAGS) $(srcdir)/src/stc/scintilla/src/XPM.cxx
+monodll_any.o: $(srcdir)/src/common/any.cpp $(MONODLL_ODEP)
+ $(CXXC) -c -o $@ $(MONODLL_CXXFLAGS) $(srcdir)/src/common/any.cpp
+
monodll_appbase.o: $(srcdir)/src/common/appbase.cpp $(MONODLL_ODEP)
$(CXXC) -c -o $@ $(MONODLL_CXXFLAGS) $(srcdir)/src/common/appbase.cpp
monodll_version_rc.o: $(srcdir)/src/msw/version.rc $(MONODLL_ODEP)
$(WINDRES) -i$< -o$@ --define __WX$(TOOLKIT)__ $(__WXUNIV_DEFINE_p_62) $(__DEBUG_DEFINE_p_61) $(__EXCEPTIONS_DEFINE_p_61) $(__RTTI_DEFINE_p_61) $(__THREAD_DEFINE_p_61) --define WXBUILDING --define WXDLLNAME=$(WXDLLNAMEPREFIXGUI)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG) $(__RCDEFDIR_p) --include-dir $(top_srcdir)/include $(__INC_TIFF_BUILD_p_62) $(__INC_TIFF_p_62) $(__INC_JPEG_p_62) $(__INC_PNG_p_61) $(__INC_ZLIB_p_63) $(__INC_REGEX_p_61) $(__INC_EXPAT_p_61) --define wxUSE_BASE=1 --define WXMAKINGDLL --include-dir $(top_srcdir)/src/stc/scintilla/include --include-dir $(top_srcdir)/src/stc/scintilla/src --define __WX__ --define SCI_LEXER --define LINK_LEXERS
+monolib_any.o: $(srcdir)/src/common/any.cpp $(MONOLIB_ODEP)
+ $(CXXC) -c -o $@ $(MONOLIB_CXXFLAGS) $(srcdir)/src/common/any.cpp
+
monolib_appbase.o: $(srcdir)/src/common/appbase.cpp $(MONOLIB_ODEP)
$(CXXC) -c -o $@ $(MONOLIB_CXXFLAGS) $(srcdir)/src/common/appbase.cpp
basedll_version_rc.o: $(srcdir)/src/msw/version.rc $(BASEDLL_ODEP)
$(WINDRES) -i$< -o$@ --define __WX$(TOOLKIT)__ $(__WXUNIV_DEFINE_p_62) $(__DEBUG_DEFINE_p_61) $(__EXCEPTIONS_DEFINE_p_61) $(__RTTI_DEFINE_p_61) $(__THREAD_DEFINE_p_61) --define WXBUILDING --define WXDLLNAME=$(WXDLLNAMEPREFIX)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)$(WXCOMPILER)$(VENDORTAG)$(WXDLLVERSIONTAG) $(__RCDEFDIR_p) --include-dir $(top_srcdir)/include $(__INC_TIFF_BUILD_p_62) $(__INC_TIFF_p_62) $(__INC_JPEG_p_62) $(__INC_PNG_p_61) $(__INC_ZLIB_p_63) $(__INC_REGEX_p_61) $(__INC_EXPAT_p_61) --define wxUSE_GUI=0 --define WXMAKINGDLL_BASE --define wxUSE_BASE=1
+basedll_any.o: $(srcdir)/src/common/any.cpp $(BASEDLL_ODEP)
+ $(CXXC) -c -o $@ $(BASEDLL_CXXFLAGS) $(srcdir)/src/common/any.cpp
+
basedll_appbase.o: $(srcdir)/src/common/appbase.cpp $(BASEDLL_ODEP)
$(CXXC) -c -o $@ $(BASEDLL_CXXFLAGS) $(srcdir)/src/common/appbase.cpp
@COND_PLATFORM_MACOSX_1@basedll_utilsunx.o: $(srcdir)/src/unix/utilsunx.cpp $(BASEDLL_ODEP)
@COND_PLATFORM_MACOSX_1@ $(CXXC) -c -o $@ $(BASEDLL_CXXFLAGS) $(srcdir)/src/unix/utilsunx.cpp
+baselib_any.o: $(srcdir)/src/common/any.cpp $(BASELIB_ODEP)
+ $(CXXC) -c -o $@ $(BASELIB_CXXFLAGS) $(srcdir)/src/common/any.cpp
+
baselib_appbase.o: $(srcdir)/src/common/appbase.cpp $(BASELIB_ODEP)
$(CXXC) -c -o $@ $(BASELIB_CXXFLAGS) $(srcdir)/src/common/appbase.cpp
<!-- Common -->
<!-- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -->
<set var="BASE_CMN_SRC" hints="files">
+ src/common/any.cpp
src/common/appbase.cpp
src/common/arcall.cpp
src/common/arcfind.cpp
</set>
<set var="BASE_CMN_HDR" hints="files">
wx/afterstd.h
+ wx/any.h
wx/anystr.h
wx/app.h
wx/apptrait.h
$(CXXFLAGS)
MONODLL_OBJECTS = \
$(OBJS)\monodll_dummy.obj \
+ $(OBJS)\monodll_any.obj \
$(OBJS)\monodll_appbase.obj \
$(OBJS)\monodll_arcall.obj \
$(OBJS)\monodll_arcfind.obj \
$(CXXFLAGS)
MONOLIB_OBJECTS = \
$(OBJS)\monolib_dummy.obj \
+ $(OBJS)\monolib_any.obj \
$(OBJS)\monolib_appbase.obj \
$(OBJS)\monolib_arcall.obj \
$(OBJS)\monolib_arcfind.obj \
-DwxUSE_BASE=1 -Hu -H=$(OBJS)\wxprec_basedll.csm $(CPPFLAGS) $(CXXFLAGS)
BASEDLL_OBJECTS = \
$(OBJS)\basedll_dummy.obj \
+ $(OBJS)\basedll_any.obj \
$(OBJS)\basedll_appbase.obj \
$(OBJS)\basedll_arcall.obj \
$(OBJS)\basedll_arcfind.obj \
-H=$(OBJS)\wxprec_baselib.csm $(CPPFLAGS) $(CXXFLAGS)
BASELIB_OBJECTS = \
$(OBJS)\baselib_dummy.obj \
+ $(OBJS)\baselib_any.obj \
$(OBJS)\baselib_appbase.obj \
$(OBJS)\baselib_arcall.obj \
$(OBJS)\baselib_arcfind.obj \
$(OBJS)\monodll_dummy.obj: ..\..\src\common\dummy.cpp
$(CXX) -q -c -P -o$@ $(MONODLL_CXXFLAGS) -H ..\..\src\common\dummy.cpp
+$(OBJS)\monodll_any.obj: ..\..\src\common\any.cpp
+ $(CXX) -q -c -P -o$@ $(MONODLL_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\monodll_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) -q -c -P -o$@ $(MONODLL_CXXFLAGS) ..\..\src\common\appbase.cpp
$(OBJS)\monolib_dummy.obj: ..\..\src\common\dummy.cpp
$(CXX) -q -c -P -o$@ $(MONOLIB_CXXFLAGS) -H ..\..\src\common\dummy.cpp
+$(OBJS)\monolib_any.obj: ..\..\src\common\any.cpp
+ $(CXX) -q -c -P -o$@ $(MONOLIB_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\monolib_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) -q -c -P -o$@ $(MONOLIB_CXXFLAGS) ..\..\src\common\appbase.cpp
$(OBJS)\basedll_version.res: ..\..\src\msw\version.rc
brcc32 -32 -r -fo$@ -i$(BCCDIR)\include -d__WXMSW__ $(__WXUNIV_DEFINE_p_62) $(__DEBUG_DEFINE_p_61) $(__EXCEPTIONS_DEFINE_p_61) $(__RTTI_DEFINE_p_61) $(__THREAD_DEFINE_p_61) $(__UNICODE_DEFINE_p_62) $(__MSLU_DEFINE_p_61) $(__GFXCTX_DEFINE_p_61) -i$(SETUPHDIR) -i..\..\include -dWXBUILDING -dWXDLLNAME=wxbase$(WX_VERSION_NODOT)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_bcc$(VENDORTAG) -i..\..\src\tiff\libtiff -i..\..\src\jpeg -i..\..\src\png -i..\..\src\zlib -i..\..\src\regex -i..\..\src\expat\lib -dwxUSE_GUI=0 -dWXMAKINGDLL_BASE -dwxUSE_BASE=1 ..\..\src\msw\version.rc
+$(OBJS)\basedll_any.obj: ..\..\src\common\any.cpp
+ $(CXX) -q -c -P -o$@ $(BASEDLL_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\basedll_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) -q -c -P -o$@ $(BASEDLL_CXXFLAGS) ..\..\src\common\appbase.cpp
$(OBJS)\baselib_dummy.obj: ..\..\src\common\dummy.cpp
$(CXX) -q -c -P -o$@ $(BASELIB_CXXFLAGS) -H ..\..\src\common\dummy.cpp
+$(OBJS)\baselib_any.obj: ..\..\src\common\any.cpp
+ $(CXX) -q -c -P -o$@ $(BASELIB_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\baselib_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) -q -c -P -o$@ $(BASELIB_CXXFLAGS) ..\..\src\common\appbase.cpp
-Wno-ctor-dtor-privacy $(CPPFLAGS) $(CXXFLAGS)
MONODLL_OBJECTS = \
$(OBJS)\monodll_dummy.o \
+ $(OBJS)\monodll_any.o \
$(OBJS)\monodll_appbase.o \
$(OBJS)\monodll_arcall.o \
$(OBJS)\monodll_arcfind.o \
-Wno-ctor-dtor-privacy $(CPPFLAGS) $(CXXFLAGS)
MONOLIB_OBJECTS = \
$(OBJS)\monolib_dummy.o \
+ $(OBJS)\monolib_any.o \
$(OBJS)\monolib_appbase.o \
$(OBJS)\monolib_arcall.o \
$(OBJS)\monolib_arcfind.o \
BASEDLL_OBJECTS = \
$(OBJS)\basedll_dummy.o \
$(OBJS)\basedll_version_rc.o \
+ $(OBJS)\basedll_any.o \
$(OBJS)\basedll_appbase.o \
$(OBJS)\basedll_arcall.o \
$(OBJS)\basedll_arcfind.o \
$(CXXFLAGS)
BASELIB_OBJECTS = \
$(OBJS)\baselib_dummy.o \
+ $(OBJS)\baselib_any.o \
$(OBJS)\baselib_appbase.o \
$(OBJS)\baselib_arcall.o \
$(OBJS)\baselib_arcfind.o \
$(OBJS)\monodll_dummy.o: ../../src/common/dummy.cpp
$(CXX) -c -o $@ $(MONODLL_CXXFLAGS) $(CPPDEPS) $<
+$(OBJS)\monodll_any.o: ../../src/common/any.cpp
+ $(CXX) -c -o $@ $(MONODLL_CXXFLAGS) $(CPPDEPS) $<
+
$(OBJS)\monodll_appbase.o: ../../src/common/appbase.cpp
$(CXX) -c -o $@ $(MONODLL_CXXFLAGS) $(CPPDEPS) $<
$(OBJS)\monolib_dummy.o: ../../src/common/dummy.cpp
$(CXX) -c -o $@ $(MONOLIB_CXXFLAGS) $(CPPDEPS) $<
+$(OBJS)\monolib_any.o: ../../src/common/any.cpp
+ $(CXX) -c -o $@ $(MONOLIB_CXXFLAGS) $(CPPDEPS) $<
+
$(OBJS)\monolib_appbase.o: ../../src/common/appbase.cpp
$(CXX) -c -o $@ $(MONOLIB_CXXFLAGS) $(CPPDEPS) $<
$(OBJS)\basedll_version_rc.o: ../../src/msw/version.rc
windres --use-temp-file -i$< -o$@ --define __WXMSW__ $(__WXUNIV_DEFINE_p_62) $(__DEBUG_DEFINE_p_61) $(__EXCEPTIONS_DEFINE_p_61) $(__RTTI_DEFINE_p_61) $(__THREAD_DEFINE_p_61) $(__UNICODE_DEFINE_p_62) $(__MSLU_DEFINE_p_61) $(__GFXCTX_DEFINE_p_61) --include-dir $(SETUPHDIR) --include-dir ../../include --define WXBUILDING --define WXDLLNAME=wxbase$(WX_VERSION_NODOT)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_gcc$(VENDORTAG) --include-dir ../../src/tiff/libtiff --include-dir ../../src/jpeg --include-dir ../../src/png --include-dir ../../src/zlib --include-dir ../../src/regex --include-dir ../../src/expat/lib --define wxUSE_GUI=0 --define WXMAKINGDLL_BASE --define wxUSE_BASE=1
+$(OBJS)\basedll_any.o: ../../src/common/any.cpp
+ $(CXX) -c -o $@ $(BASEDLL_CXXFLAGS) $(CPPDEPS) $<
+
$(OBJS)\basedll_appbase.o: ../../src/common/appbase.cpp
$(CXX) -c -o $@ $(BASEDLL_CXXFLAGS) $(CPPDEPS) $<
$(OBJS)\baselib_dummy.o: ../../src/common/dummy.cpp
$(CXX) -c -o $@ $(BASELIB_CXXFLAGS) $(CPPDEPS) $<
+$(OBJS)\baselib_any.o: ../../src/common/any.cpp
+ $(CXX) -c -o $@ $(BASELIB_CXXFLAGS) $(CPPDEPS) $<
+
$(OBJS)\baselib_appbase.o: ../../src/common/appbase.cpp
$(CXX) -c -o $@ $(BASELIB_CXXFLAGS) $(CPPDEPS) $<
/Fp"$(OBJS)\wxprec_monodll.pch" $(CPPFLAGS) $(CXXFLAGS)
MONODLL_OBJECTS = \
$(OBJS)\monodll_dummy.obj \
+ $(OBJS)\monodll_any.obj \
$(OBJS)\monodll_appbase.obj \
$(OBJS)\monodll_arcall.obj \
$(OBJS)\monodll_arcfind.obj \
/Fp"$(OBJS)\wxprec_monolib.pch" $(CPPFLAGS) $(CXXFLAGS)
MONOLIB_OBJECTS = \
$(OBJS)\monolib_dummy.obj \
+ $(OBJS)\monolib_any.obj \
$(OBJS)\monolib_appbase.obj \
$(OBJS)\monolib_arcall.obj \
$(OBJS)\monolib_arcfind.obj \
BASEDLL_OBJECTS = \
$(OBJS)\basedll_dummy.obj \
$(OBJS)\basedll_version.res \
+ $(OBJS)\basedll_any.obj \
$(OBJS)\basedll_appbase.obj \
$(OBJS)\basedll_arcall.obj \
$(OBJS)\basedll_arcfind.obj \
/Fp"$(OBJS)\wxprec_baselib.pch" $(CPPFLAGS) $(CXXFLAGS)
BASELIB_OBJECTS = \
$(OBJS)\baselib_dummy.obj \
+ $(OBJS)\baselib_any.obj \
$(OBJS)\baselib_appbase.obj \
$(OBJS)\baselib_arcall.obj \
$(OBJS)\baselib_arcfind.obj \
$(OBJS)\monodll_dummy.obj: ..\..\src\common\dummy.cpp
$(CXX) /c /nologo /TP /Fo$@ $(MONODLL_CXXFLAGS) /Ycwx/wxprec.h ..\..\src\common\dummy.cpp
+$(OBJS)\monodll_any.obj: ..\..\src\common\any.cpp
+ $(CXX) /c /nologo /TP /Fo$@ $(MONODLL_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\monodll_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) /c /nologo /TP /Fo$@ $(MONODLL_CXXFLAGS) ..\..\src\common\appbase.cpp
$(OBJS)\monolib_dummy.obj: ..\..\src\common\dummy.cpp
$(CXX) /c /nologo /TP /Fo$@ $(MONOLIB_CXXFLAGS) /Ycwx/wxprec.h ..\..\src\common\dummy.cpp
+$(OBJS)\monolib_any.obj: ..\..\src\common\any.cpp
+ $(CXX) /c /nologo /TP /Fo$@ $(MONOLIB_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\monolib_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) /c /nologo /TP /Fo$@ $(MONOLIB_CXXFLAGS) ..\..\src\common\appbase.cpp
$(OBJS)\basedll_version.res: ..\..\src\msw\version.rc
rc /fo$@ /d WIN32 $(____DEBUGRUNTIME_4) $(__NO_VC_CRTDBG_p_68) /d __WXMSW__ $(__WXUNIV_DEFINE_p_62) $(__DEBUG_DEFINE_p_61) $(__EXCEPTIONS_DEFINE_p_61) $(__RTTI_DEFINE_p_61) $(__THREAD_DEFINE_p_61) $(__UNICODE_DEFINE_p_62) $(__MSLU_DEFINE_p_61) $(__GFXCTX_DEFINE_p_61) /i $(SETUPHDIR) /i ..\..\include /d WXBUILDING /d WXDLLNAME=wxbase$(WX_VERSION_NODOT)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_vc$(VENDORTAG) /i ..\..\src\tiff\libtiff /i ..\..\src\jpeg /i ..\..\src\png /i ..\..\src\zlib /i ..\..\src\regex /i ..\..\src\expat\lib /d wxUSE_GUI=0 /d WXMAKINGDLL_BASE /d wxUSE_BASE=1 ..\..\src\msw\version.rc
+$(OBJS)\basedll_any.obj: ..\..\src\common\any.cpp
+ $(CXX) /c /nologo /TP /Fo$@ $(BASEDLL_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\basedll_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) /c /nologo /TP /Fo$@ $(BASEDLL_CXXFLAGS) ..\..\src\common\appbase.cpp
$(OBJS)\baselib_dummy.obj: ..\..\src\common\dummy.cpp
$(CXX) /c /nologo /TP /Fo$@ $(BASELIB_CXXFLAGS) /Ycwx/wxprec.h ..\..\src\common\dummy.cpp
+$(OBJS)\baselib_any.obj: ..\..\src\common\any.cpp
+ $(CXX) /c /nologo /TP /Fo$@ $(BASELIB_CXXFLAGS) ..\..\src\common\any.cpp
+
$(OBJS)\baselib_appbase.obj: ..\..\src\common\appbase.cpp
$(CXX) /c /nologo /TP /Fo$@ $(BASELIB_CXXFLAGS) ..\..\src\common\appbase.cpp
$(__EXCEPTIONSFLAG) $(CPPFLAGS) $(CXXFLAGS)
MONODLL_OBJECTS = &
$(OBJS)\monodll_dummy.obj &
+ $(OBJS)\monodll_any.obj &
$(OBJS)\monodll_appbase.obj &
$(OBJS)\monodll_arcall.obj &
$(OBJS)\monodll_arcfind.obj &
$(CPPFLAGS) $(CXXFLAGS)
MONOLIB_OBJECTS = &
$(OBJS)\monolib_dummy.obj &
+ $(OBJS)\monolib_any.obj &
$(OBJS)\monolib_appbase.obj &
$(OBJS)\monolib_arcall.obj &
$(OBJS)\monolib_arcfind.obj &
$(CPPFLAGS) $(CXXFLAGS)
BASEDLL_OBJECTS = &
$(OBJS)\basedll_dummy.obj &
+ $(OBJS)\basedll_any.obj &
$(OBJS)\basedll_appbase.obj &
$(OBJS)\basedll_arcall.obj &
$(OBJS)\basedll_arcfind.obj &
$(CPPFLAGS) $(CXXFLAGS)
BASELIB_OBJECTS = &
$(OBJS)\baselib_dummy.obj &
+ $(OBJS)\baselib_any.obj &
$(OBJS)\baselib_appbase.obj &
$(OBJS)\baselib_arcall.obj &
$(OBJS)\baselib_arcfind.obj &
$(OBJS)\monodll_dummy.obj : .AUTODEPEND ..\..\src\common\dummy.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(MONODLL_CXXFLAGS) $<
+$(OBJS)\monodll_any.obj : .AUTODEPEND ..\..\src\common\any.cpp
+ $(CXX) -bt=nt -zq -fo=$^@ $(MONODLL_CXXFLAGS) $<
+
$(OBJS)\monodll_appbase.obj : .AUTODEPEND ..\..\src\common\appbase.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(MONODLL_CXXFLAGS) $<
$(OBJS)\monolib_dummy.obj : .AUTODEPEND ..\..\src\common\dummy.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(MONOLIB_CXXFLAGS) $<
+$(OBJS)\monolib_any.obj : .AUTODEPEND ..\..\src\common\any.cpp
+ $(CXX) -bt=nt -zq -fo=$^@ $(MONOLIB_CXXFLAGS) $<
+
$(OBJS)\monolib_appbase.obj : .AUTODEPEND ..\..\src\common\appbase.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(MONOLIB_CXXFLAGS) $<
$(OBJS)\basedll_version.res : .AUTODEPEND ..\..\src\msw\version.rc
wrc -q -ad -bt=nt -r -fo=$^@ -d__WXMSW__ $(__WXUNIV_DEFINE_p) $(__DEBUG_DEFINE_p) $(__EXCEPTIONS_DEFINE_p) $(__RTTI_DEFINE_p) $(__THREAD_DEFINE_p) $(__UNICODE_DEFINE_p) $(__GFXCTX_DEFINE_p) -i=$(SETUPHDIR) -i=..\..\include -dWXBUILDING -dWXDLLNAME=wxbase$(WX_VERSION_NODOT)$(WXUNICODEFLAG)$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_wat$(VENDORTAG) -i=..\..\src\tiff\libtiff -i=..\..\src\jpeg -i=..\..\src\png -i=..\..\src\zlib -i=..\..\src\regex -i=..\..\src\expat\lib -dwxUSE_GUI=0 -dWXMAKINGDLL_BASE -dwxUSE_BASE=1 $<
+$(OBJS)\basedll_any.obj : .AUTODEPEND ..\..\src\common\any.cpp
+ $(CXX) -bt=nt -zq -fo=$^@ $(BASEDLL_CXXFLAGS) $<
+
$(OBJS)\basedll_appbase.obj : .AUTODEPEND ..\..\src\common\appbase.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(BASEDLL_CXXFLAGS) $<
$(OBJS)\baselib_dummy.obj : .AUTODEPEND ..\..\src\common\dummy.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(BASELIB_CXXFLAGS) $<
+$(OBJS)\baselib_any.obj : .AUTODEPEND ..\..\src\common\any.cpp
+ $(CXX) -bt=nt -zq -fo=$^@ $(BASELIB_CXXFLAGS) $<
+
$(OBJS)\baselib_appbase.obj : .AUTODEPEND ..\..\src\common\appbase.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(BASELIB_CXXFLAGS) $<
# PROP Default_Filter ""\r
# Begin Source File\r
\r
+SOURCE=..\..\src\common\any.cpp\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=..\..\src\common\appbase.cpp\r
# End Source File\r
# Begin Source File\r
# End Source File\r
# Begin Source File\r
\r
+SOURCE=..\..\include\wx\any.h\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=..\..\include\wx\anystr.h\r
# End Source File\r
# Begin Source File\r
<Filter\r
Name="Common Sources"\r
UniqueIdentifier="{A6A5C30D-BDB6-5050-906D-10A96065136C}">\r
+ <File\r
+ RelativePath="..\..\src\common\any.cpp">\r
+ </File>\r
<File\r
RelativePath="..\..\src\common\appbase.cpp">\r
</File>\r
<File\r
RelativePath="..\..\include\wx\afterstd.h">\r
</File>\r
+ <File\r
+ RelativePath="..\..\include\wx\any.h">\r
+ </File>\r
<File\r
RelativePath="..\..\include\wx\anystr.h">\r
</File>\r
Name="Common Sources"\r
UniqueIdentifier="{A6A5C30D-BDB6-5050-906D-10A96065136C}"\r
>\r
+ <File\r
+ RelativePath="..\..\src\common\any.cpp"\r
+ >\r
+ </File>\r
<File\r
RelativePath="..\..\src\common\appbase.cpp"\r
>\r
RelativePath="..\..\include\wx\afterstd.h"\r
>\r
</File>\r
+ <File\r
+ RelativePath="..\..\include\wx\any.h"\r
+ >\r
+ </File>\r
<File\r
RelativePath="..\..\include\wx\anystr.h"\r
>\r
Name="Common Sources"\r
UniqueIdentifier="{A6A5C30D-BDB6-5050-906D-10A96065136C}"\r
>\r
+ <File\r
+ RelativePath="..\..\src\common\any.cpp"\r
+ >\r
+ </File>\r
<File\r
RelativePath="..\..\src\common\appbase.cpp"\r
>\r
RelativePath="..\..\include\wx\afterstd.h"\r
>\r
</File>\r
+ <File\r
+ RelativePath="..\..\include\wx\any.h"\r
+ >\r
+ </File>\r
<File\r
RelativePath="..\..\include\wx\anystr.h"\r
>\r
#! /bin/sh
-# From configure.in Id.
+# From configure.in Id: configure.in 61944 2009-09-16 12:06:02Z PJC .
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.61 for wxWidgets 2.9.1.
#
--enable-baseevtloop use event loop in console programs too
--enable-epollloop use wxEpollDispatcher class (Linux only)
--enable-selectloop use wxSelectDispatcher class
+ --enable-any use wxAny class
--enable-apple_ieee use the Apple IEEE codec
--enable-arcstream use wxArchive streams
--enable-base64 use base64 encoding/decoding functions
+ enablestring=
+ defaultval=$wxUSE_ALL_FEATURES
+ if test -z "$defaultval"; then
+ if test x"$enablestring" = xdisable; then
+ defaultval=yes
+ else
+ defaultval=no
+ fi
+ fi
+
+ { echo "$as_me:$LINENO: checking for --${enablestring:-enable}-any" >&5
+echo $ECHO_N "checking for --${enablestring:-enable}-any... $ECHO_C" >&6; }
+ # Check whether --enable-any was given.
+if test "${enable_any+set}" = set; then
+ enableval=$enable_any;
+ if test "$enableval" = yes; then
+ wx_cv_use_any='wxUSE_ANY=yes'
+ else
+ wx_cv_use_any='wxUSE_ANY=no'
+ fi
+
+else
+
+ wx_cv_use_any='wxUSE_ANY=${'DEFAULT_wxUSE_ANY":-$defaultval}"
+
+fi
+
+
+ eval "$wx_cv_use_any"
+
+ if test x"$enablestring" = xdisable; then
+ if test $wxUSE_ANY = no; then
+ result=yes
+ else
+ result=no
+ fi
+ else
+ result=$wxUSE_ANY
+ fi
+
+ { echo "$as_me:$LINENO: result: $result" >&5
+echo "${ECHO_T}$result" >&6; }
+
+
enablestring=
defaultval=$wxUSE_ALL_FEATURES
if test -z "$defaultval"; then
fi
+if test "$wxUSE_ANY" = "yes"; then
+ cat >>confdefs.h <<\_ACEOF
+#define wxUSE_ANY 1
+_ACEOF
+
+fi
+
if test "$wxUSE_APPLE_IEEE" = "yes"; then
cat >>confdefs.h <<\_ACEOF
#define wxUSE_APPLE_IEEE 1
WX_ARG_FEATURE(selectloop, [ --enable-selectloop use wxSelectDispatcher class], wxUSE_SELECT_DISPATCHER)
dnl please keep the settings below in alphabetical order
+WX_ARG_FEATURE(any, [ --enable-any use wxAny class], wxUSE_ANY)
WX_ARG_FEATURE(apple_ieee, [ --enable-apple_ieee use the Apple IEEE codec], wxUSE_APPLE_IEEE)
WX_ARG_FEATURE(arcstream, [ --enable-arcstream use wxArchive streams], wxUSE_ARCHIVE_STREAMS)
WX_ARG_FEATURE(base64, [ --enable-base64 use base64 encoding/decoding functions], wxUSE_BASE64)
AC_DEFINE(wxUSE_EXTENDED_RTTI)
fi
+if test "$wxUSE_ANY" = "yes"; then
+ AC_DEFINE(wxUSE_ANY)
+fi
+
if test "$wxUSE_APPLE_IEEE" = "yes"; then
AC_DEFINE(wxUSE_APPLE_IEEE)
fi
--------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
wxWidgets Change Log
-------------------------------------------------------------------------------
- Fix bug with position argument in wxImage::Size() (Byron Sorgdrager).
- Fix bug with parsing concatenated switches in wxCmdLineParser (Mike Funduc).
- Added wxMBConv::cMB2WC(wxCharBuffer) and cWC2MB(wxWCharBuffer) overloads.
+- Added wxAny class; a modern, backwards-incompatible replacement for
+ wxVariant.
All (GUI):
These are the data structure classes supported by wxWidgets.
+@li wxAny: A class for storing arbitrary types that may change at run-time
@li wxCmdLineParser: Command line parser class
@li wxDateSpan: A logical time interval.
@li wxDateTime: A class for date/time manipulations
@itemdef{wxUSE_ACCEL, Use wxAcceleratorTable/Entry classes and support for them in wxMenu, wxMenuBar.}
@itemdef{wxUSE_AFM_FOR_POSTSCRIPT, In wxPostScriptDC class use AFM (adobe font metrics) file for character widths.}
@itemdef{wxUSE_ANIMATIONCTRL, Use wxAnimationCtrl class.}
+@itemdef{wxUSE_ANY, Use wxAny class.}
@itemdef{wxUSE_APPLE_IEEE, IEEE Extended to/from double routines; see src/common/extended.c file.}
@itemdef{wxUSE_ARCHIVE_STREAMS, Enable streams for archive formats.}
@itemdef{wxUSE_AUI, Use AUI (dockable windows) library.}
# these classes are either replaced by different data types in bindings, or have equivalent / better
# functionality provided by the target language.
excluded_classes = [
+ "wxAny",
+ "wxAnyValueType",
"wxArchiveClassFactory",
"wxArchiveEntry",
"wxArchiveInputStream",
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////\r
+// Name: wx/any.h\r
+// Purpose: wxAny class\r
+// Author: Jaakko Salli\r
+// Modified by:\r
+// Created: 07/05/2009\r
+// RCS-ID: $Id$\r
+// Copyright: (c) wxWidgets team\r
+// Licence: wxWindows licence\r
+/////////////////////////////////////////////////////////////////////////////\r
+\r
+#ifndef _WX_ANY_H_\r
+#define _WX_ANY_H_\r
+\r
+#include "wx/defs.h"\r
+\r
+#if wxUSE_ANY\r
+\r
+#include "wx/string.h"\r
+#include "wx/meta/movable.h"\r
+#include "wx/meta/if.h"\r
+\r
+\r
+// Size of the wxAny value buffer.\r
+enum\r
+{\r
+ WX_ANY_VALUE_BUFFER_SIZE = 16\r
+};\r
+\r
+union wxAnyValueBuffer\r
+{\r
+ void* m_ptr;\r
+ wxByte m_buffer[WX_ANY_VALUE_BUFFER_SIZE];\r
+};\r
+\r
+typedef void (*wxAnyClassInfo)();\r
+\r
+\r
+//\r
+// wxAnyValueType is base class for value type functionality for C++ data\r
+// types used with wxAny. Usually the default template (wxAnyValueTypeImpl<>)\r
+// will create a satisfactory wxAnyValueType implementation for a data type.\r
+//\r
+class WXDLLIMPEXP_BASE wxAnyValueType\r
+{\r
+public:\r
+ /**\r
+ Default constructor.\r
+ */\r
+ wxAnyValueType();\r
+\r
+ /**\r
+ Destructor.\r
+ */\r
+ virtual ~wxAnyValueType()\r
+ {\r
+ }\r
+\r
+ /**\r
+ This function is used for internal type matching.\r
+ */\r
+ virtual wxAnyClassInfo GetClassInfo() const = 0;\r
+\r
+ /**\r
+ This function is used for internal type matching.\r
+ */\r
+ virtual bool IsSameType(const wxAnyValueType* otherType) const = 0;\r
+\r
+ /**\r
+ This function is called every time the data in wxAny\r
+ buffer needs to be freed.\r
+ */\r
+ virtual void DeleteValue(wxAnyValueBuffer& buf) const = 0;\r
+\r
+ /**\r
+ Implement this for buffer-to-buffer copy. src.m_ptr can\r
+ be expected to be NULL if value type of previously stored\r
+ data was different.\r
+ */\r
+ virtual void CopyBuffer(const wxAnyValueBuffer& src,\r
+ wxAnyValueBuffer& dst) const = 0;\r
+\r
+ /**\r
+ Convert value into buffer of different type. Return false if\r
+ not possible.\r
+ */\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const = 0;\r
+\r
+ /**\r
+ Use this template function for checking if wxAnyValueType represents\r
+ a specific C++ data type.\r
+\r
+ @remarks This template function does not work on some older compilers\r
+ (such as Visual C++ 6.0). For full compiler ccompatibility\r
+ please use wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) macro\r
+ instead.\r
+\r
+ @see wxAny::CheckType()\r
+ */\r
+ // FIXME-VC6: remove this hack when VC6 is no longer supported\r
+ template <typename T>\r
+ bool CheckType(T* reserved = NULL);\r
+private:\r
+};\r
+\r
+//\r
+// This method of checking the type is compatible with VC6\r
+#define wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) \\r
+ wxAnyValueTypeImpl<T>::IsSameClass(valueTypePtr)\r
+\r
+ //valueTypePtr->CheckType(static_cast<T*>(NULL))\r
+\r
+\r
+/**\r
+ Helper macro for defining user value types.\r
+\r
+ NB: We really cannot compare sm_classInfo directly in IsSameClass(),\r
+ but instead call sm_instance->GetClassInfo(). The former technique\r
+ broke at least on GCC 4.2 (but worked on VC8 shared build).\r
+*/\r
+#define WX_DECLARE_ANY_VALUE_TYPE(CLS) \\r
+ friend class wxAny; \\r
+public: \\r
+ static void sm_classInfo() {} \\r
+ \\r
+ virtual wxAnyClassInfo GetClassInfo() const \\r
+ { \\r
+ return sm_classInfo; \\r
+ } \\r
+ static bool IsSameClass(const wxAnyValueType* otherType) \\r
+ { \\r
+ return sm_instance->GetClassInfo() == otherType->GetClassInfo(); \\r
+ } \\r
+ virtual bool IsSameType(const wxAnyValueType* otherType) const \\r
+ { \\r
+ return IsSameClass(otherType); \\r
+ } \\r
+private: \\r
+ static CLS* sm_instance; \\r
+public: \\r
+ static wxAnyValueType* GetInstance() \\r
+ { \\r
+ return sm_instance; \\r
+ }\r
+\r
+\r
+#define WX_IMPLEMENT_ANY_VALUE_TYPE(CLS) \\r
+ CLS* CLS::sm_instance = new CLS();\r
+\r
+\r
+#ifdef __VISUALC6__\r
+ // "non dll-interface class 'xxx' used as base interface\r
+ #pragma warning (push)\r
+ #pragma warning (disable:4275)\r
+#endif\r
+\r
+/**\r
+ Following are helper classes for the wxAnyValueTypeImplBase.\r
+*/\r
+namespace wxPrivate\r
+{\r
+\r
+template<typename T>\r
+class wxAnyValueTypeOpsMovable\r
+{\r
+public:\r
+ static void DeleteValue(wxAnyValueBuffer& buf)\r
+ {\r
+ wxUnusedVar(buf);\r
+ }\r
+\r
+ static void SetValue(const T& value,\r
+ wxAnyValueBuffer& buf)\r
+ {\r
+ memcpy(buf.m_buffer, &value, sizeof(T));\r
+ }\r
+\r
+ static const T& GetValue(const wxAnyValueBuffer& buf)\r
+ {\r
+ return *(reinterpret_cast<const T*>(&buf.m_buffer[0]));\r
+ }\r
+};\r
+\r
+\r
+template<typename T>\r
+class wxAnyValueTypeOpsGeneric\r
+{\r
+public:\r
+ template<typename T2>\r
+ class DataHolder\r
+ {\r
+ public:\r
+ DataHolder(const T2& value)\r
+ {\r
+ m_value = value;\r
+ }\r
+ virtual ~DataHolder() { }\r
+\r
+ T2 m_value;\r
+ private:\r
+ wxDECLARE_NO_COPY_CLASS(DataHolder);\r
+ };\r
+\r
+ static void DeleteValue(wxAnyValueBuffer& buf)\r
+ {\r
+ DataHolder<T>* holder = static_cast<DataHolder<T>*>(buf.m_ptr);\r
+ delete holder;\r
+ }\r
+\r
+ static void SetValue(const T& value,\r
+ wxAnyValueBuffer& buf)\r
+ {\r
+ DataHolder<T>* holder = new DataHolder<T>(value);\r
+ buf.m_ptr = holder;\r
+ }\r
+\r
+ static const T& GetValue(const wxAnyValueBuffer& buf)\r
+ {\r
+ DataHolder<T>* holder = static_cast<DataHolder<T>*>(buf.m_ptr);\r
+ return holder->m_value;\r
+ }\r
+};\r
+\r
+} // namespace wxPrivate\r
+\r
+\r
+/**\r
+ Intermediate template for the generic value type implementation.\r
+ We can derive from this same value type for multiple actual types\r
+ (for instance, we can have wxAnyValueTypeImplInt for all signed\r
+ integer types), and also easily implement specialized templates\r
+ with specific dynamic type conversion.\r
+*/\r
+template<typename T>\r
+class wxAnyValueTypeImplBase : public wxAnyValueType\r
+{\r
+ typedef typename wxIf< wxIsMovable<T>::value &&\r
+ sizeof(T) <= WX_ANY_VALUE_BUFFER_SIZE,\r
+ wxPrivate::wxAnyValueTypeOpsMovable<T>,\r
+ wxPrivate::wxAnyValueTypeOpsGeneric<T> >::value\r
+ Ops;\r
+\r
+public:\r
+ wxAnyValueTypeImplBase() : wxAnyValueType() { }\r
+ virtual ~wxAnyValueTypeImplBase() { }\r
+\r
+ virtual void DeleteValue(wxAnyValueBuffer& buf) const\r
+ {\r
+ Ops::DeleteValue(buf);\r
+ buf.m_ptr = NULL; // This is important\r
+ }\r
+\r
+ virtual void CopyBuffer(const wxAnyValueBuffer& src,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ Ops::DeleteValue(dst);\r
+ Ops::SetValue(Ops::GetValue(src), dst);\r
+ }\r
+\r
+ /**\r
+ It is important to reimplement this in any specialized template\r
+ classes that inherit from wxAnyValueTypeImplBase.\r
+ */\r
+ static void SetValue(const T& value,\r
+ wxAnyValueBuffer& buf)\r
+ {\r
+ Ops::SetValue(value, buf);\r
+ }\r
+\r
+ /**\r
+ It is important to reimplement this in any specialized template\r
+ classes that inherit from wxAnyValueTypeImplBase.\r
+ */\r
+ static const T& GetValue(const wxAnyValueBuffer& buf)\r
+ {\r
+ return Ops::GetValue(buf);\r
+ }\r
+};\r
+\r
+\r
+/*\r
+ Generic value type template. Note that bulk of the implementation\r
+ resides in wxAnyValueTypeImplBase.\r
+*/\r
+template<typename T>\r
+class wxAnyValueTypeImpl : public wxAnyValueTypeImplBase<T>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<T>)\r
+public:\r
+ wxAnyValueTypeImpl() : wxAnyValueTypeImplBase<T>() { }\r
+ virtual ~wxAnyValueTypeImpl() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ wxUnusedVar(src);\r
+ wxUnusedVar(dstType);\r
+ wxUnusedVar(dst);\r
+ return false;\r
+ }\r
+};\r
+\r
+template<typename T>\r
+wxAnyValueTypeImpl<T>* wxAnyValueTypeImpl<T>::sm_instance =\r
+ new wxAnyValueTypeImpl<T>();\r
+\r
+\r
+//\r
+// Helper macro for using same base value type implementation for multiple\r
+// actual C++ data types.\r
+//\r
+#define WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE) \\r
+template<> \\r
+class wxAnyValueTypeImpl<T> : public wxAnyValueTypeImpl##CLSTYPE \\r
+{ \\r
+ typedef wxAnyBase##CLSTYPE##Type UseDataType; \\r
+public: \\r
+ wxAnyValueTypeImpl() : wxAnyValueTypeImpl##CLSTYPE() { } \\r
+ virtual ~wxAnyValueTypeImpl() { } \\r
+ static void SetValue(const T& value, wxAnyValueBuffer& buf) \\r
+ { \\r
+ *(reinterpret_cast<UseDataType*>(&buf.m_buffer[0])) = \\r
+ static_cast<UseDataType>(value); \\r
+ } \\r
+ static T GetValue(const wxAnyValueBuffer& buf) \\r
+ { \\r
+ return static_cast<T>( \\r
+ *(reinterpret_cast<const UseDataType*>(&buf.m_buffer[0]))); \\r
+ } \\r
+};\r
+\r
+\r
+//\r
+// Integer value types\r
+//\r
+\r
+#ifdef wxLongLong_t\r
+ typedef wxLongLong_t wxAnyBaseIntType;\r
+ typedef wxULongLong_t wxAnyBaseUintType;\r
+#else\r
+ typedef long wxAnyBaseIntType;\r
+ typedef unsigned long wxAnyBaseUintType;\r
+#endif\r
+\r
+\r
+class WXDLLIMPEXP_BASE wxAnyValueTypeImplInt :\r
+ public wxAnyValueTypeImplBase<wxAnyBaseIntType>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplInt)\r
+public:\r
+ wxAnyValueTypeImplInt() :\r
+ wxAnyValueTypeImplBase<wxAnyBaseIntType>() { }\r
+ virtual ~wxAnyValueTypeImplInt() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const;\r
+};\r
+\r
+\r
+class WXDLLIMPEXP_BASE wxAnyValueTypeImplUint :\r
+ public wxAnyValueTypeImplBase<wxAnyBaseUintType>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplUint)\r
+public:\r
+ wxAnyValueTypeImplUint() :\r
+ wxAnyValueTypeImplBase<wxAnyBaseUintType>() { }\r
+ virtual ~wxAnyValueTypeImplUint() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const;\r
+};\r
+\r
+\r
+WX_ANY_DEFINE_SUB_TYPE(signed long, Int)\r
+WX_ANY_DEFINE_SUB_TYPE(signed int, Int)\r
+WX_ANY_DEFINE_SUB_TYPE(signed short, Int)\r
+WX_ANY_DEFINE_SUB_TYPE(signed char, Int)\r
+#ifdef wxLongLong_t\r
+WX_ANY_DEFINE_SUB_TYPE(wxLongLong_t, Int)\r
+#endif\r
+\r
+WX_ANY_DEFINE_SUB_TYPE(unsigned long, Uint)\r
+WX_ANY_DEFINE_SUB_TYPE(unsigned int, Uint)\r
+WX_ANY_DEFINE_SUB_TYPE(unsigned short, Uint)\r
+WX_ANY_DEFINE_SUB_TYPE(unsigned char, Uint)\r
+#ifdef wxLongLong_t\r
+WX_ANY_DEFINE_SUB_TYPE(wxULongLong_t, Uint)\r
+#endif\r
+\r
+\r
+//\r
+// String value type\r
+//\r
+class WXDLLIMPEXP_BASE wxAnyValueTypeImplString :\r
+ public wxAnyValueTypeImplBase<wxString>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplString)\r
+public:\r
+ wxAnyValueTypeImplString() :\r
+ wxAnyValueTypeImplBase<wxString>() { }\r
+ virtual ~wxAnyValueTypeImplString() { }\r
+\r
+ /**\r
+ Convert value into buffer of different type. Return false if\r
+ not possible.\r
+ */\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const;\r
+\r
+};\r
+\r
+template<>\r
+class wxAnyValueTypeImpl<wxString> : public wxAnyValueTypeImplString\r
+{\r
+public:\r
+ wxAnyValueTypeImpl() : wxAnyValueTypeImplString() { }\r
+ virtual ~wxAnyValueTypeImpl() { }\r
+};\r
+\r
+\r
+//\r
+// Bool value type\r
+//\r
+template<>\r
+class WXDLLIMPEXP_BASE wxAnyValueTypeImpl<bool> :\r
+ public wxAnyValueTypeImplBase<bool>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<bool>)\r
+public:\r
+ wxAnyValueTypeImpl() :\r
+ wxAnyValueTypeImplBase<bool>() { }\r
+ virtual ~wxAnyValueTypeImpl() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const;\r
+};\r
+\r
+//\r
+// Floating point value type\r
+//\r
+class WXDLLIMPEXP_BASE wxAnyValueTypeImplDouble :\r
+ public wxAnyValueTypeImplBase<double>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplDouble)\r
+public:\r
+ wxAnyValueTypeImplDouble() :\r
+ wxAnyValueTypeImplBase<double>() { }\r
+ virtual ~wxAnyValueTypeImplDouble() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const;\r
+};\r
+\r
+// WX_ANY_DEFINE_SUB_TYPE requires this\r
+typedef double wxAnyBaseDoubleType;\r
+\r
+WX_ANY_DEFINE_SUB_TYPE(float, Double)\r
+WX_ANY_DEFINE_SUB_TYPE(double, Double)\r
+\r
+\r
+#ifdef __VISUALC6__\r
+ // Re-enable useless VC6 warnings\r
+ #pragma warning (pop)\r
+#endif\r
+\r
+\r
+/*\r
+ Let's define a discrete Null value so we don't have to really\r
+ ever check if wxAny.m_type pointer is NULL or not. This is an\r
+ optimization, mostly. Implementation of this value type is\r
+ "hidden" in the source file.\r
+*/\r
+extern WXDLLIMPEXP_DATA_BASE(wxAnyValueType*) wxAnyNullValueType;\r
+\r
+\r
+//\r
+// We need to implement custom signed/unsigned int equals operators\r
+// for signed/unsigned (eg. wxAny(128UL) == 128L) comparisons to work.\r
+#define WXANY_IMPLEMENT_INT_EQ_OP(TS, TUS) \\r
+bool operator==(TS value) const \\r
+{ \\r
+ if ( wxAnyValueTypeImpl<TS>::IsSameClass(m_type) ) \\r
+ return (value == static_cast<TS> \\r
+ (wxAnyValueTypeImpl<TS>::GetValue(m_buffer))); \\r
+ if ( wxAnyValueTypeImpl<TUS>::IsSameClass(m_type) ) \\r
+ return (value == static_cast<TS> \\r
+ (wxAnyValueTypeImpl<TUS>::GetValue(m_buffer))); \\r
+ return false; \\r
+} \\r
+bool operator==(TUS value) const \\r
+{ \\r
+ if ( wxAnyValueTypeImpl<TUS>::IsSameClass(m_type) ) \\r
+ return (value == static_cast<TUS> \\r
+ (wxAnyValueTypeImpl<TUS>::GetValue(m_buffer))); \\r
+ if ( wxAnyValueTypeImpl<TS>::IsSameClass(m_type) ) \\r
+ return (value == static_cast<TUS> \\r
+ (wxAnyValueTypeImpl<TS>::GetValue(m_buffer))); \\r
+ return false; \\r
+}\r
+\r
+\r
+//\r
+// The wxAny class represents a container for any type. A variant's value\r
+// can be changed at run time, possibly to a different type of value.\r
+//\r
+// As standard, wxAny can store value of almost any type, in a fairly\r
+// optimal manner even.\r
+//\r
+class WXDLLIMPEXP_BASE wxAny\r
+{\r
+public:\r
+ /**\r
+ Default constructor.\r
+ */\r
+ wxAny()\r
+ {\r
+ m_type = wxAnyNullValueType;\r
+ }\r
+\r
+ /**\r
+ Destructor.\r
+ */\r
+ ~wxAny()\r
+ {\r
+ m_type->DeleteValue(m_buffer);\r
+ }\r
+\r
+ //@{\r
+ /**\r
+ Various constructors.\r
+ */\r
+ wxAny(const char* value)\r
+ {\r
+ m_type = wxAnyNullValueType;\r
+ Assign(wxString(value));\r
+ }\r
+ wxAny(const wchar_t* value)\r
+ {\r
+ m_type = wxAnyNullValueType;\r
+ Assign(wxString(value));\r
+ }\r
+\r
+ wxAny(const wxAny& any)\r
+ {\r
+ m_type = wxAnyNullValueType;\r
+ AssignAny(any);\r
+ }\r
+\r
+ template<typename T>\r
+ wxAny(const T& value)\r
+ {\r
+ m_type = wxAnyValueTypeImpl<T>::sm_instance;\r
+ wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);\r
+ }\r
+ //@}\r
+\r
+ /**\r
+ Use this template function for checking if this wxAny holds\r
+ a specific C++ data type.\r
+\r
+ @remarks This template function does not work on some older compilers\r
+ (such as Visual C++ 6.0). For full compiler ccompatibility\r
+ please use wxANY_CHECK_TYPE(any, T) macro instead.\r
+\r
+ @see wxAnyValueType::CheckType()\r
+ */\r
+ // FIXME-VC6: remove this hack when VC6 is no longer supported\r
+ template <typename T>\r
+ bool CheckType(T* = NULL)\r
+ {\r
+ return m_type->CheckType<T>();\r
+ }\r
+\r
+ /**\r
+ Returns the value type as wxAnyValueType instance.\r
+\r
+ @remarks You cannot reliably test whether two wxAnys are of\r
+ same value type by simply comparing return values\r
+ of wxAny::GetType(). Instead use\r
+ wxAnyValueType::CheckType<T>() template function.\r
+ */\r
+ const wxAnyValueType* GetType() const\r
+ {\r
+ return m_type;\r
+ }\r
+\r
+ /**\r
+ Tests if wxAny is null (that is, whether there is data).\r
+ */\r
+ bool IsNull() const\r
+ {\r
+ return (m_type == wxAnyNullValueType);\r
+ }\r
+\r
+ /**\r
+ Makes wxAny null (that is, clears it).\r
+ */\r
+ void MakeNull()\r
+ {\r
+ m_type->DeleteValue(m_buffer);\r
+ m_type = wxAnyNullValueType;\r
+ }\r
+\r
+ //@{\r
+ /**\r
+ Assignment operators.\r
+ */\r
+ wxAny& operator=(const wxAny &any)\r
+ {\r
+ AssignAny(any);\r
+ return *this;\r
+ }\r
+\r
+ template<typename T>\r
+ wxAny& operator=(const T &value)\r
+ {\r
+ m_type->DeleteValue(m_buffer);\r
+ m_type = wxAnyValueTypeImpl<T>::sm_instance;\r
+ wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);\r
+ return *this;\r
+ }\r
+\r
+ wxAny& operator=(const char* value)\r
+ { Assign(wxString(value)); return *this; }\r
+ wxAny& operator=(const wchar_t* value)\r
+ { Assign(wxString(value)); return *this; }\r
+ //@}\r
+\r
+ //@{\r
+ /**\r
+ Equality operators.\r
+ */\r
+ bool operator==(const wxString& value) const\r
+ {\r
+ if ( !wxAnyValueTypeImpl<wxString>::IsSameClass(m_type) )\r
+ return false;\r
+\r
+ return value ==\r
+ static_cast<wxString>\r
+ (wxAnyValueTypeImpl<wxString>::GetValue(m_buffer));\r
+ }\r
+\r
+ bool operator==(const char* value) const\r
+ { return (*this) == wxString(value); }\r
+ bool operator==(const wchar_t* value) const\r
+ { return (*this) == wxString(value); }\r
+\r
+ //\r
+ // We need to implement custom signed/unsigned int equals operators\r
+ // for signed/unsigned (eg. wxAny(128UL) == 128L) comparisons to work.\r
+ WXANY_IMPLEMENT_INT_EQ_OP(signed char, unsigned char)\r
+ WXANY_IMPLEMENT_INT_EQ_OP(signed short, unsigned short)\r
+ WXANY_IMPLEMENT_INT_EQ_OP(signed int, unsigned int)\r
+ WXANY_IMPLEMENT_INT_EQ_OP(signed long, unsigned long)\r
+#ifdef wxLongLong_t\r
+ WXANY_IMPLEMENT_INT_EQ_OP(wxLongLong_t, wxULongLong_t)\r
+#endif\r
+\r
+ bool operator==(float value) const\r
+ {\r
+ if ( !wxAnyValueTypeImpl<float>::IsSameClass(m_type) )\r
+ return false;\r
+\r
+ return value ==\r
+ static_cast<float>\r
+ (wxAnyValueTypeImpl<float>::GetValue(m_buffer));\r
+ }\r
+\r
+ bool operator==(double value) const\r
+ {\r
+ if ( !wxAnyValueTypeImpl<double>::IsSameClass(m_type) )\r
+ return false;\r
+\r
+ return value ==\r
+ static_cast<double>\r
+ (wxAnyValueTypeImpl<double>::GetValue(m_buffer));\r
+ }\r
+\r
+ bool operator==(bool value) const\r
+ {\r
+ if ( !wxAnyValueTypeImpl<bool>::IsSameClass(m_type) )\r
+ return false;\r
+\r
+ return value == (wxAnyValueTypeImpl<bool>::GetValue(m_buffer));\r
+ }\r
+\r
+ //@}\r
+\r
+ //@{\r
+ /**\r
+ Inequality operators (implement as template).\r
+ */\r
+ template<typename T>\r
+ bool operator!=(const T& value) const\r
+ { return !((*this) == value); }\r
+ //@}\r
+\r
+ /**\r
+ This template function converts wxAny into given type. No dynamic\r
+ conversion is performed, so if the type is incorrect an assertion\r
+ failure will occur in debug builds, and a bogus value is returned\r
+ in release ones.\r
+\r
+ @remarks This template function does not work on some older compilers\r
+ (such as Visual C++ 6.0). For full compiler ccompatibility\r
+ please use wxANY_AS(any, T) macro instead.\r
+ */\r
+ // FIXME-VC6: remove this hack when VC6 is no longer supported\r
+ template<typename T>\r
+ T As(T* = NULL) const\r
+ {\r
+ if ( !wxAnyValueTypeImpl<T>::IsSameClass(m_type) )\r
+ wxFAIL_MSG("Incorrect or non-convertible data type");\r
+ return static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(m_buffer));\r
+ }\r
+\r
+ /**\r
+ Template function that etrieves and converts the value of this\r
+ variant to the type that T* value is.\r
+\r
+ @return Returns @true if conversion was succesfull.\r
+ */\r
+ template<typename T>\r
+ bool GetAs(T* value) const\r
+ {\r
+ if ( !wxAnyValueTypeImpl<T>::IsSameClass(m_type) )\r
+ {\r
+ wxAnyValueType* otherType =\r
+ wxAnyValueTypeImpl<T>::sm_instance;\r
+ wxAnyValueBuffer temp_buf;\r
+\r
+ if ( !m_type->ConvertValue(m_buffer, otherType, temp_buf) )\r
+ return false;\r
+\r
+ *value =\r
+ static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(temp_buf));\r
+ otherType->DeleteValue(temp_buf);\r
+\r
+ return true;\r
+ }\r
+ *value = static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(m_buffer));\r
+ return true;\r
+ }\r
+\r
+private:\r
+ // Assignment functions\r
+ void AssignAny(const wxAny &any);\r
+\r
+ template<typename T>\r
+ void Assign(const T &value)\r
+ {\r
+ m_type->DeleteValue(m_buffer);\r
+ m_type = wxAnyValueTypeImpl<T>::sm_instance;\r
+ wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);\r
+ }\r
+\r
+ // Data\r
+ wxAnyValueType* m_type;\r
+ wxAnyValueBuffer m_buffer;\r
+};\r
+\r
+\r
+//\r
+// This method of checking the type is compatible with VC6\r
+#define wxANY_CHECK_TYPE(any, T) \\r
+ wxANY_VALUE_TYPE_CHECK_TYPE(any.GetType(), T)\r
+\r
+\r
+//\r
+// This method of getting the value is compatible with VC6\r
+#define wxANY_AS(any, T) \\r
+ any.As(static_cast<T*>(NULL))\r
+\r
+\r
+template<typename T>\r
+inline bool wxAnyValueType::CheckType(T* reserved)\r
+{\r
+ wxUnusedVar(reserved);\r
+ return wxAnyValueTypeImpl<T>::IsSameClass(this);\r
+}\r
+\r
+\r
+\r
+#endif // wxUSE_ANY\r
+\r
+#endif // _WX_ANY_H_\r
please keep the options in alphabetical order!
*/
+#ifndef wxUSE_ANY
+# ifdef wxABORT_ON_CONFIG_ERROR
+# error "wxUSE_ANY must be defined."
+# else
+# define wxUSE_ANY 0
+# endif
+#endif /* wxUSE_ANY */
+
#ifndef wxUSE_CONSOLE_EVENTLOOP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_CONSOLE_EVENTLOOP must be defined."
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
+// Support for wxAny class, the successor for wxVariant.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you want to reduce the library size by a small amount,
+// or your compiler cannot for some reason cope with complexity of templates used.
+#define wxUSE_ANY 1
+
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////\r
+// Name: any.h\r
+// Purpose: interface of wxAny\r
+// Author: wxWidgets team\r
+// RCS-ID: $Id$\r
+// Licence: wxWindows license\r
+/////////////////////////////////////////////////////////////////////////////\r
+\r
+\r
+/**\r
+ @class wxAny\r
+\r
+ The wxAny class represents a container for any type. Its value\r
+ can be changed at run time, possibly to a different type of value.\r
+\r
+ wxAny is successor class for wxVariant, essentially doing the same thing\r
+ in a more modern, template-based manner and with transparent support\r
+ for any user data type.\r
+\r
+ Some pseudo-code'ish example of use with arbitrary user data:\r
+\r
+ @code\r
+ void SomeFunction()\r
+ {\r
+ MyClass myObject;\r
+ wxAny any = myObject;\r
+\r
+ // Do something\r
+ // ...\r
+\r
+ // Let's do a sanity check to make sure that any still holds\r
+ // data of correct type.\r
+ if ( any.CheckType<MyClass>() )\r
+ {\r
+ // Thank goodness, still a correct type.\r
+ MyClass myObject2 = any.As<MyClass>();\r
+ }\r
+ else\r
+ {\r
+ // Something has gone horribly wrong!\r
+ wxFAIL();\r
+ }\r
+ }\r
+ @endcode\r
+\r
+ When compared to wxVariant, there are various internal implementation\r
+ differences as well. For instance, wxAny only allocates separate data\r
+ object in heap for large (ie. size in bytes more than\r
+ WX_ANY_VALUE_BUFFER_SIZE) or 'non-movable' data types. Pointers, integers,\r
+ bools etc. are fitted in the wxAny's own buffer without need for any extra\r
+ allocation. Use following code to declare your own data type as 'movable':\r
+\r
+ @code\r
+ #include "wx/meta/movable.h"\r
+ WX_DECLARE_TYPE_MOVABLE(MyClass)\r
+ @endcode\r
+\r
+ However, you must be aware that 'movable' means such data that can be\r
+ copied with memcpy() without corrupting program integrity. For instance,\r
+ movable objects usually cannot contain pointers or references to other\r
+ data. wxRect, wxPoint, and wxSize are good examples of movable classes.\r
+\r
+ Note that pointers to any and all classes are already automatically\r
+ declared as movable data.\r
+\r
+ @library{wxbase}\r
+ @category{data}\r
+\r
+ @see wxAnyValueType, wxVariant\r
+*/\r
+class wxAny\r
+{\r
+public:\r
+ /**\r
+ Default constructor. It seeds the object with a null value.\r
+ */\r
+ wxAny();\r
+\r
+ /**\r
+ Constructs wxAny from data.\r
+ */\r
+ template<typename T>\r
+ wxAny(const T& value);\r
+\r
+ /**\r
+ Constructs wxAny from another wxAny.\r
+ */\r
+ wxAny(const wxAny& any);\r
+\r
+ /**\r
+ Destructor.\r
+ */\r
+ ~wxAny();\r
+\r
+ /**\r
+ This template function converts wxAny into given type. No dynamic\r
+ conversion is performed, so if the type is incorrect an assertion\r
+ failure will occur in debug builds, and a bogus value is returned\r
+ in release ones.\r
+\r
+ @remarks This template function may not work properly with Visual C++\r
+ 6. For full compiler compatibility, please use\r
+ wxANY_AS(any, T) macro instead.\r
+ */\r
+ template<typename T>\r
+ T As() const;\r
+\r
+ /**\r
+ Use this template function for checking if this wxAny holds\r
+ a specific C++ data type.\r
+\r
+ @remarks This template function may not work properly with Visual C++\r
+ 6. For full compiler compatibility, please use\r
+ wxANY_CHECK_TYPE(any, T) macro instead.\r
+\r
+ @see wxAnyValueType::CheckType()\r
+ */\r
+ template<typename T>\r
+ bool CheckType();\r
+\r
+ /**\r
+ Template function that retrieves and converts the value of this\r
+ wxAny to the type that T* value is.\r
+\r
+ @return Returns @true if conversion was succesfull.\r
+ */\r
+ template<typename T>\r
+ bool GetAs(T* value) const;\r
+\r
+ /**\r
+ Returns the value type as wxAnyValueType instance.\r
+\r
+ @remarks You cannot reliably test whether two wxAnys are of\r
+ same value type by simply comparing return values\r
+ of wxAny::GetType(). Instead use\r
+ wxAnyValueType::CheckType<T>() template function.\r
+ */\r
+ const wxAnyValueType* GetType() const;\r
+\r
+ /**\r
+ Tests if wxAny is null (that is, whether there is data).\r
+ */\r
+ bool IsNull() const;\r
+\r
+ /**\r
+ Makes wxAny null (that is, clears it).\r
+ */\r
+ void MakeNull();\r
+\r
+ //@{\r
+ /**\r
+ @name Assignment operators\r
+ */\r
+ template<typename T>\r
+ wxAny& operator=(const T &value);\r
+ wxAny& operator=(const wxAny &any);\r
+ //@}\r
+\r
+ //@{\r
+ /**\r
+ @name Equality operators\r
+\r
+ @remarks Generic template-based comparison operators have not been\r
+ provided for various code consistency reasons, so for custom\r
+ data types you have do something like this:\r
+\r
+ @code\r
+ if ( any.CheckType<MyClass*>() &&\r
+ any.As<MyClass*>() == myObjectPtr )\r
+ {\r
+ // Do something if any stores myObjectPtr\r
+ }\r
+ @endcode\r
+ */\r
+ bool operator==(signed char value) const;\r
+ bool operator==(signed short value) const;\r
+ bool operator==(signed int value) const;\r
+ bool operator==(signed long value) const;\r
+ bool operator==(wxLongLong_t value) const;\r
+ bool operator==(unsigned char value) const;\r
+ bool operator==(unsigned short value) const;\r
+ bool operator==(unsigned int value) const;\r
+ bool operator==(unsigned long value) const;\r
+ bool operator==(wxULongLong_t value) const;\r
+ bool operator==(float value) const;\r
+ bool operator==(double value) const;\r
+ bool operator==(bool value) const;\r
+ bool operator==(const char* value) const;\r
+ bool operator==(const wchar_t* value) const;\r
+ bool operator==(const wxString& value) const;\r
+ //@}\r
+\r
+ //@{\r
+ /**\r
+ @name Inequality operators\r
+ */\r
+ bool operator!=(signed char value) const;\r
+ bool operator!=(signed short value) const;\r
+ bool operator!=(signed int value) const;\r
+ bool operator!=(signed long value) const;\r
+ bool operator!=(wxLongLong_t value) const;\r
+ bool operator!=(unsigned char value) const;\r
+ bool operator!=(unsigned short value) const;\r
+ bool operator!=(unsigned int value) const;\r
+ bool operator!=(unsigned long value) const;\r
+ bool operator!=(wxULongLong_t value) const;\r
+ bool operator!=(float value) const;\r
+ bool operator!=(double value) const;\r
+ bool operator!=(bool value) const;\r
+ bool operator!=(const char* value) const;\r
+ bool operator!=(const wchar_t* value) const;\r
+ bool operator!=(const wxString& value) const;\r
+ //@}\r
+};\r
+\r
+/**\r
+ This is value getter macro that is more compatible with older\r
+ compilers, such as Visual C++ 6.0.\r
+*/\r
+#define wxANY_AS(any, T)\r
+\r
+\r
+/**\r
+ This is type checking macro that is more compatible with older\r
+ compilers, such as Visual C++ 6.0.\r
+*/\r
+#define wxANY_CHECK_TYPE(any, T)\r
+\r
+\r
+/**\r
+ Size of the wxAny value buffer.\r
+*/\r
+enum\r
+{\r
+ WX_ANY_VALUE_BUFFER_SIZE = 16\r
+};\r
+\r
+/**\r
+ Type for buffer within wxAny for holding data.\r
+*/\r
+union wxAnyValueBuffer\r
+{\r
+ void* m_ptr;\r
+ wxByte m_buffer[WX_ANY_VALUE_BUFFER_SIZE];\r
+};\r
+\r
+\r
+/**\r
+ @class wxAnyValueType\r
+\r
+ wxAnyValueType is base class for value type functionality for C++ data\r
+ types used with wxAny. Usually the default template will create a\r
+ satisfactory wxAnyValueType implementation for a data type, but\r
+ sometimes you may need to add some customization. To do this you will need\r
+ to add specialized template of wxAnyValueTypeImpl<>. Often your only\r
+ need may be to add dynamic type conversion which would be done like\r
+ this:\r
+\r
+ @code\r
+ template<>\r
+ class wxAnyValueTypeImpl<MyClass> :\r
+ public wxAnyValueTypeImplBase<MyClass>\r
+ {\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)\r
+ public:\r
+ wxAnyValueTypeImpl() :\r
+ wxAnyValueTypeImplBase<MyClass>() { }\r
+ virtual ~wxAnyValueTypeImpl() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ // GetValue() is a static member function implemented\r
+ // in wxAnyValueTypeImplBase<>.\r
+ MyClass value = GetValue(src);\r
+\r
+ // TODO: Convert value from src buffer to destination\r
+ // type and buffer. If cannot be done, return\r
+ // false. This is a simple sample.\r
+ if ( dstType->CheckType<wxString>() )\r
+ {\r
+ wxString s = value.ToString();\r
+ wxAnyValueTypeImpl<wxString>::SetValue(s, dst);\r
+ }\r
+ else\r
+ {\r
+ return false;\r
+ }\r
+ }\r
+ };\r
+\r
+ //\r
+ // Following must be placed somewhere in your source code\r
+ WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)\r
+ @endcode\r
+\r
+ wxAnyValueTypeImplBase<> template, from which we inherit in the above\r
+ example, contains the bulk of the default wxAnyValueTypeImpl<> template\r
+ implementation, and as such allows you to easily add some minor\r
+ customization.\r
+\r
+ If you need a have complete control over the type interpretation, you\r
+ will need to derive a class directly from wxAnyValueType, like this:\r
+\r
+ @code\r
+ template <>\r
+ class wxAnyValueTypeImpl<MyClass> : public wxAnyValueType\r
+ {\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)\r
+ public:\r
+ virtual void DeleteValue(wxAnyValueBuffer& buf) const\r
+ {\r
+ // TODO: Free the data in buffer\r
+ // It is important to clear the buffer like this\r
+ // at the end of DeleteValue().\r
+ buf.m_ptr = NULL;\r
+ }\r
+\r
+ virtual void CopyBuffer(const wxAnyValueBuffer& src,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ // TODO: Copy value from one buffer to another.\r
+ }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ // TODO: Convert value from src buffer to destination\r
+ // type and buffer.\r
+ }\r
+\r
+ //\r
+ // Following static functions must be implemented\r
+ //\r
+\r
+ static void SetValue(const T& value,\r
+ wxAnyValueBuffer& buf)\r
+ {\r
+ // TODO: Store value into buf.\r
+ }\r
+\r
+ static const T& GetValue(const wxAnyValueBuffer& buf)\r
+ {\r
+ // TODO: Return reference to value stored in buffer.\r
+ }\r
+ };\r
+\r
+ //\r
+ // Following must be placed somewhere in your source code\r
+ WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)\r
+\r
+ @endcode\r
+\r
+ @library{wxbase}\r
+ @category{data}\r
+\r
+ @see wxAny\r
+*/\r
+class wxAnyValueType\r
+{\r
+public:\r
+ /**\r
+ Default constructor.\r
+ */\r
+ wxAnyValueType();\r
+\r
+ /**\r
+ Destructor.\r
+ */\r
+ virtual ~wxAnyValueType();\r
+\r
+ /**\r
+ Use this template function for checking if wxAnyValueType represents\r
+ a specific C++ data type.\r
+\r
+ @remarks This template function does not work on some older compilers\r
+ (such as Visual C++ 6.0). For full compiler ccompatibility\r
+ please use wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) macro\r
+ instead.\r
+\r
+ @see wxAny::CheckType()\r
+ */\r
+ template <typename T>\r
+ bool CheckType();\r
+\r
+ /**\r
+ Convert value into buffer of different type. Return false if\r
+ not possible.\r
+ */\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const = 0;\r
+\r
+ /**\r
+ Implement this for buffer-to-buffer copy. src.m_ptr can\r
+ be expected to be NULL if value type of previously stored\r
+ data was different.\r
+ */\r
+ virtual void CopyBuffer(const wxAnyValueBuffer& src,\r
+ wxAnyValueBuffer& dst) const = 0;\r
+\r
+ /**\r
+ This function is called every time the data in wxAny\r
+ buffer needs to be freed.\r
+ */\r
+ virtual void DeleteValue(wxAnyValueBuffer& buf) const = 0;\r
+\r
+ /**\r
+ This function is used for internal type matching.\r
+ */\r
+ virtual wxAnyClassInfo GetClassInfo() const = 0;\r
+\r
+ /**\r
+ This function is used for internal type matching.\r
+ */\r
+ virtual bool IsSameType(const wxAnyValueType* otherType) const = 0;\r
+};\r
+\r
+/**\r
+ This is type checking macro that is more compatible with older\r
+ compilers, such as Visual C++ 6.0.\r
+*/\r
+#define wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T)\r
#define wxUSE_VARIANT 0
+#define wxUSE_ANY 0
+
#define wxUSE_REGEX 0
#define wxUSE_SYSTEM_OPTIONS 0
#define wxUSE_VARIANT 1
+#define wxUSE_ANY 1
+
#define wxUSE_REGEX 0
#define wxUSE_SYSTEM_OPTIONS 1
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////\r
+// Name: src/common/any.cpp\r
+// Purpose: wxAny class, container for any type\r
+// Author: Jaakko Salli\r
+// Modified by:\r
+// Created: 07/05/2009\r
+// RCS-ID: $Id$\r
+// Copyright: (c) wxWidgets team\r
+// Licence: wxWindows licence\r
+/////////////////////////////////////////////////////////////////////////////\r
+\r
+// For compilers that support precompilation, includes "wx/wx.h".\r
+#include "wx/wxprec.h"\r
+\r
+#ifdef __BORLANDC__\r
+ #pragma hdrstop\r
+#endif\r
+\r
+#include "wx/any.h"\r
+\r
+#if wxUSE_ANY\r
+\r
+#ifndef WX_PRECOMP\r
+ #include "wx/math.h"\r
+ #include "wx/crt.h"\r
+#endif\r
+\r
+#include "wx/vector.h"\r
+#include "wx/module.h"\r
+\r
+using namespace wxPrivate;\r
+\r
+//-------------------------------------------------------------------------\r
+// wxAnyValueTypeGlobals\r
+//-------------------------------------------------------------------------\r
+\r
+//\r
+// Helper class to manage wxAnyValueType instances and other\r
+// related global variables.\r
+//\r
+// NB: We really need to have wxAnyValueType instances allocated\r
+// in heap. They are stored as static template member variables,\r
+// and with them we just can't be too careful (eg. not allocating\r
+// them in heap broke the type identification in GCC).\r
+//\r
+class wxAnyValueTypeGlobals\r
+{\r
+public:\r
+ wxAnyValueTypeGlobals()\r
+ {\r
+ }\r
+ ~wxAnyValueTypeGlobals()\r
+ {\r
+ for ( size_t i=0; i<m_valueTypes.size(); i++ )\r
+ delete m_valueTypes[i];\r
+ }\r
+\r
+ void RegisterValueType(wxAnyValueType* valueType)\r
+ {\r
+ m_valueTypes.push_back(valueType);\r
+ }\r
+\r
+private:\r
+ wxVector<wxAnyValueType*> m_valueTypes;\r
+};\r
+\r
+static wxAnyValueTypeGlobals* g_wxAnyValueTypeGlobals = NULL;\r
+\r
+//\r
+// This class is to make sure that wxAnyValueType instances\r
+// etc. get freed correctly. We must use a separate wxAnyValueTypeGlobals\r
+// because wxModule itself is instantiated too late.\r
+//\r
+class wxAnyValueTypeGlobalsManager : public wxModule\r
+{\r
+ DECLARE_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager)\r
+public:\r
+ wxAnyValueTypeGlobalsManager() : wxModule() { }\r
+ virtual ~wxAnyValueTypeGlobalsManager() { }\r
+\r
+ virtual bool OnInit()\r
+ {\r
+ return true;\r
+ }\r
+ virtual void OnExit()\r
+ {\r
+ delete g_wxAnyValueTypeGlobals;\r
+ g_wxAnyValueTypeGlobals = NULL;\r
+ }\r
+private:\r
+};\r
+\r
+IMPLEMENT_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager, wxModule)\r
+\r
+\r
+//-------------------------------------------------------------------------\r
+// wxAnyValueType\r
+//-------------------------------------------------------------------------\r
+\r
+wxAnyValueType::wxAnyValueType()\r
+{\r
+ if ( !g_wxAnyValueTypeGlobals )\r
+ g_wxAnyValueTypeGlobals = new wxAnyValueTypeGlobals();\r
+\r
+ g_wxAnyValueTypeGlobals->RegisterValueType(this);\r
+}\r
+\r
+//-------------------------------------------------------------------------\r
+// wxAny\r
+//-------------------------------------------------------------------------\r
+\r
+void wxAny::AssignAny(const wxAny &any)\r
+{\r
+ if ( !any.m_type->IsSameType(m_type) )\r
+ {\r
+ m_type->DeleteValue(m_buffer);\r
+ m_type = any.m_type;\r
+ }\r
+ m_type->CopyBuffer(any.m_buffer, m_buffer);\r
+}\r
+\r
+//-------------------------------------------------------------------------\r
+// Dynamic conversion member functions\r
+//-------------------------------------------------------------------------\r
+\r
+//\r
+// Define integer minimum and maximum as helpers\r
+#ifdef wxLongLong_t\r
+const wxAnyBaseIntType UseIntMin = wxINT64_MIN;\r
+const wxAnyBaseUintType UseIntMax = wxINT64_MAX;\r
+const wxAnyBaseUintType UseUintMax = wxUINT64_MAX;\r
+#else\r
+const wxAnyBaseIntType UseIntMin = LONG_MIN;\r
+const wxAnyBaseUintType UseUintMax = ULONG_MAX;\r
+const wxAnyBaseUintType UseIntMax = LONG_MAX;\r
+#endif\r
+\r
+const double UseIntMinF = static_cast<double>(UseIntMin);\r
+#ifndef __VISUALC6__\r
+const double UseIntMaxF = static_cast<double>(UseIntMax);\r
+const double UseUintMaxF = static_cast<double>(UseUintMax);\r
+#else\r
+// VC6 doesn't implement conversion from unsigned __int64 to double\r
+const wxAnyBaseIntType UseIntMax0 = static_cast<wxAnyBaseIntType>(UseIntMax);\r
+const wxAnyBaseIntType UseUintMax0 = static_cast<wxAnyBaseIntType>(UseUintMax);\r
+const double UseIntMaxF = static_cast<double>(UseIntMax0);\r
+const double UseUintMaxF = static_cast<double>(UseUintMax0);\r
+#endif\r
+\r
+\r
+bool wxAnyValueTypeImplInt::ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+{\r
+ wxAnyBaseIntType value = GetValue(src);\r
+ if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )\r
+ {\r
+#ifdef wxLongLong_t\r
+ wxLongLong ll(value);\r
+ wxString s = ll.ToString();\r
+#else\r
+ wxString s = wxString::Format(wxS("%ld"), (long)value);\r
+#endif\r
+ wxAnyValueTypeImpl<wxString>::SetValue(s, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )\r
+ {\r
+ if ( value < 0 )\r
+ return false;\r
+ wxAnyBaseUintType ul = (wxAnyBaseUintType) value;\r
+ wxAnyValueTypeImplUint::SetValue(ul, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )\r
+ {\r
+ double value2 = static_cast<double>(value);\r
+ wxAnyValueTypeImplDouble::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )\r
+ {\r
+ bool value2 = value ? true : false;\r
+ wxAnyValueTypeImpl<bool>::SetValue(value2, dst);\r
+ }\r
+ else\r
+ return false;\r
+\r
+ return true;\r
+}\r
+\r
+bool wxAnyValueTypeImplUint::ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+{\r
+ wxAnyBaseUintType value = GetValue(src);\r
+ if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )\r
+ {\r
+#ifdef wxLongLong_t\r
+ wxULongLong ull(value);\r
+ wxString s = ull.ToString();\r
+#else\r
+ wxString s = wxString::Format(wxS("%lu"), (long)value);\r
+#endif\r
+ wxAnyValueTypeImpl<wxString>::SetValue(s, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )\r
+ {\r
+ if ( value > UseIntMax )\r
+ return false;\r
+ wxAnyBaseIntType l = (wxAnyBaseIntType) value;\r
+ wxAnyValueTypeImplInt::SetValue(l, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )\r
+ {\r
+#ifndef __VISUALC6__\r
+ double value2 = static_cast<double>(value);\r
+#else\r
+ // VC6 doesn't implement conversion from unsigned __int64 to double\r
+ wxAnyBaseIntType value0 = static_cast<wxAnyBaseIntType>(value);\r
+ double value2 = static_cast<double>(value0);\r
+#endif\r
+ wxAnyValueTypeImplDouble::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )\r
+ {\r
+ bool value2 = value ? true : false;\r
+ wxAnyValueTypeImpl<bool>::SetValue(value2, dst);\r
+ }\r
+ else\r
+ return false;\r
+\r
+ return true;\r
+}\r
+\r
+bool wxAnyValueTypeImplString::ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+{\r
+ wxString value = GetValue(src);\r
+ if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )\r
+ {\r
+ wxAnyBaseIntType value2;\r
+#ifdef wxLongLong_t\r
+ if ( !value.ToLongLong(&value2) )\r
+#else\r
+ if ( !value.ToLong(&value2) )\r
+#endif\r
+ return false;\r
+ wxAnyValueTypeImplInt::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )\r
+ {\r
+ wxAnyBaseUintType value2;\r
+#ifdef wxLongLong_t\r
+ if ( !value.ToULongLong(&value2) )\r
+#else\r
+ if ( !value.ToULong(&value2) )\r
+#endif\r
+ return false;\r
+ wxAnyValueTypeImplUint::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )\r
+ {\r
+ double value2;\r
+ if ( !value.ToDouble(&value2) )\r
+ return false;\r
+ wxAnyValueTypeImplDouble::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )\r
+ {\r
+ bool value2;\r
+ value.MakeLower();\r
+ if ( value == wxS("true") ||\r
+ value == wxS("yes") ||\r
+ value == wxS('1') )\r
+ value2 = true;\r
+ else if ( value == wxS("false") ||\r
+ value == wxS("no") ||\r
+ value == wxS('0') )\r
+ value2 = false;\r
+ else\r
+ return false;\r
+\r
+ wxAnyValueTypeImpl<bool>::SetValue(value2, dst);\r
+ }\r
+ else\r
+ return false;\r
+\r
+ return true;\r
+}\r
+\r
+bool wxAnyValueTypeImpl<bool>::ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+{\r
+ bool value = GetValue(src);\r
+ if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )\r
+ {\r
+ wxAnyBaseIntType value2 = static_cast<wxAnyBaseIntType>(value);\r
+ wxAnyValueTypeImplInt::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )\r
+ {\r
+ wxAnyBaseIntType value2 = static_cast<wxAnyBaseUintType>(value);\r
+ wxAnyValueTypeImplUint::SetValue(value2, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )\r
+ {\r
+ wxString s;\r
+ if ( value )\r
+ s = wxS("true");\r
+ else\r
+ s = wxS("false");\r
+ wxAnyValueTypeImpl<wxString>::SetValue(s, dst);\r
+ }\r
+ else\r
+ return false;\r
+\r
+ return true;\r
+}\r
+\r
+bool wxAnyValueTypeImplDouble::ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+{\r
+ double value = GetValue(src);\r
+ if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )\r
+ {\r
+ if ( value < UseIntMinF || value > UseIntMaxF )\r
+ return false;\r
+ wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);\r
+ wxAnyValueTypeImplUint::SetValue(ul, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )\r
+ {\r
+ if ( value < 0.0 || value > UseUintMaxF )\r
+ return false;\r
+ wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);\r
+ wxAnyValueTypeImplUint::SetValue(ul, dst);\r
+ }\r
+ else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )\r
+ {\r
+ wxString s = wxString::Format(wxS("%.14g"), value);\r
+ wxAnyValueTypeImpl<wxString>::SetValue(s, dst);\r
+ }\r
+ else\r
+ return false;\r
+\r
+ return true;\r
+}\r
+\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplInt)\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplUint)\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplString)\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<bool>)\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplDouble)\r
+\r
+//-------------------------------------------------------------------------\r
+// wxAnyNullValueType implementation\r
+//-------------------------------------------------------------------------\r
+\r
+class wxAnyNullValue\r
+{\r
+private:\r
+ void* m_dummy;\r
+};\r
+\r
+template <>\r
+class wxAnyValueTypeImpl<wxAnyNullValue> : public wxAnyValueType\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)\r
+public:\r
+ virtual void DeleteValue(wxAnyValueBuffer& buf) const\r
+ {\r
+ buf.m_ptr = NULL; // This is important\r
+ }\r
+\r
+ // Dummy implementations\r
+ virtual void CopyBuffer(const wxAnyValueBuffer& src,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ wxUnusedVar(src);\r
+ wxUnusedVar(dst);\r
+ }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ wxUnusedVar(src);\r
+ wxUnusedVar(dstType);\r
+ wxUnusedVar(dst);\r
+ return false;\r
+ }\r
+\r
+private:\r
+};\r
+\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)\r
+\r
+wxAnyValueType* wxAnyNullValueType =\r
+ wxAnyValueTypeImpl<wxAnyNullValue>::GetInstance();\r
+\r
+#endif // wxUSE_ANY\r
listctrlcmn.obj,socketiohandler.obj,fdiodispatcher.obj,\
selectdispatcher.obj,overlaycmn.obj,windowid.obj,sstream.obj,\
wrapsizer.obj,headerctrlcmn.obj,headercolcmn.obj,\
- rearrangectrl.obj,spinctrlcmn.obj,datetimefmt.obj,xlocale.obj
+ rearrangectrl.obj,spinctrlcmn.obj,datetimefmt.obj,xlocale.obj,\
+ any.obj
OBJECTS_MOTIF=radiocmn.obj,combocmn.obj
accelcmn.cpp,\
anidecod.cpp,\
animatecmn.cpp,\
+ any.cpp,\
appbase.cpp,\
appcmn.cpp,\
arrstr.cpp,\
accelcmn.obj : accelcmn.cpp
anidecod.obj : anidecod.cpp
animatecmn.obj : animatecmn.cpp
+any.obj : any.cpp
appbase.obj : appbase.cpp
appcmn.obj : appcmn.cpp
arrstr.obj : arrstr.cpp
$(CPPUNIT_CFLAGS) $(CXXWARNINGS) $(CPPFLAGS) $(CXXFLAGS)
TEST_OBJECTS = \
test_test.o \
+ test_anytest.o \
test_archivetest.o \
test_ziptest.o \
test_tartest.o \
test_test.o: $(srcdir)/test.cpp $(TEST_ODEP)
$(CXXC) -c -o $@ $(TEST_CXXFLAGS) $(srcdir)/test.cpp
+test_anytest.o: $(srcdir)/any/anytest.cpp $(TEST_ODEP)
+ $(CXXC) -c -o $@ $(TEST_CXXFLAGS) $(srcdir)/any/anytest.cpp
+
test_archivetest.o: $(srcdir)/archive/archivetest.cpp $(TEST_ODEP)
$(CXXC) -c -o $@ $(TEST_CXXFLAGS) $(srcdir)/archive/archivetest.cpp
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////\r
+// Name: tests/any/anytest.cpp\r
+// Purpose: Test the wxAny classes\r
+// Author: Jaakko Salli\r
+// RCS-ID: $Id$\r
+// Copyright: (c) the wxWidgets team\r
+// Licence: wxWindows licence\r
+///////////////////////////////////////////////////////////////////////////////\r
+\r
+#include "testprec.h"\r
+\r
+#ifdef __BORLANDC__\r
+# pragma hdrstop\r
+#endif\r
+\r
+#if wxUSE_ANY\r
+\r
+#include "wx/any.h"\r
+#include "wx/datetime.h"\r
+\r
+#include <math.h>\r
+\r
+// ----------------------------------------------------------------------------\r
+// test class\r
+// ----------------------------------------------------------------------------\r
+\r
+class wxAnyTestCase : public CppUnit::TestCase\r
+{\r
+public:\r
+ wxAnyTestCase();\r
+\r
+private:\r
+ CPPUNIT_TEST_SUITE( wxAnyTestCase );\r
+ CPPUNIT_TEST( Equality );\r
+ CPPUNIT_TEST( As );\r
+ CPPUNIT_TEST( GetAs );\r
+ CPPUNIT_TEST( Null );\r
+ CPPUNIT_TEST( CustomTemplateSpecialization );\r
+ CPPUNIT_TEST_SUITE_END();\r
+\r
+ void Equality();\r
+ void As();\r
+ void GetAs();\r
+ void Null();\r
+ void CustomTemplateSpecialization();\r
+\r
+ wxDateTime m_testDateTime;\r
+\r
+ wxAny m_anySignedChar1;\r
+ wxAny m_anySignedShort1;\r
+ wxAny m_anySignedInt1;\r
+ wxAny m_anySignedLong1;\r
+ wxAny m_anySignedLongLong1;\r
+ wxAny m_anyUnsignedChar1;\r
+ wxAny m_anyUnsignedShort1;\r
+ wxAny m_anyUnsignedInt1;\r
+ wxAny m_anyUnsignedLong1;\r
+ wxAny m_anyUnsignedLongLong1;\r
+ wxAny m_anyStringString1;\r
+ wxAny m_anyCharString1;\r
+ wxAny m_anyWcharString1;\r
+ wxAny m_anyBool1;\r
+ wxAny m_anyFloatDouble1;\r
+ wxAny m_anyDoubleDouble1;\r
+ wxAny m_anyWxObjectPtr1;\r
+ wxAny m_anyVoidPtr1;\r
+ wxAny m_anyDateTime1;\r
+\r
+ wxAny m_anySignedChar2;\r
+ wxAny m_anySignedShort2;\r
+ wxAny m_anySignedInt2;\r
+ wxAny m_anySignedLong2;\r
+ wxAny m_anySignedLongLong2;\r
+ wxAny m_anyUnsignedChar2;\r
+ wxAny m_anyUnsignedShort2;\r
+ wxAny m_anyUnsignedInt2;\r
+ wxAny m_anyUnsignedLong2;\r
+ wxAny m_anyUnsignedLongLong2;\r
+ wxAny m_anyStringString2;\r
+ wxAny m_anyCharString2;\r
+ wxAny m_anyWcharString2;\r
+ wxAny m_anyBool2;\r
+ wxAny m_anyFloatDouble2;\r
+ wxAny m_anyDoubleDouble2;\r
+ wxAny m_anyWxObjectPtr2;\r
+ wxAny m_anyVoidPtr2;\r
+ wxAny m_anyDateTime2;\r
+\r
+ DECLARE_NO_COPY_CLASS(wxAnyTestCase)\r
+};\r
+\r
+// register in the unnamed registry so that these tests are run by default\r
+CPPUNIT_TEST_SUITE_REGISTRATION( wxAnyTestCase );\r
+\r
+// also include in it's own registry so that these tests can be run alone\r
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( wxAnyTestCase, "wxAnyTestCase" );\r
+\r
+// Let's use a number with first digit after decimal dot less than 5,\r
+// so that we don't have to worry about whether conversion from float\r
+// to int truncates or rounds.\r
+const double TEST_FLOAT_CONST = 123.456;\r
+\r
+const double FEQ_DELTA = 0.001;\r
+\r
+wxObject* dummyWxObjectPointer = reinterpret_cast<wxObject*>(1234);\r
+void* dummyVoidPointer = reinterpret_cast<void*>(1234);\r
+\r
+\r
+//\r
+// Test both 'creation' methods\r
+wxAnyTestCase::wxAnyTestCase()\r
+ : m_anySignedChar1((signed char)15),\r
+ m_anySignedShort1((signed short)15),\r
+ m_anySignedInt1((signed int)15),\r
+ m_anySignedLong1((signed long)15),\r
+#ifdef wxLongLong_t\r
+ m_anySignedLongLong1((wxLongLong_t)15),\r
+#endif\r
+ m_anyUnsignedChar1((unsigned char)15),\r
+ m_anyUnsignedShort1((unsigned short)15),\r
+ m_anyUnsignedInt1((unsigned int)15),\r
+ m_anyUnsignedLong1((unsigned long)15),\r
+#ifdef wxLongLong_t\r
+ m_anyUnsignedLongLong1((wxULongLong_t)15),\r
+#endif\r
+ m_anyStringString1(wxString("abc")),\r
+ m_anyCharString1("abc"),\r
+ m_anyWcharString1(L"abc"),\r
+ m_anyBool1(true),\r
+ m_anyFloatDouble1((float)TEST_FLOAT_CONST),\r
+ m_anyDoubleDouble1((double)TEST_FLOAT_CONST),\r
+ m_anyWxObjectPtr1(dummyWxObjectPointer),\r
+ m_anyVoidPtr1(dummyVoidPointer),\r
+ m_anyDateTime1(wxDateTime::Now())\r
+{\r
+ m_testDateTime = wxDateTime::Now();\r
+ m_anySignedChar2 = (signed char)15;\r
+ m_anySignedShort2 = (signed short)15;\r
+ m_anySignedInt2 = (signed int)15;\r
+ m_anySignedLong2 = (signed long)15;\r
+#ifdef wxLongLong_t\r
+ m_anySignedLongLong2 = (wxLongLong_t)15;\r
+#endif\r
+ m_anyUnsignedChar2 = (unsigned char)15;\r
+ m_anyUnsignedShort2 = (unsigned short)15;\r
+ m_anyUnsignedInt2 = (unsigned int)15;\r
+ m_anyUnsignedLong2 = (unsigned long)15;\r
+#ifdef wxLongLong_t\r
+ m_anyUnsignedLongLong2 = (wxULongLong_t)15;\r
+#endif\r
+ m_anyStringString2 = wxString("abc");\r
+ m_anyCharString2 = "abc";\r
+ m_anyWcharString2 = L"abc";\r
+ m_anyBool2 = true;\r
+ m_anyFloatDouble2 = (float)TEST_FLOAT_CONST;\r
+ m_anyDoubleDouble2 = (double)TEST_FLOAT_CONST;\r
+ m_anyDateTime2 = m_testDateTime;\r
+ m_anyWxObjectPtr2 = dummyWxObjectPointer;\r
+ m_anyVoidPtr2 = dummyVoidPointer;\r
+}\r
+\r
+void wxAnyTestCase::Equality()\r
+{\r
+ //\r
+ // Currently this should work\r
+ CPPUNIT_ASSERT(m_anyUnsignedLong1 == 15L);\r
+ CPPUNIT_ASSERT(m_anyUnsignedLong1 != 30L);\r
+ CPPUNIT_ASSERT(m_anyUnsignedLong1 == 15UL);\r
+ CPPUNIT_ASSERT(m_anyUnsignedLong1 != 30UL);\r
+ CPPUNIT_ASSERT(m_anyStringString1 == wxString("abc"));\r
+ CPPUNIT_ASSERT(m_anyStringString1 != wxString("ABC"));\r
+ CPPUNIT_ASSERT(m_anyStringString1 == "abc");\r
+ CPPUNIT_ASSERT(m_anyStringString1 != "ABC");\r
+ CPPUNIT_ASSERT(m_anyStringString1 == L"abc");\r
+ CPPUNIT_ASSERT(m_anyStringString1 != L"ABC");\r
+ CPPUNIT_ASSERT(m_anyBool1 == true);\r
+ CPPUNIT_ASSERT(m_anyBool1 != false);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(wxANY_AS(m_anyFloatDouble1, double),\r
+ wxANY_AS(m_anyDoubleDouble1, double),\r
+ FEQ_DELTA);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(wxANY_AS(m_anyFloatDouble1, double),\r
+ TEST_FLOAT_CONST,\r
+ FEQ_DELTA);\r
+ CPPUNIT_ASSERT(m_anyWxObjectPtr1.As<wxObject*>() == dummyWxObjectPointer);\r
+ CPPUNIT_ASSERT(m_anyVoidPtr1.As<void*>() == dummyVoidPointer);\r
+\r
+ CPPUNIT_ASSERT(m_anySignedLong2 == 15);\r
+ CPPUNIT_ASSERT(m_anyStringString2 == wxString("abc"));\r
+ CPPUNIT_ASSERT(m_anyStringString2 == "abc");\r
+ CPPUNIT_ASSERT(m_anyStringString2 == L"abc");\r
+ CPPUNIT_ASSERT(m_anyBool2 == true);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(wxANY_AS(m_anyFloatDouble2, double),\r
+ wxANY_AS(m_anyDoubleDouble2, double),\r
+ FEQ_DELTA);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(wxANY_AS(m_anyFloatDouble2, double),\r
+ TEST_FLOAT_CONST,\r
+ FEQ_DELTA);\r
+ CPPUNIT_ASSERT(m_anyWxObjectPtr2.As<wxObject*>() == dummyWxObjectPointer);\r
+ CPPUNIT_ASSERT(m_anyVoidPtr2.As<void*>() == dummyVoidPointer);\r
+}\r
+\r
+void wxAnyTestCase::As()\r
+{\r
+ //\r
+ // Test getting C++ data from wxAny without dynamic conversion\r
+ signed char a = wxANY_AS(m_anySignedChar1, signed char);\r
+ CPPUNIT_ASSERT(a == (signed int)15);\r
+ signed short b = wxANY_AS(m_anySignedShort1, signed short);\r
+ CPPUNIT_ASSERT(b == (signed int)15);\r
+ signed int c = wxANY_AS(m_anySignedInt1, signed int);\r
+ CPPUNIT_ASSERT(c == (signed int)15);\r
+ signed long d = wxANY_AS(m_anySignedLong1, signed long);\r
+ CPPUNIT_ASSERT(d == (signed int)15);\r
+#ifdef wxLongLong_t\r
+ wxLongLong_t e = wxANY_AS(m_anySignedLongLong1, wxLongLong_t);\r
+ CPPUNIT_ASSERT(e == (signed int)15);\r
+#endif\r
+ unsigned char f = wxANY_AS(m_anyUnsignedChar1, unsigned char);\r
+ CPPUNIT_ASSERT(f == (unsigned int)15);\r
+ unsigned short g = wxANY_AS(m_anyUnsignedShort1, unsigned short);\r
+ CPPUNIT_ASSERT(g == (unsigned int)15);\r
+ unsigned int h = wxANY_AS(m_anyUnsignedInt1, unsigned int);\r
+ CPPUNIT_ASSERT(h == (unsigned int)15);\r
+ unsigned long i = wxANY_AS(m_anyUnsignedLong1, unsigned long);\r
+ CPPUNIT_ASSERT(i == (unsigned int)15);\r
+#ifdef wxLongLong_t\r
+ wxULongLong_t j = wxANY_AS(m_anyUnsignedLongLong1, wxULongLong_t);\r
+ CPPUNIT_ASSERT(j == (unsigned int)15);\r
+#endif\r
+ wxString k = wxANY_AS(m_anyStringString1, wxString);\r
+ CPPUNIT_ASSERT(k == "abc");\r
+ wxString l = wxANY_AS(m_anyCharString1, wxString);\r
+ CPPUNIT_ASSERT(l == "abc");\r
+ wxString m = wxANY_AS(m_anyWcharString1, wxString);\r
+ CPPUNIT_ASSERT(m == "abc");\r
+ bool n = wxANY_AS(m_anyBool1, bool);\r
+ CPPUNIT_ASSERT(n);\r
+ float o = wxANY_AS(m_anyFloatDouble1, float);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(o, TEST_FLOAT_CONST, FEQ_DELTA);\r
+ double p = wxANY_AS(m_anyDoubleDouble1, double);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(p, TEST_FLOAT_CONST, FEQ_DELTA);\r
+ wxDateTime q = wxANY_AS(m_anyDateTime1, wxDateTime);\r
+ CPPUNIT_ASSERT(q == m_testDateTime);\r
+ wxObject* r = wxANY_AS(m_anyWxObjectPtr1, wxObject*);\r
+ CPPUNIT_ASSERT(r == dummyWxObjectPointer);\r
+ void* s = wxANY_AS(m_anyVoidPtr1, void*);\r
+ CPPUNIT_ASSERT(s == dummyVoidPointer);\r
+}\r
+\r
+void wxAnyTestCase::Null()\r
+{\r
+ wxAny a;\r
+ CPPUNIT_ASSERT(a.IsNull());\r
+ a = -127;\r
+ CPPUNIT_ASSERT(a == -127);\r
+ a.MakeNull();\r
+ CPPUNIT_ASSERT(a.IsNull());\r
+}\r
+\r
+void wxAnyTestCase::GetAs()\r
+{\r
+ //\r
+ // Test dynamic conversion\r
+ bool res;\r
+ long l = 0;\r
+ unsigned long ul = 0;\r
+ wxString s;\r
+ // Let's test against float instead of double, since the former\r
+ // is not the native underlying type the code converts to, but\r
+ // should still work, all the same.\r
+ float f = 0.0;\r
+ bool b = false;\r
+\r
+ // Conversions from signed long type\r
+ res = m_anySignedLong1.GetAs(&ul);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_EQUAL(ul, static_cast<unsigned long>(15));\r
+ res = m_anySignedLong1.GetAs(&s);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(s == "15");\r
+ res = m_anySignedLong1.GetAs(&f);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(f, 15.0, FEQ_DELTA);\r
+ res = m_anySignedLong1.GetAs(&b);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(b == true);\r
+\r
+ // Conversions from unsigned long type\r
+ res = m_anyUnsignedLong1.GetAs(&l);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(l == static_cast<signed long>(15));\r
+ res = m_anyUnsignedLong1.GetAs(&s);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(s == "15");\r
+ res = m_anyUnsignedLong1.GetAs(&f);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(f, 15.0, FEQ_DELTA);\r
+ res = m_anyUnsignedLong1.GetAs(&b);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(b == true);\r
+\r
+ // Conversions from default "abc" string to other types\r
+ // should not work.\r
+ CPPUNIT_ASSERT(!m_anyStringString1.GetAs(&l));\r
+ CPPUNIT_ASSERT(!m_anyStringString1.GetAs(&ul));\r
+ CPPUNIT_ASSERT(!m_anyStringString1.GetAs(&f));\r
+ CPPUNIT_ASSERT(!m_anyStringString1.GetAs(&b));\r
+\r
+ // Let's test some other conversions from string that should work.\r
+ wxAny anyString;\r
+\r
+ anyString = "15";\r
+ res = anyString.GetAs(&l);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(l == static_cast<signed long>(15));\r
+ res = anyString.GetAs(&ul);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_EQUAL(ul, static_cast<unsigned long>(15));\r
+ res = anyString.GetAs(&f);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(f, 15.0, FEQ_DELTA);\r
+ anyString = "TRUE";\r
+ res = anyString.GetAs(&b);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(b == true);\r
+ anyString = "0";\r
+ res = anyString.GetAs(&b);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(b == false);\r
+\r
+ // Conversions from bool type\r
+ res = m_anyBool1.GetAs(&l);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(l == static_cast<signed long>(1));\r
+ res = m_anyBool1.GetAs(&ul);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_EQUAL(ul, static_cast<unsigned long>(1));\r
+ res = m_anyBool1.GetAs(&s);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(s == "true");\r
+ CPPUNIT_ASSERT(!m_anyBool1.GetAs(&f));\r
+\r
+ // Conversions from floating point type\r
+ res = m_anyDoubleDouble1.GetAs(&l);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT(l == static_cast<signed long>(123));\r
+ res = m_anyDoubleDouble1.GetAs(&ul);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_EQUAL(ul, static_cast<unsigned long>(123));\r
+ res = m_anyDoubleDouble1.GetAs(&s);\r
+ CPPUNIT_ASSERT(res);\r
+ double d2;\r
+ res = s.ToDouble(&d2);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(d2, TEST_FLOAT_CONST, FEQ_DELTA);\r
+}\r
+\r
+//\r
+// Test user data type specialization of wxAnyValueTypeImpl\r
+//\r
+\r
+class MyClass\r
+{\r
+public:\r
+ MyClass( int someValue = 32768 )\r
+ {\r
+ m_someValue = someValue;\r
+ }\r
+\r
+ wxString ToString()\r
+ {\r
+ return wxString::Format("%i", m_someValue);\r
+ }\r
+\r
+private:\r
+ int m_someValue;\r
+};\r
+\r
+\r
+template<>\r
+class wxAnyValueTypeImpl<MyClass> :\r
+ public wxAnyValueTypeImplBase<MyClass>\r
+{\r
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)\r
+public:\r
+ wxAnyValueTypeImpl() :\r
+ wxAnyValueTypeImplBase<MyClass>() { }\r
+ virtual ~wxAnyValueTypeImpl() { }\r
+\r
+ virtual bool ConvertValue(const wxAnyValueBuffer& src,\r
+ wxAnyValueType* dstType,\r
+ wxAnyValueBuffer& dst) const\r
+ {\r
+ MyClass value = GetValue(src);\r
+\r
+ if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )\r
+ {\r
+ wxString s = value.ToString();\r
+ wxAnyValueTypeImpl<wxString>::SetValue(s, dst);\r
+ }\r
+ else\r
+ return false;\r
+\r
+ return true;\r
+ }\r
+};\r
+\r
+//\r
+// Following must be placed somewhere in your source code\r
+WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<MyClass>)\r
+\r
+void wxAnyTestCase::CustomTemplateSpecialization()\r
+{\r
+ // Do only a minimal CheckType() test, as dynamic type conversion already\r
+ // uses it a lot.\r
+ bool res;\r
+ MyClass myObject;\r
+ wxAny any = myObject;\r
+\r
+ CPPUNIT_ASSERT( wxANY_CHECK_TYPE(any, MyClass) );\r
+ MyClass myObject2 = wxANY_AS(any, MyClass);\r
+ wxUnusedVar(myObject2);\r
+\r
+ wxString str;\r
+ res = any.GetAs(&str);\r
+ CPPUNIT_ASSERT(res);\r
+ CPPUNIT_ASSERT_EQUAL(str, myObject.ToString());\r
+}\r
+\r
+#endif // wxUSE_ANY\r
+\r
TEST_OBJECTS = \
$(OBJS)\test_dummy.obj \
$(OBJS)\test_test.obj \
+ $(OBJS)\test_anytest.obj \
$(OBJS)\test_archivetest.obj \
$(OBJS)\test_ziptest.obj \
$(OBJS)\test_tartest.obj \
$(OBJS)\test_test.obj: .\test.cpp
$(CXX) -q -c -P -o$@ $(TEST_CXXFLAGS) .\test.cpp
+$(OBJS)\test_anytest.obj: .\any\anytest.cpp
+ $(CXX) -q -c -P -o$@ $(TEST_CXXFLAGS) .\any\anytest.cpp
+
$(OBJS)\test_archivetest.obj: .\archive\archivetest.cpp
$(CXX) -q -c -P -o$@ $(TEST_CXXFLAGS) .\archive\archivetest.cpp
TEST_OBJECTS = \
$(OBJS)\test_dummy.o \
$(OBJS)\test_test.o \
+ $(OBJS)\test_anytest.o \
$(OBJS)\test_archivetest.o \
$(OBJS)\test_ziptest.o \
$(OBJS)\test_tartest.o \
$(OBJS)\test_test.o: ./test.cpp
$(CXX) -c -o $@ $(TEST_CXXFLAGS) $(CPPDEPS) $<
+$(OBJS)\test_anytest.o: ./any/anytest.cpp
+ $(CXX) -c -o $@ $(TEST_CXXFLAGS) $(CPPDEPS) $<
+
$(OBJS)\test_archivetest.o: ./archive/archivetest.cpp
$(CXX) -c -o $@ $(TEST_CXXFLAGS) $(CPPDEPS) $<
TEST_OBJECTS = \
$(OBJS)\test_dummy.obj \
$(OBJS)\test_test.obj \
+ $(OBJS)\test_anytest.obj \
$(OBJS)\test_archivetest.obj \
$(OBJS)\test_ziptest.obj \
$(OBJS)\test_tartest.obj \
$(OBJS)\test_test.obj: .\test.cpp
$(CXX) /c /nologo /TP /Fo$@ $(TEST_CXXFLAGS) .\test.cpp
+$(OBJS)\test_anytest.obj: .\any\anytest.cpp
+ $(CXX) /c /nologo /TP /Fo$@ $(TEST_CXXFLAGS) .\any\anytest.cpp
+
$(OBJS)\test_archivetest.obj: .\archive\archivetest.cpp
$(CXX) /c /nologo /TP /Fo$@ $(TEST_CXXFLAGS) .\archive\archivetest.cpp
TEST_OBJECTS = &
$(OBJS)\test_dummy.obj &
$(OBJS)\test_test.obj &
+ $(OBJS)\test_anytest.obj &
$(OBJS)\test_archivetest.obj &
$(OBJS)\test_ziptest.obj &
$(OBJS)\test_tartest.obj &
$(OBJS)\test_test.obj : .AUTODEPEND .\test.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(TEST_CXXFLAGS) $<
+$(OBJS)\test_anytest.obj : .AUTODEPEND .\any\anytest.cpp
+ $(CXX) -bt=nt -zq -fo=$^@ $(TEST_CXXFLAGS) $<
+
$(OBJS)\test_archivetest.obj : .AUTODEPEND .\archive\archivetest.cpp
$(CXX) -bt=nt -zq -fo=$^@ $(TEST_CXXFLAGS) $<
template_append="wx_append_base">
<sources>
test.cpp
+ any/anytest.cpp
archive/archivetest.cpp
archive/ziptest.cpp
archive/tartest.cpp
# PROP Default_Filter ""\r
# Begin Source File\r
\r
+SOURCE=.\any\anytest.cpp\r
+# End Source File\r
+# Begin Source File\r
+\r
SOURCE=.\archive\archivetest.cpp\r
# End Source File\r
# Begin Source File\r
Name="Source Files"\r
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">\r
+ <File\r
+ RelativePath=".\any\anytest.cpp">\r
+ </File>\r
<File\r
RelativePath=".\archive\archivetest.cpp">\r
</File>\r
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
>\r
+ <File\r
+ RelativePath=".\any\anytest.cpp"\r
+ >\r
+ </File>\r
<File\r
RelativePath=".\archive\archivetest.cpp"\r
>\r
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"\r
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"\r
>\r
+ <File\r
+ RelativePath=".\any\anytest.cpp"\r
+ >\r
+ </File>\r
<File\r
RelativePath=".\archive\archivetest.cpp"\r
>\r
# --- wxBase headers list begins here ---
cat <<EOF >wxbase-headers.files
wx/afterstd.h
+wx/any.h
wx/anystr.h
wx/app.h
wx/apptrait.h
# --- wxBase headers list begins here ---
cat <<EOF >wxbase-headers.files
wx/afterstd.h
+wx/any.h
wx/anystr.h
wx/app.h
wx/apptrait.h
# --- wxBase headers list begins here ---
cat <<EOF >wxbase-headers.files
wx/afterstd.h
+wx/any.h
wx/anystr.h
wx/app.h
wx/apptrait.h
projects / wxWidgets.git / commitdiff
