This commit was manufactured by cvs2svn to create tag 'wxPy-2-1-4'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/wxPy-2-1-4@3889 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
removed some test code that accidentally was left in
1999-10-07 23:40:33 +00:00 · 1999-10-06 16:27:10 +00:00 · 1999-10-06 15:42:04 +00:00 · 1999-10-06 15:40:04 +00:00 · 1999-10-06 15:04:05 +00:00 · 1999-10-06 08:23:29 +00:00
1165 changed files with 363415 additions and 5105 deletions
--- a/Makefile.in
+++ b/Makefile.in
@@ -1821,14 +1821,53 @@ JPEGOBJS    = \
 		jquant2.o \
 		jdmerge.o

+BASE_OBJS = \
+    dynarray.o \
+    event.o \
+    hash.o \
+    intl.o \
+    init.o \
+    file.o \
+    filefn.o \
+    list.o \
+    log.o \
+    object.o \
+    string.o \
+    utilscmn.o \
+    utilsunx.o

-OBJECTS = $(@GUIOBJS@) $(@COMMONOBJS@) $(@GENERICOBJS@) $(@UNIXOBJS@) $(HTMLOBJS) \
-	  $(JPEGOBJS) $(PNGOBJS) $(ZLIBOBJS)
+BASE_DEPS = \
+    dynarray.d \
+    event.d \
+    hash.d \
+    intl.d \
+    init.d \
+    file.d \
+    filefn.d \
+    list.d \
+    log.d \
+    object.d \
+    string.d \
+    utilscmn.d \
+    utilsunx.d

-DEPFILES = $(@GUIDEPS@) $(@COMMONDEPS@) $(@GENERICDEPS@) $(UNIXDEPS) $(HTMLDEPS)
+BASE_HEADERS =

-HEADERS = $(@GUIHEADERS@) $(HTML_HEADERS) $(UNIX_HEADERS) $(PROTOCOL_HEADERS) \
-	  $(GENERIC_HEADERS) $(WX_HEADERS)
+GUIOBJS = @GUIOBJS@
+GUIDEPS = @GUIDEPS@
+GUIHEADERS = @GUIHEADERS@
+COMMONOBJS = @COMMONOBJS@
+COMMONDEPS = @COMMONDEPS@
+GENERICOBJS = @GENERICOBJS@
+GENERICDEPS = @GENERICDEPS@
+UNIXOBJS = @UNIXOBJS@
+UNIXDEPS = @UNIXDEPS@
+
+OBJECTS = @ALL_OBJECTS@
+
+DEPFILES = @ALL_DEPFILES@
+
+HEADERS = @ALL_HEADERS@

 all: @WX_CREATE_LINKS@

--- a/12717
+++ b/12717
--- a/configure.in
+++ b/configure.in
@@ -64,8 +64,8 @@ main ()
   if (gtk_minor_version == 1) return FALSE;

   return !((gtk_major_version > major) ||
-	    ((gtk_major_version == major) && (gtk_minor_version > minor)) ||
-	    ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro)));
+    ((gtk_major_version == major) && (gtk_minor_version > minor)) ||
+    ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro)));
 }
 ],, no_gtk=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
     CFLAGS="$ac_save_CFLAGS"
@@ -744,7 +744,7 @@ if test $DEBUG_CONFIGURE = 1; then

  DEFAULT_wxUSE_UNICODE=no
  DEFAULT_wxUSE_WCSRTOMBS=no
-  
+
  DEFAULT_wxUSE_GIF=no
  DEFAULT_wxUSE_PCX=no
  DEFAULT_wxUSE_PNM=no
@@ -855,7 +855,7 @@ else

  DEFAULT_wxUSE_UNICODE=no
  DEFAULT_wxUSE_WCSRTOMBS=no
-  
+
  DEFAULT_wxUSE_GIF=yes
  DEFAULT_wxUSE_PCX=yes
  DEFAULT_wxUSE_PNM=yes
@@ -880,6 +880,85 @@ for toolkit in `echo $ALL_TOOLKITS`; do
  fi
 done

+dnl ---------------------------------------------------------------------------
+dnl --disable-gui will build only non-GUI part of wxWindows: check for this
+dnl first to disable many other switches if it's given
+dnl
+dnl NB: this is still in testing stage, don't use if you don't know what you're
+dnl     doing
+dnl ---------------------------------------------------------------------------
+
+WX_ARG_ENABLE(gui,         [  --enable-gui            use GUI classes], wxUSE_GUI)
+
+dnl disable everything GUI related then
+if test "$wxUSE_GUI" = "no"; then
+  DEFAULT_wxUSE_ZLIB=no
+  DEFAULT_wxUSE_LIBPNG=no
+  DEFAULT_wxUSE_LIBJPEG=no
+  DEFAULT_wxUSE_SOCKETS=no
+  DEFAULT_wxUSE_JOYSTICK=no
+  DEFAULT_wxUSE_AFM_FOR_POSTSCRIPT=no
+  DEFAULT_wxUSE_NORMALIZED_PS_FONTS=no
+  DEFAULT_wxUSE_POSTSCRIPT=no
+  DEFAULT_wxUSE_X_RESOURCES=no
+  DEFAULT_wxUSE_CLIPBOARD=no
+  DEFAULT_wxUSE_TOOLTIPS=no
+  DEFAULT_wxUSE_DRAG_AND_DROP=no
+  DEFAULT_wxUSE_SPLINES=no
+  DEFAULT_wxUSE_MDI_ARCHITECTURE=no
+  DEFAULT_wxUSE_DOC_VIEW_ARCHITECTURE=no
+  DEFAULT_wxUSE_PRINTING_ARCHITECTURE=no
+  DEFAULT_wxUSE_PROLOGIO=no
+  DEFAULT_wxUSE_RESOURCES=no
+  DEFAULT_wxUSE_CONSTRAINTS=no
+  DEFAULT_wxUSE_IPC=no
+  DEFAULT_wxUSE_HELP=no
+  DEFAULT_wxUSE_WXTREE=no
+  DEFAULT_wxUSE_METAFILE=no
+  DEFAULT_wxUSE_COMMONDLGS=no
+  DEFAULT_wxUSE_DIRDLG=no
+  DEFAULT_wxUSE_TEXTDLG=no
+  DEFAULT_wxUSE_STARTUP_TIPS=no
+  DEFAULT_wxUSE_PROGRESSDLG=no
+  DEFAULT_wxUSE_MINIFRAME=no
+  DEFAULT_wxUSE_HTML=no
+  DEFAULT_wxUSE_FS_INET=no
+  DEFAULT_wxUSE_FS_ZIP=no
+  DEFAULT_wxUSE_BUSYINFO=no
+  DEFAULT_wxUSE_ZIPSTREAM=no
+  DEFAULT_wxUSE_VALIDATORS=yes
+  DEFAULT_wxUSE_ACCEL=no
+  DEFAULT_wxUSE_CARET=no
+  DEFAULT_wxUSE_BMPBUTTON=no
+  DEFAULT_wxUSE_CHECKBOX=no
+  DEFAULT_wxUSE_CHECKLST=no
+  DEFAULT_wxUSE_CHOICE=yes
+  DEFAULT_wxUSE_COMBOBOX=no
+  DEFAULT_wxUSE_GAUGE=no
+  DEFAULT_wxUSE_GRID=no
+  DEFAULT_wxUSE_IMAGLIST=no
+  DEFAULT_wxUSE_LISTBOX=no
+  DEFAULT_wxUSE_LISTCTRL=no
+  DEFAULT_wxUSE_NOTEBOOK=no
+  DEFAULT_wxUSE_RADIOBOX=no
+  DEFAULT_wxUSE_RADIOBTN=no
+  DEFAULT_wxUSE_SASH=no
+  DEFAULT_wxUSE_SCROLLBAR=no
+  DEFAULT_wxUSE_SLIDER=no
+  DEFAULT_wxUSE_SPINBTN=no
+  DEFAULT_wxUSE_SPLITTER=no
+  DEFAULT_wxUSE_STATBMP=no
+  DEFAULT_wxUSE_STATBOX=no
+  DEFAULT_wxUSE_STATLINE=no
+  DEFAULT_wxUSE_STATUSBAR=yes
+  DEFAULT_wxUSE_TABDIALOG=no
+  DEFAULT_wxUSE_TOOLBAR=no
+  DEFAULT_wxUSE_TREECTRL=no
+  DEFAULT_wxUSE_GIF=no
+  DEFAULT_wxUSE_PCX=no
+  DEFAULT_wxUSE_PNM=no
+fi
+
 AC_ARG_WITH(gtk,           [  --with-gtk              use GTK+], [wxUSE_GTK="$withval" CACHE_GTK=1 TOOLKIT_GIVEN=1])
 AC_ARG_WITH(motif,         [  --with-motif            use Motif/Lesstif], [wxUSE_MOTIF="$withval" CACHE_MOTIF=1 TOOLKIT_GIVEN=1])
 AC_ARG_WITH(wine,          [  --with-wine             use WINE], [wxUSE_WINE="$withval" CACHE_WINE=1 TOOLKIT_GIVEN=1])
@@ -929,15 +1008,6 @@ WX_ARG_ENABLE(no_exceptions, [  --enable-no_exceptions  create code without exce
 WX_ARG_ENABLE(permissive,    [  --enable-permissive     compile code disregarding strict ANSI], wxUSE_PERMISSIVE)
 WX_ARG_ENABLE(no_deps,       [  --enable-no_deps        create code without dependency information], wxUSE_NO_DEPS)

-dnl ---------------------------------------------------------------------------
-dnl --disable-gui will build only non-GUI part of wxWindows
-dnl
-dnl NB: this is still in testing stage, don't use if you don't know what you're
-dnl     doing
-dnl ---------------------------------------------------------------------------
-
-WX_ARG_ENABLE(gui,         [  --enable-gui            use GUI classes], wxUSE_GUI)
-
 dnl ---------------------------------------------------------------------------
 dnl (small) optional non GUI classes
 dnl ---------------------------------------------------------------------------
@@ -1139,6 +1209,8 @@ dnl we have a default one

 AC_MSG_CHECKING(for toolkit)

+if test "$wxUSE_GUI" = "yes"; then
+
 if test "$TOOLKIT_GIVEN" = 1; then
  dnl convert "yes" to 1 and "no" to 0
  for toolkit in `echo $ALL_TOOLKITS`; do
@@ -1187,6 +1259,11 @@ for toolkit in `echo $ALL_TOOLKITS`; do
  fi
 done

+dnl from "if wxUSE_GUI"
+else
+    AC_MSG_RESULT(base only)
+fi
+
 dnl ---------------------------------------------------------------------------
 dnl Checks for programs
 dnl ---------------------------------------------------------------------------
@@ -1390,6 +1467,8 @@ dnl ----------------------------------------------------------------
 dnl search for toolkit (widget sets)
 dnl ----------------------------------------------------------------

+if test "$wxUSE_GUI" = "yes"; then
+
 TOOLKIT=
 TOOLKIT_INCLUDE=

@@ -1409,14 +1488,14 @@ PROGRAM_EXT=

 if test "$wxUSE_CYGWIN" = 1 || test "$wxUSE_MINGW" = 1 ; then
    if test "$cross_compiling" = "yes" ; then
-    	AC_MSG_WARN(Cross compiling --- skipping windows.h check)
+        AC_MSG_WARN(Cross compiling --- skipping windows.h check)
    else
-	AC_MSG_CHECKING(for Windows headers)
-    	WX_PATH_FIND_INCLUDES($SEARCH_INCLUDE, windows.h)
-    	if test "$ac_find_includes" != "" ; then
+        AC_MSG_CHECKING(for Windows headers)
+        WX_PATH_FIND_INCLUDES($SEARCH_INCLUDE, windows.h)
+        if test "$ac_find_includes" != "" ; then
            AC_MSG_RESULT(found $ac_find_includes)
            TOOLKIT_INCLUDE="$TOOLKIT_INCLUDE -I$ac_find_includes"
-	else
+        else
            AC_MSG_RESULT(no)
            AC_MSG_ERROR(please set CFLAGS to contain the location of windows.h)
        fi
@@ -1429,10 +1508,10 @@ if test "$wxUSE_CYGWIN" = 1 || test "$wxUSE_MINGW" = 1 ; then

    TOOLKIT=MSW

-    GUIOBJS=MSW_GUIOBJS
-    GUIHEADERS=MSW_HEADERS
-    COMMONOBJS=MSW_COMMONOBJS
-    GENERICOBJS=MSW_GENERICOBJS
+    GUIOBJS="\$(MSW_GUIOBJS)"
+    GUIHEADERS="\$(MSW_HEADERS)"
+    COMMONOBJS="\$(MSW_COMMONOBJS)"
+    GENERICOBJS="\$(MSW_GENERICOBJS)"
    UNIXOBJS=
    GUIDIST=MSW_DIST
    PROGRAM_EXT=.exe
@@ -1450,14 +1529,14 @@ if test "$wxUSE_GTK" = 1; then
    GUI_TK_LIBRARY="$GTK_LIBS"
    TOOLKIT=GTK

-    GUIHEADERS=GTK_HEADERS
-    GUIOBJS=GTK_GUIOBJS
-    COMMONOBJS=GTK_COMMONOBJS
-    GENERICOBJS=GTK_GENERICOBJS
-    GUIDEPS=GTK_GUIDEPS
-    COMMONDEPS=GTK_COMMONDEPS
-    GENERICDEPS=GTK_GENERICDEPS
-    UNIXOBJS=UNIXOBJS
+    GUIOBJS="\$(GTK_GUIOBJS)"
+    GUIHEADERS="\$(GTK_HEADERS)"
+    COMMONOBJS="\$(GTK_COMMONOBJS)"
+    GENERICOBJS="\$(GTK_GENERICOBJS)"
+    GUIDEPS="\$(GTK_GUIDEPS)"
+    COMMONDEPS="\$(GTK_COMMONDEPS)"
+    GENERICDEPS="\$(GTK_GENERICDEPS)"
+    UNIXOBJS="\$(UNIX_OBJS)"
    GUIDIST=GTK_DIST
 fi

@@ -1501,14 +1580,14 @@ if test "$wxUSE_WINE" = 1; then
    WXWINE=1
    TOOLKIT=MSW

-    GUIHEADERS=MSW_HEADERS
-    GUIOBJS=MSW_GUIOBJS
-    COMMONOBJS=MSW_COMMONOBJS
-    GENERICOBJS=MSW_GENERICOBJS
-    GUIDEPS=MSW_GUIDEPS
-    COMMONDEPS=MSW_COMMONDEPS
-    GENERICDEPS=MSW_GENERICDEPS
-    UNIXOBJS=UNIXOBJS
+    GUIHEADERS="\$(MSW_HEADERS)"
+    GUIOBJS="\$(MSW_GUIOBJS)"
+    COMMONOBJS="\$(MSW_COMMONOBJS)"
+    GENERICOBJS="\$(MSW_GENERICOBJS)"
+    GUIDEPS="\$(MSW_GUIDEPS)"
+    COMMONDEPS="\$(MSW_COMMONDEPS)"
+    GENERICDEPS="\$(MSW_GENERICDEPS)"
+    UNIXOBJS="\$(UNIX_OBJS)"
    GUIDIST=MSW_DIST
 fi

@@ -1576,14 +1655,14 @@ if test "$wxUSE_MOTIF" = 1; then
    GUI_TK_LIBRARY="$GUI_TK_LIBRARY $GUI_TK_LINK"
    TOOLKIT=MOTIF

-    GUIHEADERS=MOTIF_HEADERS
-    GUIOBJS=MOTIF_GUIOBJS
-    COMMONOBJS=MOTIF_COMMONOBJS
-    GENERICOBJS=MOTIF_GENERICOBJS
-    GUIDEPS=MOTIF_GUIDEPS
-    COMMONDEPS=MOTIF_COMMONDEPS
-    GENERICDEPS=MOTIF_GENERICDEPS
-    UNIXOBJS=UNIXOBJS
+    GUIHEADERS="\$(MOTIF_HEADERS)"
+    GUIOBJS="\$(MOTIF_GUIOBJS)"
+    COMMONOBJS="\$(MOTIF_COMMONOBJS)"
+    GENERICOBJS="\$(MOTIF_GENERICOBJS)"
+    GUIDEPS="\$(MOTIF_GUIDEPS)"
+    COMMONDEPS="\$(MOTIF_COMMONDEPS)"
+    GENERICDEPS="\$(MOTIF_GENERICDEPS)"
+    UNIXOBJS="\$(UNIX_OBJS)"
    GUIDIST=MOTIF_DIST
 fi

@@ -1603,19 +1682,35 @@ TOOLKIT_DEF="-D__WX${TOOLKIT}__"
 dnl the name of the (libtool) library
 WX_LIBRARY="wx_${TOOLKIT_DIR}"

+    dnl the sources, their dependenices and the headers
+    ALL_OBJECTS="\$(GUIOBJS) \$(COMMONOBJS) \$(GENERICOBJS) \$(UNIXOBJS) \$(HTMLOBJS) \$(JPEGOBJS) \$(PNGOBJS) \$(ZLIBOBJS)"
+    ALL_DEPFILES="\$(GUIDEPS) \$(COMMONDEPS) \$(GENERICDEPS) \$(UNIXDEPS) \$(HTMLDEPS)"
+    ALL_HEADERS="\$(GUIHEADERS) \$(HTML_HEADERS) \$(UNIX_HEADERS) \$(PROTOCOL_HEADERS) \$(GENERIC_HEADERS) \$(WX_HEADERS)"
+else
+    dnl leave all TOOLKIT_XXX vars empty
+
+    dnl the sources, their dependenices and the headers
+    ALL_OBJECTS="\$(BASE_OBJS)"
+    ALL_DEPFILES="\${BASE_DEPS}"
+    ALL_HEADERS="\${BASE_HEADERS}"
+
+    dnl building wxBase only
+    WX_LIBRARY="wxbase"
+fi
+
 dnl the name of the (libtool) library
-WX_LIBRARY_NAME="libwx_${TOOLKIT_DIR}.la"
+WX_LIBRARY_NAME="lib${WX_LIBRARY}.la"

 dnl the name of the static library
-WX_LIBRARY_NAME_STATIC="libwx_${TOOLKIT_DIR}.a"
+WX_LIBRARY_NAME_STATIC="lib${WX_LIBRARY}.a"

 dnl the name of the shared library
-WX_LIBRARY_NAME_SHARED="libwx_${TOOLKIT_DIR}-${WX_RELEASE}.so.${WX_CURRENT}.${WX_REVISION}.${WX_AGE}"
+WX_LIBRARY_NAME_SHARED="lib${WX_LIBRARY}-${WX_RELEASE}.so.${WX_CURRENT}.${WX_REVISION}.${WX_AGE}"

 dnl the name of the links to the shared library
-WX_LIBRARY_LINK1="libwx_${TOOLKIT_DIR}-${WX_RELEASE}.so.${WX_CURRENT}"
-WX_LIBRARY_LINK2="libwx_${TOOLKIT_DIR}-${WX_RELEASE}.so"
-WX_LIBRARY_LINK3="libwx_${TOOLKIT_DIR}.so"
+WX_LIBRARY_LINK1="lib${WX_LIBRARY}-${WX_RELEASE}.so.${WX_CURRENT}"
+WX_LIBRARY_LINK2="lib${WX_LIBRARY}-${WX_RELEASE}.so"
+WX_LIBRARY_LINK3="lib${WX_LIBRARY}.so"

 dnl shared library settings
 SHARED_LD=
@@ -1725,8 +1820,11 @@ dnl defines HAVE_WCSTR_H
 AC_CHECK_HEADERS(wcstr.h)
 dnl defines HAVE_FNMATCH_H
 AC_CHECK_HEADERS(fnmatch.h)
-dnl defines HAVE_X11_XKBLIB_H
-AC_CHECK_HEADERS(X11/XKBlib.h)
+
+if test "$wxUSE_GUI" = "yes"; then
+    dnl defines HAVE_X11_XKBLIB_H
+    AC_CHECK_HEADERS(X11/XKBlib.h)
+fi

 dnl ---------------------------------------------------------------------------
 dnl Checks for typedefs
@@ -1863,6 +1961,9 @@ AC_CHECK_FUNCS(nanosleep, AC_DEFINE(HAVE_NANOSLEEP), [
 dnl check for uname (POSIX) and gethostname (BSD)
 AC_CHECK_FUNCS(uname gethostname, break)

+dnl check for MT-safe version of strtok
+AC_CHECK_FUNCS(strtok_r)
+
 dnl check for inet_addr, inet_aton, ...
 AC_CHECK_FUNCS(inet_addr)
 AC_CHECK_FUNCS(inet_aton)
@@ -2051,10 +2152,10 @@ fi
 DEP_INFO_FLAGS=
 if test "$GCC" = yes ; then
    if test "$wxUSE_NO_RTTI" = "yes" ; then
-	WXDEBUG_DEFINE="$WXDEBUG_DEFINE -fno-rtti"
+        WXDEBUG_DEFINE="$WXDEBUG_DEFINE -fno-rtti"
    fi
    if test "$wxUSE_NO_EXCEPTIONS" = "yes" ; then
-	WXDEBUG_DEFINE="$WXDEBUG_DEFINE -fno-exceptions"
+        WXDEBUG_DEFINE="$WXDEBUG_DEFINE -fno-exceptions"
    fi
    if test "$wxUSE_PERMISSIVE" = "yes" ; then
       CFLAGS="${CFLAGS} -fpermissive"
@@ -2312,9 +2413,9 @@ if test "$wxUSE_DYNLIB_CLASS" = "yes"; then
            AC_MSG_WARN("--with-dynlib and --with-odbc will be disabled due to missing shared library support")
            wxUSE_ODBC=no
            wxUSE_DYNLIB_CLASS=no
-	else
-	    AC_MSG_WARN("Cannot check dynlib requirements on non-Unix platforms. dynlib remains enabled.")
-	fi
+        else
+            AC_MSG_WARN("Cannot check dynlib requirements on non-Unix platforms. dynlib remains enabled.")
+        fi
    fi
 fi

@@ -2429,13 +2530,13 @@ if test "$wxUSE_DRAG_AND_DROP" = "yes" ; then
    if test "$wxUSE_GTK" = 1; then
        if test "$WXGTK12" != 1; then
            AC_MSG_WARN([Drag and drop is only supported under GTK+ 1.2])
-	    wxUSE_DRAG_AND_DROP=no
+            wxUSE_DRAG_AND_DROP=no
        fi
    fi

    if test "$wxUSE_MOTIF" = 1; then
        AC_MSG_WARN([Drag and drop is not yet supported under Motif])
-	wxUSE_DRAG_AND_DROP=no
+        wxUSE_DRAG_AND_DROP=no
    fi

    if test "$wxUSE_DRAG_AND_DROP" = "yes"; then
@@ -2556,7 +2657,7 @@ if test "$wxUSE_STATLINE" = "yes"; then
    if test "$wxUSE_WINE" = 1 ; then
        AC_MSG_WARN([wxStaticLine is not supported under WINE])
    else
-	AC_DEFINE(wxUSE_STATLINE)
+        AC_DEFINE(wxUSE_STATLINE)
    fi
 fi

@@ -2672,16 +2773,13 @@ dnl ---------------------------------------------------------------------------
 dnl Output the makefiles and such from the results found above
 dnl ---------------------------------------------------------------------------

-dnl if we add wxUSE_GUI in the future, it might be handy to separate the libs
-dnl into GUI and non-GUI parts
 GUILIBS="$GUI_TK_LIBRARY $OPENGL_LINK $LIBPNG_LINK $ZLIB_LINK $TOOLKIT_LINK"

 dnl all additional libraries (except wxWindows itself) we link with
-EXTRA_LIBS="$LIBS $POSIX4_LINK $WCHAR_LINK $THREADS_LINK $DMALLOC_LINK $GUILIBS"
-
-dnl all the libraries needed to link wxWindows programs (when the library is not
-dnl yet installed)
-LIBS="\${top_builddir}/src/${TOOLKIT_DIR}/${WX_LIBRARY_NAME} $EXTRA_LIBS"
+EXTRA_LIBS="$LIBS $POSIX4_LINK $WCHAR_LINK $THREADS_LINK $DMALLOC_LINK"
+if test "$wxUSE_GUI" = "yes"; then
+    EXTRA_LIBS="$EXTRA_LIBS $GUILIBS"
+fi

 dnl all the libraries needed to link wxWindows programs when using the
 dnl makefile system without libtool
@@ -2694,8 +2792,8 @@ dnl C/C++ compiler options used to compile wxWindows
 if test "$GXX" = yes ; then
    dnl CXXWARNINGS="-Wall -W -Wcast-qual -Werror"
    CXXWARNINGS="-Wall"
-    dnl there is one weird warning in docview.h:71 which prevents me from doing
-    dnl this...
+    dnl FIXME: there is one weird warning in docview.h:71 which prevents me from
+    dnl        doing this... (VZ)
    dnl CXXWARNINGS="-Wall -Werror"
 fi
 EXTRA_CFLAGS="$WXDEBUG $PROFILE $OPTIMISE $INCLUDES"
@@ -2712,6 +2810,8 @@ if test "$wxUSE_GUI" = "yes"; then
    dnl      mfc, nativdlg, oleauto, ownerdrw, proplist
    SAMPLES_SUBDIRS="$SAMPLES_SUBDIRS bombs controls dialogs drawing dynamic \
                     forty fractal image wxpoem"
+else
+    SAMPLES_SUBDIRS=""
 fi

 dnl for convenience, sort the samples in alphabetical order
@@ -2760,6 +2860,10 @@ AC_SUBST(GUIDEPS)
 AC_SUBST(COMMONDEPS)
 AC_SUBST(GENERICDEPS)
 AC_SUBST(UNIXOBJS)
+AC_SUBST(UNIXDEPS)
+AC_SUBST(ALL_OBJECTS)
+AC_SUBST(ALL_DEPFILES)
+AC_SUBST(ALL_HEADERS)
 AC_SUBST(GUIDIST)

 dnl additional subdirectories where we will build
@@ -2797,9 +2901,9 @@ dnl (the original file name may be overriden by appending another name after a
 dnl colon)
 AC_OUTPUT([
            wx-config
-	    src/make.env
-	    src/makeprog.env
-	    src/makelib.env
+            src/make.env
+            src/makeprog.env
+            src/makelib.env
            Makefile
            samples/Makefile
            samples/bombs/Makefile
@@ -2807,63 +2911,63 @@ AC_OUTPUT([
            samples/checklst/Makefile
            samples/config/Makefile
            samples/controls/Makefile
-	    samples/dialogs/Makefile
-	    samples/docview/Makefile
-	    samples/docvwmdi/Makefile
-	    samples/dnd/Makefile
-	    samples/drawing/Makefile
-	    samples/dynamic/Makefile
-	    samples/image/Makefile
-	    samples/internat/Makefile
-	    samples/layout/Makefile
-	    samples/listctrl/Makefile
-	    samples/mdi/Makefile
-	    samples/minifram/Makefile
-	    samples/minimal/Makefile
-	    samples/notebook/Makefile
+            samples/dialogs/Makefile
+            samples/docview/Makefile
+            samples/docvwmdi/Makefile
+            samples/dnd/Makefile
+            samples/drawing/Makefile
+            samples/dynamic/Makefile
+            samples/image/Makefile
+            samples/internat/Makefile
+            samples/layout/Makefile
+            samples/listctrl/Makefile
+            samples/mdi/Makefile
+            samples/minifram/Makefile
+            samples/minimal/Makefile
+            samples/notebook/Makefile
            samples/printing/Makefile
            samples/proplist/Makefile
-	    samples/sashtest/Makefile
-	    samples/scroll/Makefile
-	    samples/splitter/Makefile
-	    samples/text/Makefile
-	    samples/thread/Makefile
-	    samples/toolbar/Makefile
-	    samples/treectrl/Makefile
-	    samples/typetest/Makefile
-	    samples/validate/Makefile
-	    samples/wxpoem/Makefile
-	    samples/wxsocket/Makefile
-	    samples/wizard/Makefile
-	    samples/html/Makefile
-	    samples/html/about/Makefile
-	    samples/html/help/Makefile
-	    samples/html/printing/Makefile
-	    samples/html/test/Makefile
-	    samples/html/zip/Makefile
-	    samples/html/virtual/Makefile
-	    samples/html/widget/Makefile
-	    utils/Makefile
-	    utils/wxMMedia2/Makefile
-	    utils/wxMMedia2/lib/Makefile
-	    utils/wxMMedia2/sample/Makefile
-	    utils/glcanvas/Makefile
-	    utils/glcanvas/${GL_TOOLKIT_DIR}/Makefile
-	    utils/ogl/Makefile
-	    utils/ogl/src/Makefile
+            samples/sashtest/Makefile
+            samples/scroll/Makefile
+            samples/splitter/Makefile
+            samples/text/Makefile
+            samples/thread/Makefile
+            samples/toolbar/Makefile
+            samples/treectrl/Makefile
+            samples/typetest/Makefile
+            samples/validate/Makefile
+            samples/wxpoem/Makefile
+            samples/wxsocket/Makefile
+            samples/wizard/Makefile
+            samples/html/Makefile
+            samples/html/about/Makefile
+            samples/html/help/Makefile
+            samples/html/printing/Makefile
+            samples/html/test/Makefile
+            samples/html/zip/Makefile
+            samples/html/virtual/Makefile
+            samples/html/widget/Makefile
+            utils/Makefile
+            utils/wxMMedia2/Makefile
+            utils/wxMMedia2/lib/Makefile
+            utils/wxMMedia2/sample/Makefile
+            utils/glcanvas/Makefile
+            utils/glcanvas/${GL_TOOLKIT_DIR}/Makefile
+            utils/ogl/Makefile
+            utils/ogl/src/Makefile
          ],
          [
            chmod +x wx-config
-	    if test ! -d include; then
-	      mkdir include
-	    fi
-	    if test ! -d include/wx; then
-	      mkdir include/wx
-	    fi
-	    if test ! -d include/wx/${TOOLKIT_DIR}; then
-	      mkdir include/wx/${TOOLKIT_DIR}
-	    fi
-	    cp -f setup.h include/wx/${TOOLKIT_DIR}/setup.h
+            if test ! -d include; then
+              mkdir include
+            fi
+            if test ! -d include/wx; then
+              mkdir include/wx
+            fi
+            if test ! -d include/wx/${TOOLKIT_DIR}; then
+              mkdir include/wx/${TOOLKIT_DIR}
+            fi
+            cp -f setup.h include/wx/${TOOLKIT_DIR}/setup.h
          ],
          [
            LN_S="${ac_cv_prog_LN_S}"
--- a/distrib/msw/tmake/filelist.txt
+++ b/distrib/msw/tmake/filelist.txt
@@ -28,6 +28,7 @@
 # compiler, &c)
 #
 # Known flags:
+#  B	makes part of the base library too
 #  16	a generic file implementing Win32 control for Win16
 #  32	only can be compiled under Win32
 #  PS	PostScript related file, normally not compiled under Windows
@@ -37,6 +38,7 @@
 #  S	Socket file (currently doesn't compile under Win16 nor with GNU)
 #  R	Not required for the GTK port
 #  X	Not required for the Motif port
+#
 #  WX	Base header
 #  GTK  GTK header
 #  MSW	MSW header
@@ -90,9 +92,9 @@ wizard.cpp	G

 choiccmn.cpp	C	R
 cmndata.cpp	C
-config.cpp	C
+config.cpp	C	B
 ctrlcmn.cpp	C	R
-date.cpp	C
+date.cpp	C	B
 datstrm.cpp	C
 db.cpp	C
 dbtable.cpp	C
@@ -100,15 +102,15 @@ dcbase.cpp	C
 dlgcmn.cpp	C
 docmdi.cpp	C
 docview.cpp	C
-dynarray.cpp	C
-dynlib.cpp	C
+dynarray.cpp	C	B
+dynlib.cpp	C	B
 event.cpp	C
-extended.c	C
-ffile.cpp	C
-file.cpp	C
-fileconf.cpp	C
-filefn.cpp	C
-filesys.cpp	C
+extended.c	C	B
+ffile.cpp	C	B
+file.cpp	C	B
+fileconf.cpp	C	B
+filefn.cpp	C	B
+filesys.cpp	C	B
 fontcmn.cpp	C
 framecmn.cpp	C
 fs_inet.cpp	C
@@ -116,7 +118,7 @@ fs_zip.cpp	C
 ftp.cpp	C	S
 gdicmn.cpp	C
 gifdecod.cpp	C
-hash.cpp	C
+hash.cpp	C	B
 helpbase.cpp	C
 http.cpp	C	S
 imagbmp.cpp	C
@@ -127,21 +129,21 @@ imagjpeg.cpp	C	32
 imagpcx.cpp	C	32
 imagpng.cpp	C	32
 imagpnm.cpp	C	32
-intl.cpp	C
+intl.cpp	C	B
 ipcbase.cpp	C
 layout.cpp	C
-list.cpp	C
-log.cpp	C
+list.cpp	C	B
+log.cpp	C	B
 memory.cpp	C
-mimetype.cpp	C	32
-module.cpp	C
+mimetype.cpp	C	32,B
+module.cpp	C	B
 mstream.cpp	C
-object.cpp	C
+object.cpp	C	B
 objstrm.cpp	C
 odbc.cpp	C	R
 paper.cpp	C
 prntbase.cpp	C
-process.cpp	C	32
+process.cpp	C	32,B
 protocol.cpp	C	S
 resource.cpp	C
 sckaddr.cpp	C	S
@@ -152,26 +154,26 @@ serbase.cpp	C
 sizer.cpp	C
 socket.cpp	C	S
 stream.cpp	C
-strconv.cpp	C
-string.cpp	C
+strconv.cpp	C	B
+string.cpp	C	B
 tbarbase.cpp	C
 tbarsmpl.cpp	C
 textcmn.cpp	C
-textfile.cpp	C
-time.cpp	C
-timercmn.cpp	C
-tokenzr.cpp	C
+textfile.cpp	C	B
+time.cpp	C	B
+timercmn.cpp	C	B
+tokenzr.cpp	C	B
 txtstrm.cpp	C
 unzip.c	C
 url.cpp	C	S
-utilscmn.cpp	C
+utilscmn.cpp	C	B
 valgen.cpp	C
 validate.cpp	C
 valtext.cpp	C
-variant.cpp	C
+variant.cpp	C	B
 wfstream.cpp	C
 wincmn.cpp	C
-wxchar.cpp	C
+wxchar.cpp	C	B
 wxexpr.cpp	C
 zipstrm.cpp	C
 zstream.cpp	C
@@ -272,6 +274,7 @@ window.cpp	M
 xpmhand.cpp	M
 gsocket.c	M	S

+dialup.cpp	U
 threadpsx.cpp	U
 utilsunx.cpp	U
 gsocket.c	U
--- a/docs/html/roadmap.htm
+++ b/docs/html/roadmap.htm
@@ -116,6 +116,7 @@ combined base/GUI library for GUI applications only.
 <li>Release date: c. July 2nd, 2000
 <li>Unicode compilation working in wxGTK and wxMSW.
 <li>wxDateTime class.
+<li>Regular expressions support.
 </ul>

 <P>
--- a/docs/html/standard.htm
+++ b/docs/html/standard.htm
@@ -50,6 +50,7 @@ C++ portability guide</A> by David Williams.
    <LI><A HREF="#no_stl">Don't use STL</A></LI>
    <LI><A HREF="#no_fordecl">Don't declare variables inside <TT>for()</TT></A></LI>
    <LI><A HREF="#no_nestedclasses">Don't use nested classes</A></LI>
+    <LI><A HREF="#no_ternarywithobjects">Use ternary operator ?: carefully</A></LI>
  </OL>
  <BR>
  <LI>General recommendations</LI>
@@ -332,6 +333,25 @@ you can try the following:
 <P>A nice side effect is that you don't need to recompile all the files
 including the header if you change the PrivateLibClass declaration (it's
 an example of a more general interface/implementation separation idea).
+
+  <P><LI><A NAME="no_ternarywithobjects"></A><B>Use ternary operator ?: carefully</B></LI><P>
+  The ternary operator <TT>?:</TT> shouldn't be used with objects (i.e. if any
+of its operands are objects) because some compilers (notable Borland C++) fail
+to compile such code.
+<P><U>Workaround</U>: use <TT>if/else</TT> instead.
+<PRE>
+    wxString s1, s2;
+
+    // Borland C++ won't compile the line below
+    wxString s = s1.Len() < s2.Len() ? s1 : s2;
+
+    // but any C++ compiler will compile this
+    wxString s;
+    if ( s1.Len() < s2.Len() )
+        s = s1;
+    else
+        s = s2;
+</PRE>
 </OL>

  <BR>
--- a/docs/latex/wx/dc.tex
+++ b/docs/latex/wx/dc.tex
@@ -418,6 +418,9 @@ Gets the current pen (see \helpref{wxDC::SetPen}{wxdcsetpen}).
 Sets {\it colour} to the colour at the specified location. Windows only; an X implementation
 is being worked on. Not available for wxPostScriptDC or wxMetafileDC.

+\pythonnote{For wxPython the wxColour value is returned and is not
+required as a parameter.}
+
 \membersection{wxDC::GetSize}\label{wxdcgetsize}

 \func{void}{GetSize}{\param{long *}{width}, \param{long *}{height}}
--- a/docs/latex/wx/listctrl.tex
+++ b/docs/latex/wx/listctrl.tex
@@ -376,6 +376,10 @@ giving details in {\it flags}. {\it flags} will be a combination of the followin
 wxLIST\_HITTEST\_ONITEMSTATEICON.}
 \end{twocollist}

+\pythonnote{A tuple of values is returned in the wxPython version of
+thsi method.  The first value is the item id and the second is the
+flags value mentioned above.}
+
 \membersection{wxListCtrl::InsertColumn}\label{wxlistctrlinsertcolumn}

 \func{long}{InsertColumn}{\param{long }{col}, \param{wxListItem\& }{info}}
--- a/docs/latex/wx/log.tex
+++ b/docs/latex/wx/log.tex
@@ -52,6 +52,7 @@ empty, {\it HasPendingMessages()} is also provided which allows to explicitly
 verify it.

 \helpref{Flush}{wxlogflush}\\
+\helpref{FlushActive}{wxlogflushactive}\\
 \helpref{HasPendingMessages}{haspendingmessages}

 \membersection{Customization}\label{wxlogcustomization}
@@ -142,6 +143,16 @@ currently. (Almost) for internal use only.
 Shows all the messages currently in buffer and clears it. If the buffer
 is already empty, nothing happens.

+\membersection{wxLog::FlushActive}\label{wxlogflushactive}
+
+\func{static void}{FlushActive}{\void}
+
+Flushes the current log target if any, does nothing if there is none.
+
+See also:
+
+\helpref{Flush}{wxlogflush}
+
 \membersection{wxLog::HasPendingMessages}\label{haspendingmessages}

 \constfunc{bool}{HasPendingMessages}{\void}
--- a/docs/latex/wx/topics.tex
+++ b/docs/latex/wx/topics.tex
@@ -9,6 +9,7 @@ This chapter contains a selection of topic overviews.
 \input tcontain.tex
 \input tlog.tex
 \input tconfig.tex
+\input tunicode.tex
 \input tbitmap.tex
 \input tdialog.tex
 \input tfont.tex
--- a/docs/latex/wx/wxPython.tex
+++ b/docs/latex/wx/wxPython.tex
@@ -365,10 +365,11 @@ as possible to the C++ spec over time.
 \item \helpref{wxBitmapButton}{wxbitmapbutton}
 \item \helpref{wxBitmap}{wxbitmap}
 \item wxBMPHandler
-\item \helpref{wxBoxSizer}{wxBoxSizer}
+\item \helpref{wxBoxSizer}{wxboxsizer}
 \item \helpref{wxBrush}{wxbrush}
 \item \helpref{wxButton}{wxbutton}
 \item \helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent}
+\item wxCaret
 \item \helpref{wxCheckBox}{wxcheckbox}
 \item \helpref{wxCheckListBox}{wxchecklistbox}
 \item \helpref{wxChoice}{wxchoice}
@@ -401,14 +402,14 @@ as possible to the C++ spec over time.
 \item wxGridCell
 \item wxGridEvent
 \item \helpref{wxGrid}{wxgrid}
-\item \helpref{wxHtmlCell}{wxHtmlCell}
-\item \helpref{wxHtmlContainerCell}{wxHtmlContainerCell}
-\item \helpref{wxHtmlParser}{wxHtmlParser}
-\item \helpref{wxHtmlTagHandler}{wxHtmlTagHandler}
-\item \helpref{wxHtmlTag}{wxHtmlTag}
-\item \helpref{wxHtmlWinParser}{wxHtmlWinParser}
-\item \helpref{wxHtmlWinTagHandler}{wxHtmlWinTagHandler}
-\item \helpref{wxHtmlWindow}{wxHtmlWindow}
+\item \helpref{wxHtmlCell}{wxhtmlcell}
+\item \helpref{wxHtmlContainerCell}{wxhtmlcontainercell}
+\item \helpref{wxHtmlParser}{wxhtmlparser}
+\item \helpref{wxHtmlTagHandler}{wxhtmltaghandler}
+\item \helpref{wxHtmlTag}{wxhtmltag}
+\item \helpref{wxHtmlWinParser}{wxhtmlwinparser}
+\item \helpref{wxHtmlWinTagHandler}{wxhtmlwintaghandler}
+\item \helpref{wxHtmlWindow}{wxhtmlwindow}
 \item wxIconizeEvent
 \item \helpref{wxIcon}{wxicon}
 \item \helpref{wxIdleEvent}{wxidleevent}
@@ -480,7 +481,7 @@ as possible to the C++ spec over time.
 \item \helpref{wxSingleChoiceDialog}{wxsinglechoicedialog}
 \item \helpref{wxSizeEvent}{wxsizeevent}
 \item \helpref{wxSize}{wxsize}
-\item \helpref{wxSizer}{wxSizer}
+\item \helpref{wxSizer}{wxsizer}
 \item wxSizerItem
 \item \helpref{wxSlider}{wxslider}
 \item \helpref{wxSpinButton}{wxspinbutton}
@@ -488,7 +489,7 @@ as possible to the C++ spec over time.
 \item \helpref{wxSplitterWindow}{wxsplitterwindow}
 \item \helpref{wxStaticBitmap}{wxstaticbitmap}
 \item \helpref{wxStaticBox}{wxstaticbox}
-\item \helpref{wxStaticBoxSizer}{wxStaticBoxSizer}
+\item \helpref{wxStaticBoxSizer}{wxstaticboxsizer}
 \item wxStaticLine
 \item \helpref{wxStaticText}{wxstatictext}
 \item \helpref{wxStatusBar}{wxstatusbar}
--- a/include/wx/app.h
+++ b/include/wx/app.h
@@ -37,7 +37,9 @@

 #include "wx/event.h"       // for the base class

-#include "wx/window.h"      // for wxTopLevelWindows
+#if wxUSE_GUI
+    #include "wx/window.h"      // for wxTopLevelWindows
+#endif // wxUSE_GUI

 #if wxUSE_LOG
    #include "wx/log.h"
@@ -64,22 +66,33 @@ public:
        // prevents the program from continuing - it's a good place to create
        // the top level program window and return TRUE.
        //
-        // Override: always.
+        // Override: always in GUI application, rarely in console ones.
+#if wxUSE_GUI
    virtual bool OnInit() { return FALSE; };
+#else // !GUI
+    virtual bool OnInit() { return TRUE; };
+#endif // wxUSE_GUI

+#if wxUSE_GUI
        // a platform-dependent version of OnInit(): the code here is likely to
        // depend on the toolkit. default version does nothing.
        //
        // Override: rarely.
    virtual bool OnInitGui() { return TRUE; }
+#endif // wxUSE_GUI

        // called to start program execution - the default version just enters
        // the main GUI loop in which events are received and processed until
        // the last window is not deleted (if GetExitOnFrameDelete) or
-        // ExitMainLoop() is called.
+        // ExitMainLoop() is called. In console mode programs, the execution
+        // of the program really starts here
        //
-        // Override: rarely.
+        // Override: rarely in GUI applications, always in console ones.
+#if wxUSE_GUI
    virtual int OnRun() { return MainLoop(); };
+#else // !GUI
+    virtual int OnRun() = 0;
+#endif // wxUSE_GUI

        // called after the main loop termination. This is a good place for
        // cleaning up (it may be too late in dtor) and is also useful if you
@@ -102,6 +115,7 @@ public:
    // the worker functions - usually not used directly by the user code
    // -----------------------------------------------------------------

+#if wxUSE_GUI
        // execute the main GUI loop, the function returns when the loop ends
    virtual int MainLoop() = 0;

@@ -118,6 +132,7 @@ public:
        // process the first event in the event queue (blocks until an event
        // apperas if there are none currently)
    virtual void Dispatch() = 0;
+#endif // wxUSE_GUI

    // application info: name, description, vendor
    // -------------------------------------------
@@ -144,6 +159,7 @@ public:
    const wxString& GetVendorName() const { return m_vendorName; }
    void SetVendorName(const wxString& name) { m_vendorName = name; }

+#if wxUSE_GUI
    // top level window functions
    // --------------------------

@@ -171,6 +187,8 @@ public:
    void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
    bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }

+#endif // wxUSE_GUI
+
    // miscellaneous customization functions
    // -------------------------------------

@@ -179,10 +197,15 @@ public:
        // user-defined class (default implementation creates a wxLogGui
        // object) - this log object is used by default by all wxLogXXX()
        // functions.
-    virtual wxLog *CreateLogTarget() { return new wxLogGui; }
+    virtual wxLog *CreateLogTarget()
+#if wxUSE_GUI
+        { return new wxLogGui; }
+#else // !GUI
+        { return new wxLogStderr; }
+#endif // wxUSE_GUI
 #endif // wxUSE_LOG

-
+#if wxUSE_GUI
        // get the standard icon used by wxWin dialogs - this allows the user
        // to customize the standard dialogs. The 'which' parameter is one of
        // wxICON_XXX values
@@ -198,6 +221,7 @@ public:
        // printing.
    virtual void SetPrintMode(int WXUNUSED(mode)) { }
    int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
+#endif // wxUSE_GUI

    // implementation only from now on
    // -------------------------------
@@ -228,29 +252,35 @@ protected:
    // TRUE if the application wants to get debug output
    bool m_wantDebugOutput;

+#if wxUSE_GUI
    // the main top level window - may be NULL
    wxWindow *m_topWindow;
+#endif // wxUSE_GUI
 };

 // ----------------------------------------------------------------------------
 // now include the declaration of the real class
 // ----------------------------------------------------------------------------

-#if defined(__WXMSW__)
-    #include "wx/msw/app.h"
-#elif defined(__WXMOTIF__)
-    #include "wx/motif/app.h"
-#elif defined(__WXQT__)
-    #include "wx/qt/app.h"
-#elif defined(__WXGTK__)
-    #include "wx/gtk/app.h"
-#elif defined(__WXMAC__)
-    #include "wx/mac/app.h"
-#elif defined(__WXPM__)
-    #include "wx/os2/app.h"
-#elif defined(__WXSTUBS__)
-    #include "wx/stubs/app.h"
-#endif
+#if wxUSE_GUI
+    #if defined(__WXMSW__)
+        #include "wx/msw/app.h"
+    #elif defined(__WXMOTIF__)
+        #include "wx/motif/app.h"
+    #elif defined(__WXQT__)
+        #include "wx/qt/app.h"
+    #elif defined(__WXGTK__)
+        #include "wx/gtk/app.h"
+    #elif defined(__WXMAC__)
+        #include "wx/mac/app.h"
+    #elif defined(__WXPM__)
+        #include "wx/os2/app.h"
+    #elif defined(__WXSTUBS__)
+        #include "wx/stubs/app.h"
+    #endif
+#else // !GUI
+    typedef wxAppBase wxApp;
+#endif // GUI/!GUI

 // ----------------------------------------------------------------------------
 // the global data
@@ -266,11 +296,34 @@ WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
 // global functions
 // ----------------------------------------------------------------------------

+// event loop related functions only work in GUI programs
+// ------------------------------------------------------
+
+#if wxUSE_GUI
+
 // Force an exit from main loop
-void WXDLLEXPORT wxExit();
+extern void WXDLLEXPORT wxExit();

 // Yield to other apps/messages
-bool WXDLLEXPORT wxYield();
+extern bool WXDLLEXPORT wxYield();
+
+#endif // wxUSE_GUI
+
+// console applications may avoid using DECLARE_APP and IMPLEMENT_APP macros
+// and call these functions instead at the program startup and termination
+// -------------------------------------------------------------------------
+
+#if wxUSE_NOGUI
+
+// initialize the library (may be called as many times as needed, but each
+// call to wxInitialize() must be matched by wxUninitialize())
+extern bool WXDLLEXPORT wxInitialize();
+
+// clean up - the library can't be used any more after the last call to
+// wxUninitialize()
+extern void WXDLLEXPORT wxUninitialize();
+
+#endif // wxUSE_NOGUI

 // ----------------------------------------------------------------------------
 // macros for dynamic creation of the application object
--- a/include/wx/arrimpl.cpp
+++ b/include/wx/arrimpl.cpp
@@ -2,7 +2,7 @@
 // Name:        listimpl.cpp
 // Purpose:     helper file for implementation of dynamic lists
 // Author:      Vadim Zeitlin
-// Modified by: 
+// Modified by:
 // Created:     16.10.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1997 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
@@ -20,6 +20,9 @@
 *          4) WX_DEFINE_OBJARRAY                                            *
 *****************************************************************************/

+// needed to resolve the conflict between global T and macro parameter T
+#define _WX_ERROR_REMOVE2(x)     T("bad index in " #x "::Remove()")
+
 // macro implements remaining (not inline) methods of template list
 // (it's private to this file)
 #undef  _DEFINE_OBJARRAY
@@ -58,7 +61,7 @@ void name::Empty()                                                            \
                                                                              \
 void name::Remove(size_t uiIndex)                                             \
 {                                                                             \
-  wxCHECK_RET( uiIndex < Count(), _T("bad index in " #name "::Remove()") );   \
+  wxCHECK_RET( uiIndex < Count(), _WX_ERROR_REMOVE2(name) );                  \
                                                                              \
  delete (T*)wxBaseArray::Item(uiIndex);                                      \
                                                                              \
@@ -99,8 +102,8 @@ int name::Index(const T& Item, bool bFromEnd) const                           \
    }                                                                         \
  }                                                                           \
                                                                              \
-  return wxNOT_FOUND;                                                           \
-}                                                                             
+  return wxNOT_FOUND;                                                         \
+}

 // redefine the macro so that now it will generate the class implementation
 // old value would provoke a compile-time error if this file is not included
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -15,6 +15,7 @@
 #define _WX_BUFFER_H

 #include "wx/wxchar.h"
+
 #include <string.h> // strdup

 // ----------------------------------------------------------------------------
@@ -27,14 +28,14 @@ class wxCharBuffer
 public:
    wxCharBuffer(const char *str)
    {
-        wxASSERT_MSG( str, _T("NULL string in wxCharBuffer") );
+        wxASSERT_MSG( str, T("NULL string in wxCharBuffer") );

        m_str = str ? strdup(str) : (char *)NULL;
    }
    wxCharBuffer(size_t len)
    {
        m_str = (char *)malloc(len+1);
-	m_str[len] = '\0';
+        m_str[len] = '\0';
    }
    // no need to check for NULL, free() does it
   ~wxCharBuffer() { free(m_str); }
@@ -66,7 +67,7 @@ class wxWCharBuffer
 public:
    wxWCharBuffer(const wchar_t *wcs)
    {
-        wxASSERT_MSG( wcs, _T("NULL string in wxWCharBuffer") );
+        wxASSERT_MSG( wcs, T("NULL string in wxWCharBuffer") );

        if (wcs) {
          size_t siz = (wcslen(wcs)+1)*sizeof(wchar_t);
@@ -78,7 +79,7 @@ public:
    wxWCharBuffer(size_t len)
    {
        m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));
-	m_wcs[len] = L'\0';
+        m_wcs[len] = L'\0';
    }

    // no need to check for NULL, free() does it
@@ -100,23 +101,23 @@ public:

   operator const wchar_t *() const { return m_wcs; }
   wchar_t operator[](size_t n) const { return m_wcs[n]; }
-          
+
 private:
   wchar_t *m_wcs;
 };
 #endif

 #if wxUSE_UNICODE
-#define wxMB2WXbuf wxWCharBuffer
-#define wxWX2MBbuf wxCharBuffer
-#define wxWC2WXbuf wxChar*
-#define wxWX2WCbuf wxChar*
-#else
-#define wxMB2WXbuf wxChar*
-#define wxWX2MBbuf wxChar*
-#define wxWC2WXbuf wxCharBuffer
-#define wxWX2WCbuf wxWCharBuffer
-#endif
+    #define wxMB2WXbuf wxWCharBuffer
+    #define wxWX2MBbuf wxCharBuffer
+    #define wxWC2WXbuf wxChar*
+    #define wxWX2WCbuf wxChar*
+#else // ANSI
+    #define wxMB2WXbuf wxChar*
+    #define wxWX2MBbuf wxChar*
+    #define wxWC2WXbuf wxCharBuffer
+    #define wxWX2WCbuf wxWCharBuffer
+#endif // Unicode/ANSI

 // ----------------------------------------------------------------------------
 // template class for any kind of data
--- a/include/wx/debug.h
+++ b/include/wx/debug.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        debug.h
+// Name:        wx/debug.h
 // Purpose:     Misc debug functions and macros
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence:   	wxWindows license
+// Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////

 #ifndef   _WX_DEBUG_H_
@@ -16,24 +16,19 @@

 #include  "wx/wxchar.h"

-#ifndef __TFILE__
-#define __XFILE__(x) _T(x)
-#define __TFILE__ __XFILE__(__FILE__)
-#endif
-
 // ----------------------------------------------------------------------------
-/** 
-  @name Debugging macros 
+/**
+  @name Debugging macros

  All debugging macros rely on ASSERT() which in turn calls user-defined
  OnAssert() function. To keep things simple, it's called even when the
  expression is TRUE (i.e. everything is ok) and by default does nothing: just
  returns the same value back. But if you redefine it to do something more sexy
-  (popping up a message box in your favourite GUI, sending you e-mail or 
+  (popping up a message box in your favourite GUI, sending you e-mail or
  whatever) it will affect all ASSERTs, FAILs and CHECKs in your code.
  <BR>
  <BR>
-  <b>Warning</b>: if you don't like advices on programming style, don't read 
+  <b>Warning</b>: if you don't like advices on programming style, don't read
  further! ;-)
  <BR>
  <BR>
@@ -94,13 +89,13 @@

 // NB: these macros work also in release mode!

-/** 
+/**
  These macros must be used only in invalid situation: for example, an
  invalid parameter (NULL pointer) is passed to a function. Instead of
  dereferencing it and causing core dump the function might try using
  CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )

-  @name Macros which remain even in 'release' mode 
+  @name Macros which remain even in 'release' mode
 */
 //@{
  /// check that expression is true, "return" if not (also FAILs in debug mode)
--- a/include/wx/defs.h
+++ b/include/wx/defs.h
@@ -115,13 +115,11 @@
 #   pragma suppress 571             // Virtual function hiding
 #endif // __SALFORDC__

-#ifdef __VISUALC__
-#ifndef WIN32
-// VC1.5 does not have LPTSTR type
-#define LPTSTR LPSTR
-#define LPCTSTR LPCSTR
-#endif
-#endif
+#if defined(__VISUALC__) && !defined(WIN32)
+    // VC1.5 does not have LPTSTR type
+    #define LPTSTR LPSTR
+    #define LPCTSTR LPCSTR
+#endif // VC++ 1.5

 // Digital Unix C++ compiler only defines this symbol for .cxx and .hxx files,
 // so define it ourselves
@@ -190,8 +188,9 @@
 // Make sure the environment is set correctly
 #if defined(__WXMSW__) && defined(__X__)
    #error "Target can't be both X and Windows"
-#elif !defined(__WXMOTIF__) && !defined(__WXMSW__) && !defined(__WXGTK__) && !defined(__WXPM__) && \
-      !defined(__WXMAC__) && !defined(__X__) && !defined(__WXQT__) && !defined(__WXSTUBS__)
+#elif !defined(__WXMOTIF__) && !defined(__WXMSW__) && !defined(__WXGTK__) && \
+      !defined(__WXPM__) && !defined(__WXMAC__) && !defined(__X__) && \
+      !defined(__WXQT__) && !defined(__WXSTUBS__) && wxUSE_GUI
    #error "No Target! Use -D[__WXMOTIF__|__WXGTK__|__WXMSW__|__WXMAC__|__WXQT__|__WXPM__|__WXSTUBS__]"
 #endif

@@ -215,6 +214,17 @@

 #include "wx/version.h"

+// ----------------------------------------------------------------------------
+// compatibility defines
+// ----------------------------------------------------------------------------
+
+// possibility to build non GUI apps is new, so don't burden ourselves with
+// compatibility code
+#if !wxUSE_GUI
+    #undef WXWIN_COMPATIBILITY_2
+    #define WXWIN_COMPATIBILITY_2 0
+#endif // !GUI
+
 // ============================================================================
 // non portable C++ features
 // ============================================================================
@@ -223,21 +233,14 @@
 // check for native bool type and TRUE/FALSE constants
 // ----------------------------------------------------------------------------

-#if defined(__WXMOTIF__) || defined(__WXGTK__) || defined(__WXQT__) || defined(__WXPM__) || defined(__WXSTUBS__)
-    // Bool is now obsolete, use bool instead
-    // typedef int Bool;
+// define boolean constants if not done yet
+#ifndef TRUE
+    #define TRUE  1
+#endif

-    #ifndef TRUE
-        #define TRUE  1
-        #define FALSE 0
-        #define Bool_DEFINED
-    #endif
-#elif defined(__WXMSW__)
-    #ifndef TRUE
-        #define TRUE  1
-        #define FALSE 0
-    #endif
-#endif // TRUE/FALSE
+#ifndef FALSE
+    #define FALSE 0
+#endif

 // Add more tests here for Windows compilers that already define bool
 // (under Unix, configure tests for this)
--- a/include/wx/dialup.h
+++ b/include/wx/dialup.h
@@ -24,7 +24,7 @@

 extern const wxChar *wxEmptyString;

-#define WXDIALUP_MANAGER_DEFAULT_BEACONHOST  _T("www.yahoo.com")
+#define WXDIALUP_MANAGER_DEFAULT_BEACONHOST  T("www.yahoo.com")

 // ----------------------------------------------------------------------------
 // A class which groups functions dealing with connecting to the network from a
@@ -78,7 +78,7 @@ public:
                      bool async = TRUE) = 0;

    // returns TRUE if (async) dialing is in progress
-    virtual bool IsDialling() const = 0;
+    virtual bool IsDialing() const = 0;

    // cancel dialing the number initiated with Dial(async = TRUE)
    // NB: this won't result in DISCONNECTED event being sent
@@ -129,8 +129,8 @@ public:
    // Sets the commands to start up the network and to hang up again. Used by
    // the Unix implementations only.
    virtual void
-    SetConnectCommand(const wxString& commandDial = _T("/usr/bin/pon"),
-                      const wxString& commandHangup = _T("/usr/bin/poff")) = 0;
+    SetConnectCommand(const wxString& commandDial = T("/usr/bin/pon"),
+                      const wxString& commandHangup = T("/usr/bin/poff")) = 0;
 };

 // ----------------------------------------------------------------------------
--- a/include/wx/dynarray.h
+++ b/include/wx/dynarray.h
@@ -151,6 +151,11 @@ private:
 // template classes
 // ============================================================================

+// resolves the name conflict between the T() macor and T typedef: we can't
+// use T() inside WX_DEFINE_ARRAY!
+#define _WX_ERROR_SIZEOF   T("illegal use of DEFINE_ARRAY")
+#define _WX_ERROR_REMOVE   T("removing inexisting element in wxArray::Remove")
+
 // ----------------------------------------------------------------------------
 // This macro generates a new array class. It is intended for storage of simple
 // types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
@@ -170,7 +175,7 @@ public:                                                             \
    size_t type = sizeof(T);                                        \
    size_t sizelong = sizeof(long);                                 \
    if ( type > sizelong )                                          \
-      { wxFAIL_MSG( _T("illegal use of DEFINE_ARRAY") ); }          \
+      { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
  }                                                                 \
                                                                    \
  name& operator=(const name& src)                                  \
@@ -197,7 +202,7 @@ public:                                                             \
  void Remove(T Item)                                               \
    { int iIndex = Index(Item);                                     \
      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
-        _T("removing inexisting element in wxArray::Remove") );     \
+         _WX_ERROR_REMOVE);                                         \
      wxBaseArray::Remove((size_t)iIndex); }                        \
                                                                    \
  void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
@@ -232,7 +237,7 @@ public:                                                             \
  { size_t type = sizeof(T);                                        \
    size_t sizelong = sizeof(long);                                 \
    if ( type > sizelong )                                          \
-      { wxFAIL_MSG( _T("illegal use of DEFINE_ARRAY") ); }          \
+      { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
    m_fnCompare = fn;                                               \
  }                                                                 \
                                                                    \
@@ -259,7 +264,7 @@ public:                                                             \
  void Remove(T Item)                                               \
    { int iIndex = Index(Item);                                     \
      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
-        _T("removing inexisting element in wxArray::Remove") );     \
+        _WX_ERROR_REMOVE );                                         \
      wxBaseArray::Remove((size_t)iIndex); }                        \
                                                                    \
 private:                                                            \
--- a/include/wx/event.h
+++ b/include/wx/event.h
@@ -18,16 +18,31 @@

 #include "wx/defs.h"
 #include "wx/object.h"
-#include "wx/gdicmn.h"
+
+#if wxUSE_GUI
+    #include "wx/gdicmn.h"
+#endif

 #if wxUSE_THREADS
    #include "wx/thread.h"
 #endif

-/*
- * Event types
- *
- */
+// ----------------------------------------------------------------------------
+// forward declarations
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxList;
+
+#if wxUSE_GUI
+    class WXDLLEXPORT wxClientData;
+    class WXDLLEXPORT wxDC;
+    class WXDLLEXPORT wxMenu;
+    class WXDLLEXPORT wxWindow;
+#endif // wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// Event types
+// ----------------------------------------------------------------------------

 typedef int wxEventType;

@@ -336,6 +351,8 @@ public:
    bool              m_isCommandEvent;
 };

+#if wxUSE_GUI
+
 // Item or menu event class
 /*
 wxEVT_COMMAND_BUTTON_CLICKED
@@ -354,8 +371,6 @@ public:
 wxEVT_COMMAND_COMBOBOX_SELECTED
 */

-class WXDLLEXPORT wxClientData;
-
 class WXDLLEXPORT wxCommandEvent : public wxEvent
 {
    DECLARE_DYNAMIC_CLASS(wxCommandEvent)
@@ -523,7 +538,6 @@ public:
 wxEVT_NC_RIGHT_DCLICK,
 */

-class WXDLLEXPORT wxDC;
 class WXDLLEXPORT wxMouseEvent : public wxEvent
 {
    DECLARE_DYNAMIC_CLASS(wxMouseEvent)
@@ -764,7 +778,6 @@ public:
 wxEVT_ERASE_BACKGROUND
 */

-class WXDLLEXPORT wxDC;
 class WXDLLEXPORT wxEraseEvent : public wxEvent
 {
    DECLARE_DYNAMIC_CLASS(wxEraseEvent)
@@ -884,7 +897,7 @@ public:
    {
        // GetVeto() will return FALSE anyhow...
        wxCHECK_RET( m_canVeto,
-                     _T("call to Veto() ignored (can't veto this event)") );
+                     T("call to Veto() ignored (can't veto this event)") );

        m_veto = veto;
    }
@@ -1069,36 +1082,11 @@ public:
    void CopyObject(wxObject& obj) const;
 };

-// Idle event
-/*
- wxEVT_IDLE
- */
-
-class WXDLLEXPORT wxIdleEvent : public wxEvent
-{
-    DECLARE_DYNAMIC_CLASS(wxIdleEvent)
-
-public:
-    wxIdleEvent()
-        { m_eventType = wxEVT_IDLE; m_requestMore = FALSE; }
-
-    void RequestMore(bool needMore = TRUE) { m_requestMore = needMore; }
-    bool MoreRequested() const { return m_requestMore; }
-
-    void CopyObject(wxObject& obj) const;
-
-protected:
-    bool m_requestMore;
-};
-
 // Update UI event
 /*
 wxEVT_UPDATE_UI
 */

-class WXDLLEXPORT wxMenu;
-class WXDLLEXPORT wxWindow;
-
 class WXDLLEXPORT wxUpdateUIEvent : public wxCommandEvent
 {
    DECLARE_DYNAMIC_CLASS(wxUpdateUIEvent)
@@ -1256,6 +1244,30 @@ public:
    wxWindow *GetWindow() const { return (wxWindow *)GetEventObject(); }
 };

+#endif // wxUSE_GUI
+
+// Idle event
+/*
+ wxEVT_IDLE
+ */
+
+class WXDLLEXPORT wxIdleEvent : public wxEvent
+{
+    DECLARE_DYNAMIC_CLASS(wxIdleEvent)
+
+public:
+    wxIdleEvent()
+        { m_eventType = wxEVT_IDLE; m_requestMore = FALSE; }
+
+    void RequestMore(bool needMore = TRUE) { m_requestMore = needMore; }
+    bool MoreRequested() const { return m_requestMore; }
+
+    void CopyObject(wxObject& obj) const;
+
+protected:
+    bool m_requestMore;
+};
+
 /* TODO
 wxEVT_POWER,
 wxEVT_MOUSE_CAPTURE_CHANGED,
@@ -1267,11 +1279,6 @@ public:
 wxEVT_COMPARE_ITEM
 */

-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxControl;
-
-// struct WXDLLEXPORT wxEventTableEntry;
-
 typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);

 struct WXDLLEXPORT wxEventTableEntry
@@ -1312,7 +1319,7 @@ public:
    virtual void OnCommand(wxWindow& WXUNUSED(win),
                           wxCommandEvent& WXUNUSED(event))
    {
-        wxFAIL_MSG(_T("shouldn't be called any more"));
+        wxFAIL_MSG(T("shouldn't be called any more"));
    }

    // Called if child control has no callback function
@@ -1373,6 +1380,7 @@ protected:
 };

 typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
+#if wxUSE_GUI
 typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
 typedef void (wxEvtHandler::*wxScrollEventFunction)(wxScrollEvent&);
 typedef void (wxEvtHandler::*wxScrollWinEventFunction)(wxScrollWinEvent&);
@@ -1398,6 +1406,7 @@ typedef void (wxEvtHandler::*wxMaximizeEventFunction)(wxShowEvent&);
 typedef void (wxEvtHandler::*wxNavigationKeyEventFunction)(wxNavigationKeyEvent&);
 typedef void (wxEvtHandler::*wxPaletteChangedEventFunction)(wxPaletteChangedEvent&);
 typedef void (wxEvtHandler::*wxQueryNewPaletteEventFunction)(wxQueryNewPaletteEvent&);
+#endif // wxUSE_GUI

 // N.B. In GNU-WIN32, you *have* to take the address of a member function
 // (use &) or the compiler crashes...
@@ -1603,13 +1612,17 @@ const wxEventTableEntry theClass::sm_eventTableEntries[] = { \
 #define EVT_UPDATE_UI(id, func) \
 { wxEVT_UPDATE_UI, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxUpdateUIEventFunction) & func, (wxObject *) NULL },\

-/*
- * Helper functions
- */
+// ----------------------------------------------------------------------------
+// Helper functions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_GUI

 // Find a window with the focus, that is also a descendant of the given window.
 // This is used to determine the window to initially send commands to.
 wxWindow* wxFindFocusDescendant(wxWindow* ancestor);

+#endif // wxUSE_GUI
+
 #endif
        // _WX_EVENTH__
--- a/include/wx/ffile.h
+++ b/include/wx/ffile.h
@@ -51,7 +51,7 @@ public:
  bool Close();

  // assign an existing file descriptor and get it back from wxFFile object
-  void Attach(FILE *fp, const wxString& name = _T(""))
+  void Attach(FILE *fp, const wxString& name = T(""))
    { Close(); m_fp = fp; m_name = name; }
  void Detach() { m_fp = NULL; }
  FILE *fp() const { return m_fp; }
--- a/include/wx/fileconf.h
+++ b/include/wx/fileconf.h
@@ -141,9 +141,9 @@ public:
    // New constructor: one size fits all. Specify wxCONFIG_USE_LOCAL_FILE or
    // wxCONFIG_USE_GLOBAL_FILE to say which files should be used.
  wxFileConfig(const wxString& appName,
-               const wxString& vendorName = _T(""),
-               const wxString& localFilename = _T(""),
-               const wxString& globalFilename = _T(""),
+               const wxString& vendorName = T(""),
+               const wxString& localFilename = T(""),
+               const wxString& globalFilename = T(""),
               long style = wxCONFIG_USE_LOCAL_FILE);

    // dtor will save unsaved data
--- a/include/wx/filefn.h
+++ b/include/wx/filefn.h
@@ -159,15 +159,15 @@ WXDLLEXPORT bool wxMkdir(const wxString& dir, int perm = 0777);
 WXDLLEXPORT bool wxRmdir(const wxString& dir, int flags = 0);

 // separators in file names
-#define wxFILE_SEP_EXT        _T('.')
-#define wxFILE_SEP_DSK        _T(':')
-#define wxFILE_SEP_PATH_DOS   _T('\\')
-#define wxFILE_SEP_PATH_UNIX  _T('/')
+#define wxFILE_SEP_EXT        T('.')
+#define wxFILE_SEP_DSK        T(':')
+#define wxFILE_SEP_PATH_DOS   T('\\')
+#define wxFILE_SEP_PATH_UNIX  T('/')

 // separator in the path list (as in PATH environment variable)
 // NB: these are strings and not characters on purpose!
-#define wxPATH_SEP_DOS        _T(";")
-#define wxPATH_SEP_UNIX       _T(":")
+#define wxPATH_SEP_DOS        T(";")
+#define wxPATH_SEP_UNIX       T(":")

 // platform independent versions
 #ifdef  __UNIX__
--- a/include/wx/fontenum.h
+++ b/include/wx/fontenum.h
@@ -32,7 +32,7 @@ public:
    // enumerate the different encodings either for given font family or for
    // all font families - will result in OnFontEncoding() being called for
    // each available (family, encoding) couple
-    virtual bool EnumerateEncodings(const wxString& family = _T(""));
+    virtual bool EnumerateEncodings(const wxString& family = T(""));

    // callbacks which are called after one of EnumerateXXX() functions from
    // above is invoked - all of them may return FALSE to stop enumeration or
--- a/include/wx/generic/filedlgg.h
+++ b/include/wx/generic/filedlgg.h
@@ -100,7 +100,7 @@ public:
                const wxSize &size = wxDefaultSize,
                long style = wxLC_LIST,
                const wxValidator &validator = wxDefaultValidator,
-                const wxString &name = _T("filelist") );
+                const wxString &name = T("filelist") );
    void ChangeToListMode();
    void ChangeToReportMode();
    void ChangeToIconMode();
--- a/include/wx/generic/progdlgg.h
+++ b/include/wx/generic/progdlgg.h
@@ -54,7 +54,7 @@ public:
       @param newmsg if used, new message to display
       @returns true if ABORT button has not been pressed
   */
-   bool Update(int value = -1, const wxString& newmsg = _T(""));
+   bool Update(int value = -1, const wxString& newmsg = T(""));

   /* Can be called to continue after the cancel button has been pressed, but
       the program decided to continue the operation (e.g., user didn't
--- a/include/wx/gtk/frame.h
+++ b/include/wx/gtk/frame.h
@@ -64,7 +64,7 @@ public:

 #if wxUSE_STATUSBAR
    virtual wxStatusBar* CreateStatusBar(int number=1, long style = wxST_SIZEGRIP, wxWindowID id = 0,
-            const wxString& name = _T("statusBar"));
+            const wxString& name = T("statusBar"));
    virtual wxStatusBar *OnCreateStatusBar( int number, long style, wxWindowID id,
            const wxString& name );
    virtual wxStatusBar *GetStatusBar() const;
--- a/include/wx/gtk/mdi.h
+++ b/include/wx/gtk/mdi.h
@@ -121,8 +121,12 @@ class wxMDIChildFrame: public wxFrame
    
 #if wxUSE_STATUSBAR
    // no status bars
-  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number)=1, long WXUNUSED(style)=1, 
-    wxWindowID WXUNUSED(id)=1, const wxString& WXUNUSED(name)=WXSTRINGCAST NULL ) {return (wxStatusBar*)NULL; }
+  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number) = 1,
+                                        long WXUNUSED(style) = 1, 
+                                        wxWindowID WXUNUSED(id) = 1,
+                                        const wxString& WXUNUSED(name) = wxEmptyString)
+    { return (wxStatusBar*)NULL; }
+
  virtual wxStatusBar *GetStatusBar() const { return (wxStatusBar*)NULL; }
  virtual void SetStatusText( const wxString &WXUNUSED(text), int WXUNUSED(number)=0 ) {}
  virtual void SetStatusWidths( int WXUNUSED(n), const int WXUNUSED(widths_field)[] ) {}
--- a/include/wx/gtk1/frame.h
+++ b/include/wx/gtk1/frame.h
@@ -64,7 +64,7 @@ public:

 #if wxUSE_STATUSBAR
    virtual wxStatusBar* CreateStatusBar(int number=1, long style = wxST_SIZEGRIP, wxWindowID id = 0,
-            const wxString& name = _T("statusBar"));
+            const wxString& name = T("statusBar"));
    virtual wxStatusBar *OnCreateStatusBar( int number, long style, wxWindowID id,
            const wxString& name );
    virtual wxStatusBar *GetStatusBar() const;
--- a/include/wx/gtk1/mdi.h
+++ b/include/wx/gtk1/mdi.h
@@ -121,8 +121,12 @@ class wxMDIChildFrame: public wxFrame
    
 #if wxUSE_STATUSBAR
    // no status bars
-  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number)=1, long WXUNUSED(style)=1, 
-    wxWindowID WXUNUSED(id)=1, const wxString& WXUNUSED(name)=WXSTRINGCAST NULL ) {return (wxStatusBar*)NULL; }
+  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number) = 1,
+                                        long WXUNUSED(style) = 1, 
+                                        wxWindowID WXUNUSED(id) = 1,
+                                        const wxString& WXUNUSED(name) = wxEmptyString)
+    { return (wxStatusBar*)NULL; }
+
  virtual wxStatusBar *GetStatusBar() const { return (wxStatusBar*)NULL; }
  virtual void SetStatusText( const wxString &WXUNUSED(text), int WXUNUSED(number)=0 ) {}
  virtual void SetStatusWidths( int WXUNUSED(n), const int WXUNUSED(widths_field)[] ) {}
--- a/include/wx/intl.h
+++ b/include/wx/intl.h
@@ -32,7 +32,7 @@
 // gettext() style macro (notice that xgettext should be invoked with "-k_"
 // option to extract the strings inside _() from the sources)
 #ifndef WXINTL_NO_GETTEXT_MACRO
-    #define   _(str)  wxGetTranslation(_T(str))
+    #define   _(str)  wxGetTranslation(T(str))
 #endif

 // ----------------------------------------------------------------------------
--- a/include/wx/ipcbase.h
+++ b/include/wx/ipcbase.h
@@ -53,8 +53,8 @@ class WXDLLEXPORT wxConnectionBase: public wxObject
  inline ~wxConnectionBase(void) {}

  // Calls that CLIENT can make
-  virtual bool Execute(wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT ) = 0;
-  virtual bool Execute(const wxString& str) { return Execute(WXSTRINGCAST str, -1, wxIPC_TEXT); }
+  virtual bool Execute(const wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT ) = 0;
+  virtual bool Execute(const wxString& str) { return Execute(str, -1, wxIPC_TEXT); }
  virtual char *Request(const wxString& item, int *size = (int *) NULL, wxIPCFormat format = wxIPC_TEXT) = 0;
  virtual bool Poke(const wxString& item, wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT) = 0;
  virtual bool StartAdvise(const wxString& item) = 0;
--- a/include/wx/log.h
+++ b/include/wx/log.h
@@ -245,7 +245,7 @@ protected:
 // GUI part (andnot just the base one) of the library, they're implemented in
 // src/generic/logg.cpp *and not src/common/log.cpp unlike all the rest)

-#ifndef wxUSE_NOGUI
+#if wxUSE_GUI

 // log everything to a text window (GUI only of course)
 class WXDLLEXPORT wxLogTextCtrl : public wxLog
@@ -338,7 +338,7 @@ private:
    wxLogFrame *m_pLogFrame;      // the log frame
 };

-#endif // wxUSE_NOGUI
+#endif // wxUSE_GUI

 // ----------------------------------------------------------------------------
 // /dev/null log target: suppress logging until this object goes out of scope
@@ -464,7 +464,7 @@ DECLARE_LOG_FUNCTION2(SysError, long lErrCode);
 // ----------------------------------------------------------------------------

 #ifndef __TFILE__
-    #define __XFILE__(x) _T(x)
+    #define __XFILE__(x) Tx)
    #define __TFILE__ __XFILE__(__FILE__)
 #endif

@@ -473,12 +473,12 @@ DECLARE_LOG_FUNCTION2(SysError, long lErrCode);
    // will take us immediately to the place of the failed API
 #ifdef __VISUALC__
    #define wxLogApiError(api, rc)                                              \
-        wxLogDebug(_T("%s(%d): '%s' failed with error 0x%08lx (%s)."),          \
+        wxLogDebug(T("%s(%d): '%s' failed with error 0x%08lx (%s)."),          \
                   __TFILE__, __LINE__, api,                                    \
                   rc, wxSysErrorMsg(rc))
 #else // !VC++
    #define wxLogApiError(api, rc)                                              \
-        wxLogDebug(_T("In file %s at line %d: '%s' failed with "                \
+        wxLogDebug(T("In file %s at line %d: '%s' failed with "                \
                      "error 0x%08lx (%s)."),                                   \
                   __TFILE__, __LINE__, api,                                    \
                   rc, wxSysErrorMsg(rc))
--- a/include/wx/motif/clipbrd.h
+++ b/include/wx/motif/clipbrd.h
@@ -110,7 +110,7 @@ class WXDLLEXPORT wxClipboardClient : public wxObject

 public:
  /* This list should be filled in with strings indicating the formats
-     this client can provide. Almost all clients will provide "TEXT".
+     this client can provide. Almost all clients will provide "TEXT(".
     Format names should be 4 characters long, so things will work
     out on the Macintosh */
  wxStringList formats;
@@ -147,7 +147,7 @@ class WXDLLEXPORT wxClipboard : public wxObject
  /* Set the clipboard string; does not require a client. */
  void SetClipboardString(char *, long time);

-  /* Get data from the clipboard in the format "TEXT". */
+  /* Get data from the clipboard in the format "TEXT(". */
  char *GetClipboardString(long time);

  /* Get data from the clipboard */
--- a/include/wx/motif/dnd.h
+++ b/include/wx/motif/dnd.h
@@ -92,7 +92,7 @@ public:
    
  // the string ID identifies the format of clipboard or DnD data. a word
  // processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
-  // to the clipboard - the latter with the Id "WXWORD_FORMAT".
+  // to the clipboard - the latter with the Id "WXWORD_FORMAT(".
    
  void SetId( const wxString& id )
      { m_id = id; }
--- a/include/wx/msw/curicop.h
+++ b/include/wx/msw/curicop.h
@@ -3,7 +3,7 @@
 // Header signatures for various resources
 #define BFT_ICON   0x4349   /* 'IC' */
 #define BFT_BITMAP 0x4d42   /* 'BM' */
-#define BFT_CURSOR 0x5450   /* 'PT' */
+#define BFT_CURSOR 0x5450   /* 'PT(' */

 // This WIDTHBYTES macro determines the number of BYTES per scan line.
 #define WIDTHBYTES( i)   ((i + 31) / 32 * 4)
--- a/include/wx/msw/dde.h
+++ b/include/wx/msw/dde.h
@@ -54,8 +54,8 @@ public:
  ~wxDDEConnection(void);

  // Calls that CLIENT can make
-  virtual bool Execute(wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT);
-  virtual bool Execute(const wxString& str) { return Execute(WXSTRINGCAST str, -1, wxIPC_TEXT); }
+  virtual bool Execute(const wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT);
+  virtual bool Execute(const wxString& str) { return Execute(str, -1, wxIPC_TEXT); }
  virtual char *Request(const wxString& item, int *size = NULL, wxIPCFormat format = wxIPC_TEXT);
  virtual bool Poke(const wxString& item, wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT);
  virtual bool StartAdvise(const wxString& item);
--- a/include/wx/msw/private.h
+++ b/include/wx/msw/private.h
@@ -139,17 +139,17 @@ WXDLLEXPORT_DATA(extern HFONT) wxSTATUS_LINE_FONT;
 * for this combination of CTl3D/FAFA settings
 */

-#define STATIC_CLASS     _T("STATIC")
+#define STATIC_CLASS     T("STATIC")
 #define STATIC_FLAGS     (SS_LEFT|WS_CHILD|WS_VISIBLE)
-#define CHECK_CLASS      _T("BUTTON")
+#define CHECK_CLASS      T("BUTTON")
 #define CHECK_FLAGS      (BS_AUTOCHECKBOX|WS_TABSTOP|WS_CHILD)
 #define CHECK_IS_FAFA   FALSE
-#define RADIO_CLASS      _T("BUTTON")
+#define RADIO_CLASS      T("BUTTON")
 #define RADIO_FLAGS      (BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE)
 #define RADIO_SIZE       20
 #define RADIO_IS_FAFA   FALSE
 #define PURE_WINDOWS
-#define GROUP_CLASS      _T("BUTTON")
+#define GROUP_CLASS      T("BUTTON")
 #define GROUP_FLAGS      (BS_GROUPBOX|WS_CHILD|WS_VISIBLE)

 /*
--- a/include/wx/msw/setup0.h
+++ b/include/wx/msw/setup0.h
@@ -12,13 +12,12 @@
 #ifndef _WX_SETUP_H_
 #define _WX_SETUP_H_

-/*
- * General features
- *
- */
+// ----------------------------------------------------------------------------
+// global settings
+// ----------------------------------------------------------------------------

-#define wxUSE_CONFIG           1
-                                // Use wxConfig, with CreateConfig in wxApp
+// define this to 0 when building wxBase library
+#define wxUSE_GUI            1

 #define WXWIN_COMPATIBILITY  0
                                // Compatibility with 1.68 API.
@@ -27,6 +26,13 @@
                                // the compatibility code is now very minimal so there
                                // is little advantage to setting it to 1.

+// ----------------------------------------------------------------------------
+// General features
+// ----------------------------------------------------------------------------
+
+#define wxUSE_CONFIG           1
+                                // Use wxConfig, with CreateConfig in wxApp
+
 #define wxUSE_POSTSCRIPT  0
                                // 0 for no PostScript device context
 #define wxUSE_AFM_FOR_POSTSCRIPT 0
--- a/include/wx/msw/timer.h
+++ b/include/wx/msw/timer.h
@@ -6,7 +6,7 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:   	wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_TIMER_H_
@@ -37,9 +37,9 @@ public:
    bool OneShot() const { return oneShot; }

 protected:
-    bool oneShot ;
-    int  milli ;
-    int  lastMilli ;
+    bool oneShot;
+    int  milli;
+    int  lastMilli;

    long id;

--- a/include/wx/object.h
+++ b/include/wx/object.h
@@ -117,13 +117,13 @@ WXDLLEXPORT wxObject* wxCreateStoredObject( wxInputStream& stream );
 #define IMPLEMENT_DYNAMIC_CLASS(name, basename) \
 wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \
   { return new name; }\
- wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename), (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name);
+ wxClassInfo name::sm_class##name((wxChar *) T(#name), (wxChar *) T(#basename), (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name);

 // Multiple inheritance with two base classes
 #define IMPLEMENT_DYNAMIC_CLASS2(name, basename1, basename2) \
 wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \
   { return new name; }\
- wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename1), (wxChar *) _T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name);
+ wxClassInfo name::sm_class##name((wxChar *) T(#name), (wxChar *) T(#basename1), (wxChar *) T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name);

 //////
 ////// for abstract classes
@@ -131,13 +131,13 @@ wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \

 // Single inheritance with one base class
 #define IMPLEMENT_ABSTRACT_CLASS(name, basename) \
- wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename), \
+ wxClassInfo name::sm_class##name((wxChar *) T(#name), (wxChar *) T(#basename), \
         (wxChar *) NULL, (int) sizeof(name), (wxObjectConstructorFn) NULL);

 // Multiple inheritance with two base classes
 #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
- wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename1), \
-         (wxChar *) _T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL);
+ wxClassInfo name::sm_class##name((wxChar *) T(#name), (wxChar *) T(#basename1), \
+         (wxChar *) T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL);

 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
--- a/include/wx/os2/dc.h
+++ b/include/wx/os2/dc.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dc.h
 // Purpose:     wxDC class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     08/26/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:   	wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_DC_H_
--- a/include/wx/os2/dcclient.h
+++ b/include/wx/os2/dcclient.h
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dcclient.h
 // Purpose:     wxClientDC class
-// Author:      Julian Smart
+// Author:      David Webster
 // Modified by:
-// Created:     01/02/97
+// Created:     09/12/99
 // RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart and Markus Holzem
+// Copyright:   (c) David Webster
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////

@@ -16,10 +16,6 @@
 // headers
 // ----------------------------------------------------------------------------

-#ifdef __GNUG__
-    #pragma interface "dcclient.h"
-#endif
-
 #include "wx/dc.h"
 #include "wx/dynarray.h"

--- a/include/wx/os2/dcmemory.h
+++ b/include/wx/os2/dcmemory.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dcmemory.h
 // Purpose:     wxMemoryDC class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     09/09/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:   	wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_DCMEMORY_H_
--- a/include/wx/os2/dcprint.h
+++ b/include/wx/os2/dcprint.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dcprint.h
 // Purpose:     wxPrinterDC class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     09/12/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:   	wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_DCPRINT_H_
--- a/include/wx/os2/dialog.h
+++ b/include/wx/os2/dialog.h
@@ -74,30 +74,33 @@ public:
 // ---------------------------------------------------------------------------

    virtual bool Destroy();
+    virtual void DoSetClientSize(int width, int height);
+    virtual void GetPosition(int *x, int *y) const;
+
+    bool Show(bool show);
+    bool IsShown() const;
+    void Iconize(bool iconize);
+
    virtual bool IsIconized() const;
-    virtual void Centre(int direction = wxBOTH);
-    virtual bool IsModal() const { return ((GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL); }
-
-    virtual int  ShowModal();
-    virtual void EndModal(int retCode);
-
-    void     SetClientSize(int width, int height) { wxWindow::DoSetClientSize(width, height); };
-    void     SetClientSize( const wxSize& size ) { wxWindow::DoSetClientSize(size.x, size.y); };
-    void     SetClientSize(const wxRect& rect) { SetClientSize( rect.width, rect.height ); };
-
-    void     GetPosition(int *x, int *y) const;
-    bool     Show(bool show);
-    void     Iconize(bool iconize);
-
-    void     Fit();
+    void         Fit();

    void     SetTitle(const wxString& title);
    wxString GetTitle() const ;

-    void     OnCharHook(wxKeyEvent& event);
-    void     OnCloseWindow(wxCloseEvent& event);
+    void OnSize(wxSizeEvent& event);
+    bool OnClose();
+    void OnCharHook(wxKeyEvent& event);
+    void OnPaint(wxPaintEvent& event);
+    void OnCloseWindow(wxCloseEvent& event);

-    void     SetModal(bool flag);
+    void SetModal(bool flag);
+
+    virtual void Centre(int direction = wxBOTH);
+    virtual bool IsModal() const;
+
+    // For now, same as Show(TRUE) but returns return code
+    virtual int  ShowModal();
+    virtual void EndModal(int retCode);

    // Standard buttons
    void     OnOK(wxCommandEvent& event);
@@ -107,6 +110,32 @@ public:
    // Responds to colour changes
    void     OnSysColourChanged(wxSysColourChangedEvent& event);

+    // implementation
+    // --------------
+    virtual MRESULT OS2WindowProc(HWND hwnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
+
+    virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
+                                WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
+
+    bool IsModalShowing() const { return m_modalShowing; }
+
+  // tooltip management
+#if wxUSE_TOOLTIPS
+    WXHWND GetToolTipCtrl() const { return m_hwndToolTip; }
+    void SetToolTipCtrl(WXHWND hwndTT) { m_hwndToolTip = hwndTT; }
+#endif // tooltips
+
+protected:
+    bool   m_modalShowing;
+    WXHWND m_hwndOldFocus;  // the window which had focus before we were shown
+
+private:
+#if wxUSE_TOOLTIPS
+    WXHWND                m_hwndToolTip;
+#endif // tooltips
+
+private:
+
 DECLARE_EVENT_TABLE()
 };

--- a/include/wx/os2/filedlg.h
+++ b/include/wx/os2/filedlg.h
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        filedlg.h
 // Purpose:     wxFileDialog class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/05/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

@@ -28,15 +28,6 @@ WXDLLEXPORT_DATA(extern const char*) wxFileSelectorDefaultWildcardStr;
 class WXDLLEXPORT wxFileDialog: public wxDialog
 {
 DECLARE_DYNAMIC_CLASS(wxFileDialog)
-protected:
-    wxString    m_message;
-    long        m_dialogStyle;
-    wxWindow *  m_parent;
-    wxString    m_dir;
-    wxString    m_path; // Full path
-    wxString    m_fileName;
-    wxString    m_wildCard;
-    int         m_filterIndex;
 public:
    wxFileDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr,
        const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
@@ -59,6 +50,16 @@ public:
    inline int GetFilterIndex() const { return m_filterIndex ; }

    int ShowModal();
+
+protected:
+    wxString    m_message;
+    long        m_dialogStyle;
+    wxWindow *  m_parent;
+    wxString    m_dir;
+    wxString    m_path; // Full path
+    wxString    m_fileName;
+    wxString    m_wildCard;
+    int         m_filterIndex;
 };

 #define wxOPEN              0x0001
@@ -68,22 +69,42 @@ public:
 #define wxFILE_MUST_EXIST   0x0010

 // File selector - backward compatibility
-WXDLLEXPORT wxString wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
-                     const char *default_filename = NULL, const char *default_extension = NULL,
-                     const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
-                     wxWindow *parent = NULL, int x = -1, int y = -1);
+WXDLLEXPORT wxString wxFileSelector( const char *message = wxFileSelectorPromptStr
+                                    ,const char *default_path = NULL
+                                    ,const char *default_filename = NULL
+                                    ,const char *default_extension = NULL
+                                    ,const char *wildcard = wxFileSelectorDefaultWildcardStr
+                                    ,int flags = 0
+                                    ,wxWindow *parent = NULL
+                                    ,int x = -1
+                                    ,int y = -1
+                                   );

 // An extended version of wxFileSelector
-WXDLLEXPORT wxString wxFileSelectorEx(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
-                     const char *default_filename = NULL, int *indexDefaultExtension = NULL,
-                     const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
-                     wxWindow *parent = NULL, int x = -1, int y = -1);
+WXDLLEXPORT wxString wxFileSelectorEx( const char *message = wxFileSelectorPromptStr
+                                      ,const char *default_path = NULL
+                                      ,const char *default_filename = NULL
+                                      ,int *indexDefaultExtension = NULL
+                                      ,const char *wildcard = wxFileSelectorDefaultWildcardStr
+                                      ,int flags = 0
+                                      ,wxWindow *parent = NULL
+                                      ,int x = -1
+                                      ,int y = -1
+                                     );

 // Generic file load dialog
-WXDLLEXPORT wxString wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
+WXDLLEXPORT wxString wxLoadFileSelector( const char *what
+                                        ,const char *extension
+                                        ,const char *default_name = NULL
+                                        ,wxWindow *parent = NULL
+                                       );

 // Generic file save dialog
-WXDLLEXPORT wxString wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
+WXDLLEXPORT wxString wxSaveFileSelector( const char *what
+                                        ,const char *extension
+                                        ,const char *default_name = NULL
+                                        ,wxWindow *parent = NULL
+                                       );

 #endif
    // _WX_FILEDLG_H_
--- a/include/wx/os2/setup.h
+++ b/include/wx/os2/setup.h
@@ -1,21 +1,34 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        setup.h
 // Purpose:     Configuration for the library
-// Author:      Julian Smart
+// Author:      David Webster
 // Modified by:
-// Created:     01/02/97
+// Created:     04/02/99
 // RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart
+// Copyright:   (c) David Webster
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_SETUP_H_
 #define _WX_SETUP_H_

-/*
- * General features
- *
- */
+// ----------------------------------------------------------------------------
+// global settings
+// ----------------------------------------------------------------------------
+
+// define this to 0 when building wxBase library
+#define wxUSE_GUI            1
+
+#define WXWIN_COMPATIBILITY  0
+                                // Compatibility with 1.68 API.
+                                // Level 0: no backward compatibility, all new features
+                                // Level 1: Some compatibility. In fact
+                                // the compatibility code is now very minimal so there
+                                // is little advantage to setting it to 1.
+
+// ----------------------------------------------------------------------------
+// General features
+// ----------------------------------------------------------------------------

 #define wxUSE_CONFIG           1
                                // Use wxConfig, with CreateConfig in wxApp
--- a/include/wx/os2/setup0.h
+++ b/include/wx/os2/setup0.h
@@ -12,10 +12,23 @@
 #ifndef _WX_SETUP_H_
 #define _WX_SETUP_H_

-/*
- * General features
- *
- */
+// ----------------------------------------------------------------------------
+// global settings
+// ----------------------------------------------------------------------------
+
+// define this to 0 when building wxBase library
+#define wxUSE_GUI            1
+
+#define WXWIN_COMPATIBILITY  0
+                                // Compatibility with 1.68 API.
+                                // Level 0: no backward compatibility, all new features
+                                // Level 1: Some compatibility. In fact
+                                // the compatibility code is now very minimal so there
+                                // is little advantage to setting it to 1.
+
+// ----------------------------------------------------------------------------
+// General features
+// ----------------------------------------------------------------------------

 #define wxUSE_CONFIG           1
                                // Use wxConfig, with CreateConfig in wxApp
--- a/include/wx/os2/window.h
+++ b/include/wx/os2/window.h
@@ -272,6 +272,9 @@ public:
    // Transfers data to any child controls
    void OnInitDialog(wxInitDialogEvent& event);

+    virtual MRESULT OS2WindowProc(HWND hwnd, WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+
+
 protected:

    // Caret data
--- a/include/wx/proplist.h
+++ b/include/wx/proplist.h
@@ -552,7 +552,7 @@ class WXDLLEXPORT wxListOfStringsListValidator: public wxPropertyListValidator
   // Called when the property is double clicked.
   bool OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);

-   bool EditStringList(wxWindow *parent, wxStringList *stringList, const wxChar *title = _T("String List Editor"));
+   bool EditStringList(wxWindow *parent, wxStringList *stringList, const wxChar *title = T("String List Editor"));

   // Called when the edit (...) button is pressed.
   void OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
--- a/include/wx/sckipc.h
+++ b/include/wx/sckipc.h
@@ -63,9 +63,9 @@ protected:
  friend class wxTCPServer;
  friend class wxTCPClient;
  friend void Client_OnRequest(wxSocketBase&,
-			       wxSocketNotify, char *);
+                               wxSocketNotify, char *);
  friend void Server_OnRequest(wxSocketServer&,
-			       wxSocketNotify, char *);
+                               wxSocketNotify, char *);
 public:

  wxTCPConnection(char *buffer, int size);
@@ -73,7 +73,7 @@ public:
  virtual ~wxTCPConnection();

  // Calls that CLIENT can make
-  bool Execute(wxChar *data, int size = -1,
+  bool Execute(const wxChar *data, int size = -1,
               wxIPCFormat format = wxIPC_TEXT);
  char *Request(const wxString& item, int *size = NULL,
                wxIPCFormat format = wxIPC_TEXT);
--- a/include/wx/strconv.h
+++ b/include/wx/strconv.h
@@ -24,159 +24,175 @@

 #if wxUSE_WCHAR_T

-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // wxMBConv (base class for conversions, using libc conversion itself)
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 class WXDLLEXPORT wxMBConv
 {
 public:
+    // the actual conversion takes place here
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+
+    // No longer inline since BC++ complains.
+    const wxWCharBuffer cMB2WC(const char *psz) const;
+    const wxCharBuffer cWC2MB(const wchar_t *psz) const;

-  // the actual conversion takes place here
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
-  
-  // No longer inline since BC++ complains.
-  const wxWCharBuffer cMB2WC(const char *psz) const;
-  const wxCharBuffer cWC2MB(const wchar_t *psz) const;
 #if wxUSE_UNICODE
-  const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
-  const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
-  const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; }
-  const wchar_t* cMB2WC(const wchar_t *psz) const { return psz; }
-#else
-  const char* cMB2WX(const char *psz) const { return psz; }
-  const char* cWX2MB(const char *psz) const { return psz; }
-  const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
-  const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }
-#endif
+    const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
+    const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
+    const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; }
+    const wchar_t* cMB2WC(const wchar_t *psz) const { return psz; }
+#else // ANSI
+    const char* cMB2WX(const char *psz) const { return psz; }
+    const char* cWX2MB(const char *psz) const { return psz; }
+    const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
+    const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }
+#endif // Unicode/ANSI
 };

 WXDLLEXPORT_DATA(extern wxMBConv) wxConvLibc;

-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // wxMBConvFile (for conversion to filenames)
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

-class WXDLLEXPORT wxMBConvFile: public wxMBConv 
+class WXDLLEXPORT wxMBConvFile : public wxMBConv
 {
 public:
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 };

 WXDLLEXPORT_DATA(extern wxMBConvFile) wxConvFile;

-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // wxMBConvUTF7 (for conversion using UTF7 encoding)
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

-class WXDLLEXPORT wxMBConvUTF7: public wxMBConv 
+class WXDLLEXPORT wxMBConvUTF7 : public wxMBConv
 {
 public:
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 };

 WXDLLEXPORT_DATA(extern wxMBConvUTF7) wxConvUTF7;

-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // wxMBConvUTF8 (for conversion using UTF8 encoding)
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

-class WXDLLEXPORT wxMBConvUTF8: public wxMBConv 
+class WXDLLEXPORT wxMBConvUTF8 : public wxMBConv
 {
 public:
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 };

 WXDLLEXPORT_DATA(extern wxMBConvUTF8) wxConvUTF8;

 #ifdef __WXGTK12__
-//---------------------------------------------------------------------------
-// wxMBConvUTF8 (for conversion using GDK's internal converions)
-//---------------------------------------------------------------------------

-class WXDLLEXPORT wxMBConvGdk: public wxMBConv
+// ----------------------------------------------------------------------------
+// wxMBConvUTF8 (for conversion using GDK's internal converions)
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMBConvGdk : public wxMBConv
 {
 public:
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 };

 WXDLLEXPORT_DATA(extern wxMBConvGdk) wxConvGdk;
-#endif

-//---------------------------------------------------------------------------
-// wxCSConv (for conversion based on laodable char sets)
-//---------------------------------------------------------------------------
+#endif // wxGTK 1.2

-class wxCharacterSet;
+// ----------------------------------------------------------------------------
+// wxCSConv (for conversion based on loadable char sets)
+// ----------------------------------------------------------------------------

-class WXDLLEXPORT wxCSConv: public wxMBConv
+class WXDLLEXPORT wxCharacterSet;
+
+class WXDLLEXPORT wxCSConv : public wxMBConv
 {
-private:
-  wxChar *m_name;
-  wxCharacterSet *m_cset;
-  bool m_deferred;
-  void SetName(const wxChar *charset);
-  
 public:
-  wxCSConv(const wxChar *charset);
-  virtual ~wxCSConv();
-  void LoadNow();
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+    wxCSConv(const wxChar *charset);
+    virtual ~wxCSConv();
+
+    void LoadNow();
+
+    virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
+    virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
+
+private:
+    void SetName(const wxChar *charset);
+
+    wxChar *m_name;
+    wxCharacterSet *m_cset;
+    bool m_deferred;
 };

 WXDLLEXPORT_DATA(extern wxCSConv) wxConvLocal;
-#define wxConv_local wxConvLocal
-
 WXDLLEXPORT_DATA(extern wxMBConv *) wxConvCurrent;
-#define wxConv_current wxConvCurrent

-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // filename conversion macros
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

 // filenames are multibyte on Unix and probably widechar on Windows?
 #if defined(__UNIX__) || defined(__BORLANDC__)
-#define wxMBFILES 1
+    #define wxMBFILES 1
 #else
-#define wxMBFILES 0
+    #define wxMBFILES 0
 #endif

 #if wxMBFILES
-#define wxFNCONV(name) wxConvFile.cWX2MB(name)
-#define FNSTRINGCAST MBSTRINGCAST
+    #define wxFNCONV(name) wxConvFile.cWX2MB(name)
+    #define wxFNSTRINGCAST wxMBSTRINGCAST
 #else
-#define wxFNCONV(name) name
-#define FNSTRINGCAST WXSTRINGCAST
+    #define wxFNCONV(name) name
+    #define wxFNSTRINGCAST WXSTRINGCAST
 #endif

 #else
  // !wxUSE_WCHAR_T

-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // stand-ins in absence of wchar_t
-//---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------

-class WXDLLEXPORT wxMBConv 
+class WXDLLEXPORT wxMBConv
 {
 public:
-  const char* cMB2WX(const char *psz) const { return psz; }
-  const char* cWX2MB(const char *psz) const { return psz; }
+    const char* cMB2WX(const char *psz) const { return psz; }
+    const char* cWX2MB(const char *psz) const { return psz; }
 };
+
 WXDLLEXPORT_DATA(extern wxMBConv) wxConvLibc, wxConvFile;
 WXDLLEXPORT_DATA(extern wxMBConv *) wxConvCurrent;

 #define wxFNCONV(name) name
-#define FNSTRINGCAST WXSTRINGCAST
+#define wxFNSTRINGCAST WXSTRINGCAST

 #endif
  // wxUSE_WCHAR_T

-#endif  
+// ----------------------------------------------------------------------------
+// macros for the most common conversions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_UNICODE
+    #define wxConvertWX2MB(s)   wxConvCurrent->cWX2MB(s)
+    #define wxConvertMB2WX(s)   wxConvCurrent->cMB2WX(s)
+#else // ANSI
+    // no conversions to do
+    #define wxConvertWX2MB(s)   (s)
+    #define wxConvertMB2WX(s)   (s)
+#endif // Unicode/ANSI
+
+#endif
  // _WX_WXSTRCONVH__

--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -9,13 +9,35 @@
 // Licence:     wxWindows license
 ///////////////////////////////////////////////////////////////////////////////

+/*
+    Efficient string class [more or less] compatible with MFC CString,
+    wxWindows version 1 wxString and std::string and some handy functions
+    missing from string.h.
+*/
+
 #ifndef _WX_WXSTRINGH__
 #define _WX_WXSTRINGH__

 #ifdef __GNUG__
-#pragma interface "string.h"
+    #pragma interface "string.h"
 #endif

+// ----------------------------------------------------------------------------
+// conditinal compilation
+// ----------------------------------------------------------------------------
+
+// compile the std::string compatibility functions if defined
+#define   wxSTD_STRING_COMPATIBILITY
+
+// define to derive wxString from wxObject (deprecated!)
+#ifdef WXSTRING_IS_WXOBJECT
+    #undef WXSTRING_IS_WXOBJECT
+#endif
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __WXMAC__
    #include <ctype.h>
 #endif
@@ -34,57 +56,53 @@
    #include <strings.h>    // for strcasecmp()
 #endif // AIX

-#ifndef  WX_PRECOMP
-  #include "wx/defs.h"
+#include "wx/defs.h"        // everybody should include this
+#include "wx/debug.h"       // for wxASSERT()
+#include "wx/wxchar.h"      // for wxChar
+#include "wx/buffer.h"      // for wxCharBuffer
+#include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes

+#ifndef  WX_PRECOMP
  #ifdef    WXSTRING_IS_WXOBJECT
-    #include "wx/object.h"
+    #include "wx/object.h" // base class
  #endif
 #endif // !PCH

-#include "wx/debug.h"
-#include "wx/wxchar.h"
-#include "wx/buffer.h"
-
-/*
-    Efficient string class [more or less] compatible with MFC CString,
-    wxWindows version 1 wxString and std::string and some handy functions
-    missing from string.h.
-*/
-
 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------

-// compile the std::string compatibility functions if defined
-#define   wxSTD_STRING_COMPATIBILITY
-
-// define to derive wxString from wxObject
-#ifdef    WXSTRING_IS_WXOBJECT
-#undef    WXSTRING_IS_WXOBJECT
-#endif
-
-// maximum possible length for a string means "take all string" everywhere
-//  (as sizeof(StringData) is unknown here we substract 100)
-const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
-
 // 'naughty' cast
 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
-#define   WXCSTRINGCAST (wxChar *)(const wxChar *)
-#define   MBSTRINGCAST (char *)(const char *)
-#define   WCSTRINGCAST (wchar_t *)(const wchar_t *)
+#define   wxCSTRINGCAST (wxChar *)(const wxChar *)
+#define   wxMBSTRINGCAST (char *)(const char *)
+#define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)

 // implementation only
 #define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )

-// include conversion classes
-#include "wx/strconv.h"
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// maximum possible length for a string means "take all string" everywhere
+//  (as sizeof(StringData) is unknown here, we substract 100)
+const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
+
+// ----------------------------------------------------------------------------
+// global data
+// ----------------------------------------------------------------------------
+
+// global pointer to empty string
+WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;

 // ---------------------------------------------------------------------------
-// Global functions complementing standard C string library replacements for
+// global functions complementing standard C string library replacements for
 // strlen() and portable strcasecmp()
 //---------------------------------------------------------------------------
-// USE wx* FUNCTIONS IN wx/wxchar.h INSTEAD - THIS IS ONLY FOR BINARY COMPATIBILITY
+
+// Use wxXXX() functions from wxchar.h instead! These functions are for
+// backwards compatibility only.

 // checks whether the passed in pointer is NULL and if the string is empty
 inline bool WXDLLEXPORT IsEmpty(const char *p) { return (!p || !*p); }
@@ -138,23 +156,15 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
 #endif  // OS/compiler
 }

-// ----------------------------------------------------------------------------
-// global data
-// ----------------------------------------------------------------------------
-
-WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
-
-// global pointer to empty string
-WXDLLEXPORT_DATA(extern const wxChar*) g_szNul;
-
 // return an empty wxString
 class WXDLLEXPORT wxString; // not yet defined
-inline const wxString& wxGetEmptyString() { return *(wxString *)&g_szNul; }
+inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }

 // ---------------------------------------------------------------------------
 // string data prepended with some housekeeping info (used by wxString class),
 // is never used directly (but had to be put here to allow inlining)
 // ---------------------------------------------------------------------------
+
 struct WXDLLEXPORT wxStringData
 {
  int     nRefs;        // reference count
@@ -225,7 +235,7 @@ private:
  // string (re)initialization functions
    // initializes the string to the empty value (must be called only from
    // ctors, use Reinit() otherwise)
-  void Init() { m_pchData = (wxChar *)g_szNul; }
+  void Init() { m_pchData = (wxChar *)wxEmptyString; }
    // initializaes the string with (a part of) C-string
  void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = wxSTRING_MAXLEN);
    // as Init, but also frees old data
@@ -278,6 +288,7 @@ public:
    // (default value of wxSTRING_MAXLEN means take all the string)
  wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
    { InitWith(psz, 0, nLength); }
+
 #if wxUSE_UNICODE
    // from multibyte string
    // (NB: nLength is right now number of Unicode characters, not
@@ -286,21 +297,24 @@ public:
    // from wxWCharBuffer (i.e. return from wxGetString)
  wxString(const wxWCharBuffer& psz)
    { InitWith(psz, 0, wxSTRING_MAXLEN); }
-#else
+#else // ANSI
    // from C string (for compilers using unsigned char)
  wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
    { InitWith((const char*)psz, 0, nLength); }
    // from multibyte string
  wxString(const char *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
    { InitWith(psz, 0, nLength); }
+
 #if wxUSE_WCHAR_T
    // from wide (Unicode) string
  wxString(const wchar_t *pwz);
-#endif
+#endif // !wxUSE_WCHAR_T
+
    // from wxCharBuffer
  wxString(const wxCharBuffer& psz)
    { InitWith(psz, 0, wxSTRING_MAXLEN); }
-#endif
+#endif // Unicode/ANSI
+
    // dtor is not virtual, this class must not be inherited from!
 ~wxString() { GetStringData()->Unlock(); }

@@ -378,25 +392,36 @@ public:
    const wxChar* c_str()   const { return m_pchData; }
    // (and this with [wx]Printf()!)
    const wxChar* wx_str()  const { return m_pchData; }
-    //
+    // identical to c_str()
    const wxChar* GetData() const { return m_pchData; }
+
+    // conversions with (possible) format convertions: have to return a
+    // buffer with temporary data
 #if wxUSE_UNICODE
    const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const { return conv.cWC2MB(m_pchData); }
+    const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
+
    const wxChar* wc_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const { return m_pchData; }
+
 #if wxMBFILES
    const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
-#else
+#else // !wxMBFILES
    const wxChar* fn_str() const { return m_pchData; }
-#endif
-#else
-    const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConvLibc ) const { return m_pchData; }
+#endif // wxMBFILES/!wxMBFILES
+#else // ANSI
+#if wxUSE_MULTIBYTE
+    const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConvLibc) const
+        { return m_pchData; }
+    const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
+#else // !mmultibyte
+    const wxChar* mb_str() const { return m_pchData; }
+    const wxWX2MBbuf mbc_str() const { return mb_str(); }
+#endif // multibyte/!multibyte
 #if wxUSE_WCHAR_T
    const wxWCharBuffer wc_str(wxMBConv& conv) const { return conv.cMB2WC(m_pchData); }
-#endif
+#endif // wxUSE_WCHAR_T
    const wxChar* fn_str() const { return m_pchData; }
-#endif
-    // for convenience
-    const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
+#endif // Unicode/ANSI

  // overloaded assignment
    // from another wxString
@@ -408,7 +433,7 @@ public:
 #if wxUSE_UNICODE
    // from wxWCharBuffer
  wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); }
-#else
+#else // ANSI
    // from another kind of C string
  wxString& operator=(const unsigned char* psz);
 #if wxUSE_WCHAR_T
@@ -417,7 +442,7 @@ public:
 #endif
    // from wxCharBuffer
  wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); }
-#endif
+#endif // Unicode/ANSI

  // string concatenation
    // in place concatenation
@@ -548,7 +573,7 @@ public:
      // remove spaces from left or from right (default) side
  wxString& Trim(bool bFromRight = TRUE);
      // add nCount copies chPad in the beginning or at the end (default)
-  wxString& Pad(size_t nCount, wxChar chPad = _T(' '), bool bFromRight = TRUE);
+  wxString& Pad(size_t nCount, wxChar chPad = T(' '), bool bFromRight = TRUE);
      // truncate string to given length
  wxString& Truncate(size_t uiLen);

@@ -660,7 +685,7 @@ public:
    // return the maximum size of the string
  size_t max_size() const { return wxSTRING_MAXLEN; }
    // resize the string, filling the space with c if c != 0
-  void resize(size_t nSize, wxChar ch = _T('\0'));
+  void resize(size_t nSize, wxChar ch = T('\0'));
    // delete the contents of the string
  void clear() { Empty(); }
    // returns true if the string is empty
@@ -835,6 +860,7 @@ public:
 // so the original string may be safely deleted. When a string is retrieved
 // from the array (operator[] or Item() method), a reference is returned.
 // ----------------------------------------------------------------------------
+
 class WXDLLEXPORT wxArrayString
 {
 public:
@@ -979,20 +1005,23 @@ wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
 #if wxUSE_UNICODE
 inline wxString WXDLLEXPORT operator+(const wxString& string, const wxWCharBuffer& buf)
-{ return string + (const wchar_t *)buf; }
+    { return string + (const wchar_t *)buf; }
 inline wxString WXDLLEXPORT operator+(const wxWCharBuffer& buf, const wxString& string)
-{ return (const wchar_t *)buf + string; }
+    { return (const wchar_t *)buf + string; }
 #else
 inline wxString WXDLLEXPORT operator+(const wxString& string, const wxCharBuffer& buf)
-{ return string + (const char *)buf; }
+    { return string + (const char *)buf; }
 inline wxString WXDLLEXPORT operator+(const wxCharBuffer& buf, const wxString& string)
-{ return (const char *)buf + string; }
+    { return (const char *)buf + string; }
 #endif

 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------

+// don't pollute the library user's name space
+#undef ASSERT_VALID_INDEX
+
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM

 #include "wx/ioswrap.h"
--- a/include/wx/utils.h
+++ b/include/wx/utils.h
@@ -74,7 +74,7 @@ WXDLLEXPORT bool StringMatch(wxChar *one, wxChar *two, bool subString = TRUE, bo
 // ----------------------------------------------------------------------------

 // Sound the bell
-WXDLLEXPORT void wxBell(void) ;
+WXDLLEXPORT void wxBell();

 // Get OS version
 WXDLLEXPORT int wxGetOsVersion(int *majorVsn= (int *) NULL,int *minorVsn= (int *) NULL) ;
@@ -82,6 +82,7 @@ WXDLLEXPORT int wxGetOsVersion(int *majorVsn= (int *) NULL,int *minorVsn= (int *
 // Return a string with the current date/time
 WXDLLEXPORT wxString wxNow();

+#if wxUSE_GUI
 // Don't synthesize KeyUp events holding down a key and producing
 // KeyDown events with autorepeat. On by default and always on
 // in wxMSW.
@@ -106,6 +107,8 @@ WXDLLEXPORT void wxRegisterId(long id);
 // Return the current ID
 WXDLLEXPORT long wxGetCurrentId();

+#endif // wxUSE_GUI
+
 // ----------------------------------------------------------------------------
 // Various conversions
 // ----------------------------------------------------------------------------
@@ -215,6 +218,8 @@ WXDLLEXPORT const wxMB2WXbuf wxGetUserHome(const wxString& user = wxEmptyString)
 WXDLLEXPORT wxChar* wxGetUserHome(const wxString& user = wxEmptyString);
 #endif

+#if wxUSE_GUI // GUI only things from now on
+
 // ----------------------------------------------------------------------------
 // Strip out any menu codes
 // ----------------------------------------------------------------------------
@@ -388,5 +393,7 @@ extern wxNativeFont wxLoadQueryNearestFont(int pointSize,

 #endif // X || GTK

+#endif // wxUSE_GUI
+
 #endif
    // _WX_UTILSH__
--- a/include/wx/variant.h
+++ b/include/wx/variant.h
@@ -81,22 +81,22 @@ public:

 // Construction & destruction
    wxVariant();
-    wxVariant(double val, const wxString& name = g_szNul);
-    wxVariant(long val, const wxString& name = g_szNul);
+    wxVariant(double val, const wxString& name = wxEmptyString);
+    wxVariant(long val, const wxString& name = wxEmptyString);
 #ifdef HAVE_BOOL
-    wxVariant(bool val, const wxString& name = g_szNul);
+    wxVariant(bool val, const wxString& name = wxEmptyString);
 #endif
-    wxVariant(char val, const wxString& name = g_szNul);
-    wxVariant(const wxString& val, const wxString& name = g_szNul);
-    wxVariant(const wxChar* val, const wxString& name = g_szNul); // Necessary or VC++ assumes bool!
-    wxVariant(const wxStringList& val, const wxString& name = g_szNul);
-    wxVariant(const wxList& val, const wxString& name = g_szNul); // List of variants
+    wxVariant(char val, const wxString& name = wxEmptyString);
+    wxVariant(const wxString& val, const wxString& name = wxEmptyString);
+    wxVariant(const wxChar* val, const wxString& name = wxEmptyString); // Necessary or VC++ assumes bool!
+    wxVariant(const wxStringList& val, const wxString& name = wxEmptyString);
+    wxVariant(const wxList& val, const wxString& name = wxEmptyString); // List of variants
 #if wxUSE_TIMEDATE
-    wxVariant(const wxTime& val, const wxString& name = g_szNul); // Time
-    wxVariant(const wxDate& val, const wxString& name = g_szNul); // Date
+    wxVariant(const wxTime& val, const wxString& name = wxEmptyString); // Time
+    wxVariant(const wxDate& val, const wxString& name = wxEmptyString); // Date
 #endif
-    wxVariant(void* ptr, const wxString& name = g_szNul); // void* (general purpose)
-    wxVariant(wxVariantData* data, const wxString& name = g_szNul); // User-defined data
+    wxVariant(void* ptr, const wxString& name = wxEmptyString); // void* (general purpose)
+    wxVariant(wxVariantData* data, const wxString& name = wxEmptyString); // User-defined data
    wxVariant(const wxVariant& variant);
    ~wxVariant();

--- a/include/wx/wizard.h
+++ b/include/wx/wizard.h
@@ -81,7 +81,7 @@ public:
    static void Chain(wxWizardPageSimple *first, wxWizardPageSimple *second)
    {
        wxCHECK_RET( first && second,
-                     _T("NULL passed to wxWizardPageSimple::Chain") );
+                     T("NULL passed to wxWizardPageSimple::Chain") );

        first->SetNext(second);
        second->SetPrev(first);
--- a/include/wx/wx.h
+++ b/include/wx/wx.h
@@ -6,16 +6,26 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c)
-// Licence:   	wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_WXH__
 #define _WX_WXH__

-#include "wx/setup.h"           // Which features to include - user editable
 #include "wx/defs.h"
+#include "wx/object.h"
+#include "wx/dynarray.h"
+#include "wx/list.h"
+#include "wx/hash.h"
 #include "wx/string.h"
+#include "wx/intl.h"
 #include "wx/log.h"
+#include "wx/event.h"
+#include "wx/app.h"
+#include "wx/utils.h"
+
+#if wxUSE_GUI
+
 #include "wx/window.h"
 #include "wx/panel.h"
 #include "wx/frame.h"
@@ -26,8 +36,6 @@
 #include "wx/dcscreen.h"
 #include "wx/button.h"
 #include "wx/menu.h"
-#include "wx/app.h"
-#include "wx/event.h"
 #include "wx/list.h"
 #include "wx/pen.h"
 #include "wx/brush.h"
@@ -36,7 +44,6 @@
 #include "wx/cursor.h"
 #include "wx/dialog.h"
 #include "wx/timer.h"
-#include "wx/utils.h"
 #include "wx/settings.h"
 #include "wx/msgdlg.h"
 #include "wx/cmndata.h"
@@ -67,10 +74,6 @@
 #include "wx/filedlg.h"
 #include "wx/dirdlg.h"

-#if wxUSE_INTL
-    #include "wx/intl.h"
-#endif // wxUSE_INTL
-
 #if wxUSE_VALIDATORS
    #include "wx/valtext.h"
 #endif // wxUSE_VALIDATORS
@@ -80,5 +83,7 @@
    #include "wx/serbase.h"
 #endif // wxUSE_SERIAL

+#endif // wxUSE_GUI
+
 #endif
    // _WX_WXH__
--- a/include/wx/wxchar.h
+++ b/include/wx/wxchar.h
@@ -47,6 +47,9 @@
 #  define HAVE_WCSLEN 1

 #  include <tchar.h>
+
+#  define T(x)       _T(x)
+
 #  if wxUSE_UNICODE // temporary - preserve binary compatibility
 typedef  _TCHAR      wxChar;
 typedef  _TSCHAR     wxSChar;
@@ -230,7 +233,7 @@ typedef __WCHAR_TYPE__          wxChar;
 typedef signed __WCHAR_TYPE__   wxSChar;
 typedef unsigned __WCHAR_TYPE__ wxUChar;

-#      define _T(x)                   L##x
+#      define T(x)                   L##x

       // ctype.h functions (wctype.h)
 #      define  wxIsalnum   iswalnum
@@ -289,50 +292,54 @@ typedef unsigned __WCHAR_TYPE__ wxUChar;
 #    include <ctype.h>
 #    include <string.h>

-#    if 0 // temporary - preserve binary compatibilty
-typedef char            wxChar;
-typedef signed char     wxSChar;
-typedef unsigned char   wxUChar;
-#    else
-#      define wxChar char
-#      define wxSChar signed char
-#      define wxUChar unsigned char
-#    endif
+#   if 0 // temporary - preserve binary compatibilty
+        typedef char            wxChar;
+        typedef signed char     wxSChar;
+        typedef unsigned char   wxUChar;
+#   else
+#     define wxChar char
+#     define wxSChar signed char
+#     define wxUChar unsigned char
+#   endif

-#    ifdef __FreeBSD__
-#      undef _T
-#    endif
-#    define _T(x)           x
+#   ifdef __FreeBSD__
+#     undef T
+#   endif
+#   define T(x)           x

     // ctype.h functions
-#    define  wxIsalnum   isalnum
-#    define  wxIsalpha   isalpha
-#    define  wxIsctrl    isctrl
-#    define  wxIsdigit   isdigit
-#    define  wxIsgraph   isgraph
-#    define  wxIslower   islower
-#    define  wxIsprint   isprint
-#    define  wxIspunct   ispunct
-#    define  wxIsspace   isspace
-#    define  wxIsupper   isupper
-#    define  wxIsxdigit  isxdigit
-#    define  wxTolower   tolower
-#    define  wxToupper   toupper
+#   define  wxIsalnum   isalnum
+#   define  wxIsalpha   isalpha
+#   define  wxIsctrl    isctrl
+#   define  wxIsdigit   isdigit
+#   define  wxIsgraph   isgraph
+#   define  wxIslower   islower
+#   define  wxIsprint   isprint
+#   define  wxIspunct   ispunct
+#   define  wxIsspace   isspace
+#   define  wxIsupper   isupper
+#   define  wxIsxdigit  isxdigit
+#   define  wxTolower   tolower
+#   define  wxToupper   toupper

-     // locale.h functons
-#    define  wxSetlocale setlocale
+    // locale.h functons
+#   define  wxSetlocale setlocale

-     // string.h functions
-     // #define  wxStricmp   strcasecmp
-     // wxStricmp is defined below!!
+    // string.h functions
+    // #define  wxStricmp   strcasecmp
+    // wxStricmp is defined below!!

-     // #define  wxStrtok    strtok_r // this needs a configure check
+    #ifdef HAVE_STRTOK_R
+        #define  wxStrtok(str, sep, last)    strtok_r(str, sep, last)
+    #else
+        #define  wxStrtok(str, sep, last)    strtok(str, sep)
+    #endif

     // leave the rest to defaults below
-#    define wxNEED_WX_STRING_H
-#    define wxNEED_WX_STDIO_H
-#    define wxNEED_WX_STDLIB_H
-#    define wxNEED_WX_TIME_H
+#   define wxNEED_WX_STRING_H
+#   define wxNEED_WX_STDIO_H
+#   define wxNEED_WX_STDLIB_H
+#   define wxNEED_WX_TIME_H

 #  endif//Unicode
 #endif//TCHAR-aware compilers
@@ -557,6 +564,12 @@ WXDLLEXPORT int      wxSystem(const wxChar *psz);
 WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm);
 #endif

+// a Unicode-friendly __FILE__ analog
+#ifndef __TFILE__
+    #define __XFILE__(x) T(x)
+    #define __TFILE__ __XFILE__(__FILE__)
+#endif
+
 #endif
  //_WX_WXCHAR_H_

--- a/include/wx/wxexpr.h
+++ b/include/wx/wxexpr.h
@@ -112,7 +112,7 @@ class WXDLLEXPORT wxExpr
      return value.word;
    else if (type == wxExprString)
      return wxString(value.string);
-    else return wxString(_T(""));
+    else return wxString(T(""));
  }

  inline wxString StringValue(void) const {
@@ -120,7 +120,7 @@ class WXDLLEXPORT wxExpr
      return wxString(value.string);
    else if (type == wxExprWord)
      return wxString(value.word);
-    else return wxString(_T(""));
+    else return wxString(T(""));
  }

  // Get nth arg of clause (starting from 1)
--- a/samples/dnd/dnd.cpp
+++ b/samples/dnd/dnd.cpp
@@ -295,11 +295,11 @@ void DnDFrame::OnClipboardHasText(wxCommandEvent& WXUNUSED(event))

    if ( !wxTheClipboard->IsSupported( wxDF_TEXT ) )
    {
-        wxLogMessage( _T("No text is on the clipboard") );
+        wxLogMessage( _T("No text on the clipboard") );
    }
    else
    {
-        wxLogMessage( _T("There is text is on the clipboard") );
+        wxLogMessage( _T("There is text on the clipboard") );
    }

    wxTheClipboard->Close();
@@ -316,11 +316,11 @@ void DnDFrame::OnClipboardHasBitmap(wxCommandEvent& WXUNUSED(event))

    if ( !wxTheClipboard->IsSupported( wxDF_BITMAP ) )
    {
-        wxLogMessage( _T("No bitmap is on the clipboard") );
+        wxLogMessage( _T("No bitmap on the clipboard") );
    }
    else
    {
-        wxLogMessage( _T("A bitmap is on the clipboard") );
+        wxLogMessage( _T("There is a bitmap on the clipboard") );
    }

    wxTheClipboard->Close();
@@ -435,7 +435,12 @@ DnDFrame::~DnDFrame()

 void DnDFrame::OnCopyBitmap(wxCommandEvent& WXUNUSED(event))
 {
+    // PNG support is not always compiled in under Windows, so use BMP there
+#ifdef __WXMSW__
+    wxFileDialog dialog(this, "Open a BMP file", "", "", "BMP files (*.bmp)|*.bmp", 0);
+#else
    wxFileDialog dialog(this, "Open a PNG file", "", "", "PNG files (*.png)|*.png", 0);
+#endif

    if (dialog.ShowModal() != wxID_OK)
    { 
@@ -456,7 +461,13 @@ void DnDFrame::OnCopyBitmap(wxCommandEvent& WXUNUSED(event))
    }
    
    wxImage image;
-    image.LoadFile( dialog.GetPath(), wxBITMAP_TYPE_PNG );
+    image.LoadFile( dialog.GetPath(), 
+#ifdef __WXMSW__
+                    wxBITMAP_TYPE_BMP
+#else
+                    wxBITMAP_TYPE_PNG
+#endif
+                  );
    if (!image.Ok())
    {
        wxLogMessage( _T("Invalid image file...") );
--- a/samples/nettest/nettest.cpp
+++ b/samples/nettest/nettest.cpp
@@ -35,7 +35,7 @@
    #include "wx/wx.h"
 #endif

-#include "wx/net.h"
+#include "wx/dialup.h"

 // ----------------------------------------------------------------------------
 // private classes
@@ -208,9 +208,6 @@ void MyApp::OnConnected(wxDialUpEvent& event)
 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
       : wxFrame((wxFrame *)NULL, -1, title, pos, size)
 {
-    // set the frame icon
-    SetIcon(wxICON(mondrian));
-
    // create a menu bar
    wxMenu *menuFile = new wxMenu;

--- a/samples/treectrl/treetest.cpp
+++ b/samples/treectrl/treetest.cpp
@@ -285,7 +285,7 @@ void MyFrame::OnCount(wxCommandEvent& WXUNUSED(event))

    int i = m_treeCtrl->GetChildrenCount( item, FALSE );
    
-    wxLogMessage(_T("%d children"), i);
+    wxLogMessage(T("%d children"), i);
 }

 void MyFrame::OnCountRec(wxCommandEvent& WXUNUSED(event))
@@ -296,7 +296,7 @@ void MyFrame::OnCountRec(wxCommandEvent& WXUNUSED(event))

    int i = m_treeCtrl->GetChildrenCount( item );
    
-    wxLogMessage(_T("%d children"), i);
+    wxLogMessage(T("%d children"), i);
 }

 void MyFrame::DoSort(bool reverse)
@@ -324,7 +324,7 @@ void MyFrame::OnDumpSelected(wxCommandEvent& WXUNUSED(event))
    wxArrayTreeItemIds array;

    size_t count = m_treeCtrl->GetSelections(array);
-    wxLogMessage(_T("%u items selected"), count);
+    wxLogMessage(T("%u items selected"), count);

    for ( size_t n = 0; n < count; n++ )
    {
--- a/setup.h.in
+++ b/setup.h.in
@@ -131,11 +131,11 @@
 /*
 * Use GUI
 */
-#define wxUSE_GUI 1
+#define wxUSE_GUI 0
 /*
- * Defined if !wxUSE_GUI
+ * Don't use GUI (defined to 1 when compiling/using base only)
 */
-#undef wxUSE_NOGUI
+#define wxUSE_NOGUI 0

 /*
 * Use constraints mechanism
@@ -367,10 +367,20 @@
 #define wxUSE_POSTSCRIPT 0

 /*
- * Compile wxString with wide character (Unicode) support?
+ * Compile wxString with some Unicode support?
+ */
+#define wxUSE_WCHAR_T 0
+
+/*
+ * Compile wxString in wide character (Unicode) mode?
 */
 #define wxUSE_UNICODE 0

+/*
+ * Compile wxString with (limited) multibyte char support?
+ */
+#define wxUSE_MULTIBYTE 0
+
 /*
 * Work around a bug in GNU libc 5.x wcstombs() implementation.
 *
@@ -644,6 +654,9 @@
 /* Define if you have the shl_load function.  */
 #undef HAVE_SHL_LOAD

+/* Define if you have strtok_r function. */
+#undef HAVE_STRTOK_R
+
 /* Define if you have the uname function.  */
 #undef HAVE_UNAME

--- a/src/common/choiccmn.cpp
+++ b/src/common/choiccmn.cpp
@@ -55,7 +55,7 @@ wxString wxChoiceBase::GetStringSelection() const
 {
    int sel = GetSelection();
    wxString str;
-    wxCHECK_MSG( sel != wxNOT_FOUND, str, _T("no selection, hence no string") );
+    wxCHECK_MSG( sel != wxNOT_FOUND, str, T("no selection, hence no string") );

    str = GetString(sel);
    return str;
@@ -65,7 +65,7 @@ bool wxChoiceBase::SetStringSelection(const wxString& sel)
 {
    int selIndex = FindString(sel);
    wxCHECK_MSG( selIndex != wxNOT_FOUND, FALSE,
-                 _T("can't set selection to string not in the control") );
+                 T("can't set selection to string not in the control") );

    SetSelection(selIndex);

@@ -79,7 +79,7 @@ bool wxChoiceBase::SetStringSelection(const wxString& sel)
 void wxChoiceBase::SetClientObject(int n, wxClientData *data)
 {
    wxASSERT_MSG( m_clientDataItemsType != ClientData_Void,
-                  _T("can't have both object and void client data") );
+                  T("can't have both object and void client data") );

    wxClientData *clientDataOld = DoGetClientObject(n);
    if ( clientDataOld )
@@ -92,7 +92,7 @@ void wxChoiceBase::SetClientObject(int n, wxClientData *data)
 wxClientData *wxChoiceBase::GetClientObject(int n) const
 {
    wxASSERT_MSG( m_clientDataItemsType == ClientData_Object,
-                  _T("this window doesn't have object client data") );
+                  T("this window doesn't have object client data") );

    return DoGetClientObject(n);
 }
@@ -100,7 +100,7 @@ wxClientData *wxChoiceBase::GetClientObject(int n) const
 void wxChoiceBase::SetClientData(int n, void *data)
 {
    wxASSERT_MSG( m_clientDataItemsType != ClientData_Object,
-                  _T("can't have both object and void client data") );
+                  T("can't have both object and void client data") );

    DoSetClientData(n, data);
    m_clientDataItemsType = ClientData_Void;
@@ -109,7 +109,7 @@ void wxChoiceBase::SetClientData(int n, void *data)
 void *wxChoiceBase::GetClientData(int n) const
 {
    wxASSERT_MSG( m_clientDataItemsType == ClientData_Void,
-                  _T("this window doesn't have void client data") );
+                  T("this window doesn't have void client data") );

    return DoGetClientData(n);
 }
--- a/src/common/cmndata.cpp
+++ b/src/common/cmndata.cpp
@@ -231,31 +231,31 @@ wxPrintData::~wxPrintData()
 static wxString wxGetPrintDlgError()
 {
    DWORD err = CommDlgExtendedError();
-    wxString msg = _T("Unknown");
+    wxString msg = T("Unknown");
    switch (err)
    {
-        case CDERR_FINDRESFAILURE: msg = _T("CDERR_FINDRESFAILURE"); break;
-        case CDERR_INITIALIZATION: msg = _T("CDERR_INITIALIZATION"); break;
-        case CDERR_LOADRESFAILURE: msg = _T("CDERR_LOADRESFAILURE"); break;
-        case CDERR_LOADSTRFAILURE: msg = _T("CDERR_LOADSTRFAILURE"); break;
-        case CDERR_LOCKRESFAILURE: msg = _T("CDERR_LOCKRESFAILURE"); break;
-        case CDERR_MEMALLOCFAILURE: msg = _T("CDERR_MEMALLOCFAILURE"); break;
-        case CDERR_MEMLOCKFAILURE: msg = _T("CDERR_MEMLOCKFAILURE"); break;
-        case CDERR_NOHINSTANCE: msg = _T("CDERR_NOHINSTANCE"); break;
-        case CDERR_NOHOOK: msg = _T("CDERR_NOHOOK"); break;
-        case CDERR_NOTEMPLATE: msg = _T("CDERR_NOTEMPLATE"); break;
-        case CDERR_STRUCTSIZE: msg = _T("CDERR_STRUCTSIZE"); break;
-        case  PDERR_RETDEFFAILURE: msg = _T("PDERR_RETDEFFAILURE"); break;
-        case  PDERR_PRINTERNOTFOUND: msg = _T("PDERR_PRINTERNOTFOUND"); break;
-        case  PDERR_PARSEFAILURE: msg = _T("PDERR_PARSEFAILURE"); break;
-        case  PDERR_NODEVICES: msg = _T("PDERR_NODEVICES"); break;
-        case  PDERR_NODEFAULTPRN: msg = _T("PDERR_NODEFAULTPRN"); break;
-        case  PDERR_LOADDRVFAILURE: msg = _T("PDERR_LOADDRVFAILURE"); break;
-        case  PDERR_INITFAILURE: msg = _T("PDERR_INITFAILURE"); break;
-        case  PDERR_GETDEVMODEFAIL: msg = _T("PDERR_GETDEVMODEFAIL"); break;
-        case  PDERR_DNDMMISMATCH: msg = _T("PDERR_DNDMMISMATCH"); break;
-        case  PDERR_DEFAULTDIFFERENT: msg = _T("PDERR_DEFAULTDIFFERENT"); break;
-        case  PDERR_CREATEICFAILURE: msg = _T("PDERR_CREATEICFAILURE"); break;
+        case CDERR_FINDRESFAILURE: msg = T("CDERR_FINDRESFAILURE"); break;
+        case CDERR_INITIALIZATION: msg = T("CDERR_INITIALIZATION"); break;
+        case CDERR_LOADRESFAILURE: msg = T("CDERR_LOADRESFAILURE"); break;
+        case CDERR_LOADSTRFAILURE: msg = T("CDERR_LOADSTRFAILURE"); break;
+        case CDERR_LOCKRESFAILURE: msg = T("CDERR_LOCKRESFAILURE"); break;
+        case CDERR_MEMALLOCFAILURE: msg = T("CDERR_MEMALLOCFAILURE"); break;
+        case CDERR_MEMLOCKFAILURE: msg = T("CDERR_MEMLOCKFAILURE"); break;
+        case CDERR_NOHINSTANCE: msg = T("CDERR_NOHINSTANCE"); break;
+        case CDERR_NOHOOK: msg = T("CDERR_NOHOOK"); break;
+        case CDERR_NOTEMPLATE: msg = T("CDERR_NOTEMPLATE"); break;
+        case CDERR_STRUCTSIZE: msg = T("CDERR_STRUCTSIZE"); break;
+        case  PDERR_RETDEFFAILURE: msg = T("PDERR_RETDEFFAILURE"); break;
+        case  PDERR_PRINTERNOTFOUND: msg = T("PDERR_PRINTERNOTFOUND"); break;
+        case  PDERR_PARSEFAILURE: msg = T("PDERR_PARSEFAILURE"); break;
+        case  PDERR_NODEVICES: msg = T("PDERR_NODEVICES"); break;
+        case  PDERR_NODEFAULTPRN: msg = T("PDERR_NODEFAULTPRN"); break;
+        case  PDERR_LOADDRVFAILURE: msg = T("PDERR_LOADDRVFAILURE"); break;
+        case  PDERR_INITFAILURE: msg = T("PDERR_INITFAILURE"); break;
+        case  PDERR_GETDEVMODEFAIL: msg = T("PDERR_GETDEVMODEFAIL"); break;
+        case  PDERR_DNDMMISMATCH: msg = T("PDERR_DNDMMISMATCH"); break;
+        case  PDERR_DEFAULTDIFFERENT: msg = T("PDERR_DEFAULTDIFFERENT("); break;
+        case  PDERR_CREATEICFAILURE: msg = T("PDERR_CREATEICFAILURE"); break;
        default: break;
    }
    return msg;
@@ -299,7 +299,7 @@ void wxPrintData::ConvertToNative()
            pd->hDevNames = NULL;

 #if defined(__WXDEBUG__) && defined(__WIN32__)
-            wxString str(_T("Printing error: "));
+            wxString str(T("Printing error: "));
            str += wxGetPrintDlgError();
            wxLogDebug(str);
 #endif
@@ -343,7 +343,7 @@ void wxPrintData::ConvertToNative()

        //// Printer name

-        if (m_printerName != _T(""))
+        if (m_printerName != T(""))
        {
            // TODO: make this Unicode compatible
            int len = wxMin(31, m_printerName.Len());
@@ -516,7 +516,7 @@ void wxPrintData::ConvertFromNative()
                else
                {
                    // Shouldn't really get here
-                    wxFAIL_MSG(_T("Couldn't find paper size in paper database."));
+                    wxFAIL_MSG(T("Couldn't find paper size in paper database."));

                    m_paperId = wxPAPER_NONE;
                    m_paperSize.x = 0;
@@ -526,7 +526,7 @@ void wxPrintData::ConvertFromNative()
            else
            {
                // Shouldn't really get here
-                wxFAIL_MSG(_T("Paper database wasn't initialized in wxPrintData::ConvertFromNative."));
+                wxFAIL_MSG(T("Paper database wasn't initialized in wxPrintData::ConvertFromNative."));

                m_paperId = wxPAPER_NONE;
                m_paperSize.x = 0;
@@ -542,7 +542,7 @@ void wxPrintData::ConvertFromNative()
        else
        {
            // Shouldn't really get here
-            wxFAIL_MSG(_T("Couldn't find paper size from DEVMODE."));
+            wxFAIL_MSG(T("Couldn't find paper size from DEVMODE."));

            m_paperSize.x = 0;
            m_paperSize.y = 0;
@@ -761,7 +761,7 @@ void wxPrintDialogData::ConvertToNative()

    m_printData.SetNativeData((void*) NULL);

-    wxASSERT_MSG( (pd->hDevMode), _T("hDevMode must be non-NULL in ConvertToNative!"));
+    wxASSERT_MSG( (pd->hDevMode), T("hDevMode must be non-NULL in ConvertToNative!"));

    pd->hDC = (HDC) NULL;
    pd->nFromPage = (UINT)m_printFromPage;
@@ -1023,7 +1023,7 @@ void wxPageSetupDialogData::ConvertToNative()

    m_printData.SetNativeData((void*) NULL);

-    wxASSERT_MSG( (pd->hDevMode), _T("hDevMode must be non-NULL in ConvertToNative!"));
+    wxASSERT_MSG( (pd->hDevMode), T("hDevMode must be non-NULL in ConvertToNative!"));

 //        pd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, sizeof(DEVMODE));

@@ -1163,7 +1163,7 @@ void wxPageSetupDialogData::SetPaperSize(wxPaperSize id)
 void wxPageSetupDialogData::CalculateIdFromPaperSize()
 {
    wxASSERT_MSG( (wxThePrintPaperDatabase != (wxPrintPaperDatabase*) NULL),
-                  _T("wxThePrintPaperDatabase should not be NULL. "
+                  T("wxThePrintPaperDatabase should not be NULL. "
                     "Do not create global print dialog data objects.") );

    wxSize sz = GetPaperSize();
@@ -1179,7 +1179,7 @@ void wxPageSetupDialogData::CalculateIdFromPaperSize()
 void wxPageSetupDialogData::CalculatePaperSizeFromId()
 {
    wxASSERT_MSG( (wxThePrintPaperDatabase != (wxPrintPaperDatabase*) NULL),
-                  _T("wxThePrintPaperDatabase should not be NULL. "
+                  T("wxThePrintPaperDatabase should not be NULL. "
                     "Do not create global print dialog data objects.") );

    wxSize sz = wxThePrintPaperDatabase->GetSize(m_printData.GetPaperId());
--- a/src/common/config.cpp
+++ b/src/common/config.cpp
@@ -186,7 +186,7 @@ bool wxConfigBase::Read(const wxString& key, int *pi, int defVal) const
 bool wxConfigBase::Write(const wxString& key, double val)
 {
    wxString str;
-    str.Printf(_T("%f"), val);
+    str.Printf(T("%f"), val);
    return Write(key, str);
 }

@@ -371,11 +371,11 @@ void wxSplitPath(wxArrayString& aParts, const wxChar *sz)
  wxString strCurrent;
  const wxChar *pc = sz;
  for ( ;; ) {
-    if ( *pc == _T('\0') || *pc == wxCONFIG_PATH_SEPARATOR ) {
-      if ( strCurrent == _T(".") ) {
+    if ( *pc == T('\0') || *pc == wxCONFIG_PATH_SEPARATOR ) {
+      if ( strCurrent == T(".") ) {
        // ignore
      }
-      else if ( strCurrent == _T("..") ) {
+      else if ( strCurrent == T("..") ) {
        // go up one level
        if ( aParts.IsEmpty() )
          wxLogWarning(_("'%s' has extra '..', ignored."), sz);
@@ -391,7 +391,7 @@ void wxSplitPath(wxArrayString& aParts, const wxChar *sz)
      //else:
        // could log an error here, but we prefer to ignore extra '/'

-      if ( *pc == _T('\0') )
+      if ( *pc == T('\0') )
        return;
    }
    else
--- a/src/common/ctrlcmn.cpp
+++ b/src/common/ctrlcmn.cpp
@@ -48,7 +48,7 @@ bool wxControlBase::CreateControl(wxWindowBase *parent,
    // even if it's possible to create controls without parents in some port,
    // it should surely be discouraged because it doesn't work at all under
    // Windows
-    wxCHECK_MSG( parent, FALSE, _T("all controls must have parents") );
+    wxCHECK_MSG( parent, FALSE, T("all controls must have parents") );

    if ( !CreateBase(parent, id, pos, size, style, validator, name) )
        return FALSE;
--- a/src/common/date.cpp
+++ b/src/common/date.cpp
@@ -43,13 +43,13 @@
 #define ABBR_LENGTH 3

 static const wxChar *dayname[] = {
-    _T("Sunday"), _T("Monday"), _T("Tuesday"), _T("Wednesday"),
-    _T("Thursday"), _T("Friday"), _T("Saturday")
+    T("Sunday"), T("Monday"), T("Tuesday"), T("Wednesday"),
+    T("Thursday"), T("Friday"), T("Saturday")
 };

 static const wxChar *mname[] = {
-    _T("January"), _T("February"), _T("March"), _T("April"), _T("May"), _T("June"),
-    _T("July"), _T("August"), _T("September"), _T("October"), _T("November"), _T("December")
+    T("January"), T("February"), T("March"), T("April"), T("May"), T("June"),
+    T("July"), T("August"), T("September"), T("October"), T("November"), T("December")
 };

 static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
@@ -88,7 +88,7 @@ wxDate::wxDate (const wxString& dat)
 {
    DisplayFormat=wxMDY;
    DisplayOptions='\0';
-    if (wxStrcmp(dat, _T("TODAY")) == 0 || wxStrcmp(dat, _T("today")) == 0)
+    if (wxStrcmp(dat, T("TODAY")) == 0 || wxStrcmp(dat, T("today")) == 0)
    {
        // Sets the current date
        Set();
@@ -96,12 +96,12 @@ wxDate::wxDate (const wxString& dat)
    else
    {
        wxChar buf[100];
-        wxStrcpy(buf, WXSTRINGCAST dat);
+        wxStrcpy(buf, dat);

-        wxChar *save_ptr, *token = wxStrtok(buf,_T("/-"),&save_ptr);
+        wxChar *save_ptr, *token = wxStrtok(buf,T("/-"),&save_ptr);
        month = wxAtoi(token);
-        day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
-        year  = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&save_ptr));
+        day   = wxAtoi(wxStrtok((wxChar *) NULL,T("/-"),&save_ptr));
+        year  = wxAtoi(wxStrtok((wxChar *) NULL,T(" "),&save_ptr));
    }

    mdy_to_julian ();
@@ -131,7 +131,7 @@ void wxDate::operator = (const wxString& dat)
 {
    DisplayFormat=wxMDY;
    DisplayOptions='\0';
-    if (wxStrcmp(dat, _T("TODAY")) == 0 || wxStrcmp(dat, _T("today")) == 0)
+    if (wxStrcmp(dat, T("TODAY")) == 0 || wxStrcmp(dat, T("today")) == 0)
    {
        // Sets the current date
        Set();
@@ -139,12 +139,12 @@ void wxDate::operator = (const wxString& dat)
    else
    {
        wxChar buf[100];
-        wxStrcpy(buf, WXSTRINGCAST dat);
+        wxStrcpy(buf, dat);

-        wxChar *save_ptr, *token = wxStrtok(buf,_T("/-"),&save_ptr);
+        wxChar *save_ptr, *token = wxStrtok(buf,T("/-"),&save_ptr);
        month = wxAtoi(token);
-        day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
-        year  = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&save_ptr));
+        day   = wxAtoi(wxStrtok((wxChar *) NULL,T("/-"),&save_ptr));
+        year  = wxAtoi(wxStrtok((wxChar *) NULL,T(" "),&save_ptr));
    }

    mdy_to_julian ();
@@ -379,11 +379,11 @@ wxString wxDate::FormatDate (int type) const
            }
            wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
 		       (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            wxStrcat( buf, _T(", "));
+            wxStrcat( buf, T(", "));
            wxStrncat( buf, wxGetTranslation(mname[month-1]),
 		       (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            wxStrcat( buf, _T(" "));
-            wxSprintf( buf+wxStrlen(buf), _T("%d, %d"), day, abs(year) );
+            wxStrcat( buf, T(" "));
+            wxSprintf( buf+wxStrlen(buf), T("%d, %d"), day, abs(year) );
            if (year < 0)
                wxStrcat(buf,_(" B.C."));
            return wxString(buf);
@@ -395,10 +395,10 @@ wxString wxDate::FormatDate (int type) const
                wxStrcpy(buf, _("invalid date"));
                return wxString(buf);
            }
-            wxSprintf(buf,_T("%d "),  day);
+            wxSprintf(buf,T("%d "),  day);
            wxStrncat(buf, wxGetTranslation(mname[month-1]),
                    (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
-            wxSprintf( buf+wxStrlen(buf), _T(" %d"), abs(year) );
+            wxSprintf( buf+wxStrlen(buf), T(" %d"), abs(year) );
            if (year < 0)
                wxStrcat(buf, _(" B.C."));
            return wxString(buf);
@@ -408,13 +408,13 @@ wxString wxDate::FormatDate (int type) const
            if (day==0 || month==0 || year==0)
                wxStrcpy(buf, _("invalid date"));
            else
-                wxSprintf( buf+wxStrlen(buf), _T("%1d/%1d/%02d"), month, day,
+                wxSprintf( buf+wxStrlen(buf), T("%1d/%1d/%02d"), month, day,
 			   (DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
 			   ? (abs(year) - (abs(year) / 100 * 100))
 			   : (abs(year))  );
            return wxString(buf);
    }
-    return wxString(_T(""));
+    return wxString(T(""));
 }

 void wxDate::SetFormat( int format )
--- a/src/common/db.cpp
+++ b/src/common/db.cpp
@@ -193,7 +193,7 @@ bool wxDB::Open(char *Dsn, char *Uid, char *AuthStr)
 	// =====================================================================
 	// Results from a Microsoft Access 7.0 db, using a driver from Microsoft
 	//
-	// SQL_VARCHAR						type name = 'TEXT', Precision = 255
+	// SQL_VARCHAR						type name = 'TEXT(', Precision = 255
 	// SQL_TIMESTAMP					type name = 'DATETIME'
 	// SQL_DECIMAL						SQL_NO_DATA_FOUND
 	// SQL_NUMERIC						type name = 'CURRENCY', Precision = 19
@@ -979,14 +979,14 @@ bool wxDB::Grant(int privileges, char *tableName, char *userList)
 		int c = 0;
 		if (privileges & DB_GRANT_SELECT)
 		{
-			strcat(sqlStmt, "SELECT");
+			strcat(sqlStmt, "SELECT(");
 			c++;
 		}
 		if (privileges & DB_GRANT_INSERT)
 		{
 			if (c++)
 				strcat(sqlStmt, ", ");
-			strcat(sqlStmt, "INSERT");
+			strcat(sqlStmt, "INSERT(");
 		}
 		if (privileges & DB_GRANT_UPDATE)
 		{
--- a/src/common/dlgcmn.cpp
+++ b/src/common/dlgcmn.cpp
@@ -56,13 +56,13 @@ wxSizer *wxDialogBase::CreateTextSizer( const wxString &message )
    wxString line;
    for (size_t pos = 0; pos < message.Len(); pos++)
    {
-        if (message[pos] == _T('\n'))
+        if (message[pos] == T('\n'))
        {
            if (!line.IsEmpty())
            {
                wxStaticText *s1 = new wxStaticText( this, -1, line );
 		box->Add( s1 );
-                line = _T("");
+                line = T("");
            }
 	    else
 	    {
--- a/src/common/docmdi.cpp
+++ b/src/common/docmdi.cpp
@@ -51,7 +51,7 @@ void wxDocMDIParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
 void wxDocMDIParentFrame::OnMRUFile(wxCommandEvent& event)
 {
      wxString f(m_docManager->GetHistoryFile(event.GetSelection() - wxID_FILE1));
-      if (f != _T(""))
+      if (f != T(""))
        (void)m_docManager->CreateDocument(f, wxDOC_SILENT);
 }

--- a/src/common/docview.cpp
+++ b/src/common/docview.cpp
@@ -103,7 +103,7 @@ static inline wxString FindExtension(const wxChar *path);
 // local constants
 // ----------------------------------------------------------------------------

-static const char *s_MRUEntryFormat = _T("&%d %s");
+static const char *s_MRUEntryFormat = T("&%d %s");

 // ============================================================================
 // implementation
@@ -224,7 +224,7 @@ bool wxDocument::Save()
    bool ret = FALSE;

    if (!IsModified()) return TRUE;
-    if (m_documentFile == _T("") || !m_savedYet)
+    if (m_documentFile == T("") || !m_savedYet)
        ret = SaveAs();
    else
        ret = OnSaveDocument(m_documentFile);
@@ -254,7 +254,7 @@ bool wxDocument::SaveAs()
    wxString path, name, ext;
    wxSplitPath(fileName, & path, & name, & ext);

-    if (ext.IsEmpty() || ext == _T(""))
+    if (ext.IsEmpty() || ext == T(""))
    {
        fileName += ".";
        fileName += docTemplate->GetDefaultExtension();
@@ -283,7 +283,7 @@ bool wxDocument::OnSaveDocument(const wxString& file)
        return FALSE;

    wxString msgTitle;
-    if (wxTheApp->GetAppName() != _T(""))
+    if (wxTheApp->GetAppName() != T(""))
        msgTitle = wxTheApp->GetAppName();
    else
        msgTitle = wxString(_("File error"));
@@ -319,7 +319,7 @@ bool wxDocument::OnOpenDocument(const wxString& file)
        return FALSE;

    wxString msgTitle;
-    if (wxTheApp->GetAppName() != _T(""))
+    if (wxTheApp->GetAppName() != T(""))
        msgTitle = wxTheApp->GetAppName();
    else
        msgTitle = wxString(_("File error"));
@@ -378,12 +378,12 @@ bool wxDocument::Revert()
 // Get title, or filename if no title, else unnamed
 bool wxDocument::GetPrintableName(wxString& buf) const
 {
-    if (m_documentTitle != _T(""))
+    if (m_documentTitle != T(""))
    {
        buf = m_documentTitle;
        return TRUE;
    }
-    else if (m_documentFile != _T(""))
+    else if (m_documentFile != T(""))
    {
        buf = wxFileNameFromPath(m_documentFile);
        return TRUE;
@@ -418,7 +418,7 @@ bool wxDocument::OnSaveModified()
        GetPrintableName(title);

        wxString msgTitle;
-        if (wxTheApp->GetAppName() != _T(""))
+        if (wxTheApp->GetAppName() != T(""))
            msgTitle = wxTheApp->GetAppName();
        else
            msgTitle = wxString(_("Warning"));
@@ -985,8 +985,8 @@ wxDocument *wxDocManager::CreateDocument(const wxString& path, long flags)
    // Existing document
    wxDocTemplate *temp = (wxDocTemplate *) NULL;

-    wxString path2(_T(""));
-    if (path != _T(""))
+    wxString path2(T(""));
+    if (path != T(""))
        path2 = path;

    if (flags & wxDOC_SILENT)
@@ -1211,21 +1211,21 @@ wxDocTemplate *wxDocManager::SelectDocumentPath(wxDocTemplate **templates,
        {
            // add a '|' to separate this filter from the previous one
            if ( !descrBuf.IsEmpty() )
-                descrBuf << _T('|');
+                descrBuf << T('|');

            descrBuf << templates[i]->GetDescription()
-                << _T(" (") << templates[i]->GetFileFilter() << _T(") |")
+                << T(" (") << templates[i]->GetFileFilter() << T(") |")
                << templates[i]->GetFileFilter();
        }
    }
 #else
-    wxString descrBuf = _T("*.*");
+    wxString descrBuf = T("*.*");
 #endif

    int FilterIndex = 0;
    wxString pathTmp = wxFileSelectorEx(_("Select a file"),
-                                        _T(""),
-                                        _T(""),
+                                        T(""),
+                                        T(""),
                                        &FilterIndex,
                                        descrBuf,
                                        0,
@@ -1250,7 +1250,7 @@ wxDocTemplate *wxDocManager::SelectDocumentPath(wxDocTemplate **templates,
    }
    else
    {
-        path = _T("");
+        path = T("");
        return (wxDocTemplate *) NULL;
    }
 #if 0
@@ -1261,7 +1261,7 @@ wxDocTemplate *wxDocManager::SelectDocumentPath(wxDocTemplate **templates,
    if (!temp)
        return (wxDocTemplate *) NULL;

-    wxChar *pathTmp = wxFileSelector(_("Select a file"), _T(""), _T(""),
+    wxChar *pathTmp = wxFileSelector(_("Select a file"), T(""), T(""),
            temp->GetDefaultExtension(),
            temp->GetFileFilter(),
            0, wxTheApp->GetTopWindow());
@@ -1287,7 +1287,7 @@ wxDocTemplate *wxDocManager::SelectDocumentType(wxDocTemplate **templates,
    {
        if (templates[i]->IsVisible())
        {
-            strings[n] = WXSTRINGCAST templates[i]->m_description;
+            strings[n] = (wxChar *)templates[i]->m_description.c_str();
            data[n] = (wxChar *)templates[i];
            n ++;
        }
@@ -1322,9 +1322,9 @@ wxDocTemplate *wxDocManager::SelectViewType(wxDocTemplate **templates,
    int n = 0;
    for (i = 0; i < noTemplates; i++)
    {
-        if (templates[i]->IsVisible() && (templates[i]->GetViewName() != _T("")))
+        if (templates[i]->IsVisible() && (templates[i]->GetViewName() != T("")))
        {
-            strings[n] = WXSTRINGCAST templates[i]->m_viewTypeName;
+            strings[n] = (wxChar *)templates[i]->m_viewTypeName.c_str();
            data[n] = (wxChar *)templates[i];
            n ++;
        }
@@ -1543,7 +1543,7 @@ void wxDocParentFrame::OnCloseWindow(wxCloseEvent& event)
 #if wxUSE_PRINTING_ARCHITECTURE

 wxDocPrintout::wxDocPrintout(wxView *view, const wxString& title)
-             : wxPrintout(WXSTRINGCAST title)
+             : wxPrintout(title)
 {
    m_printoutView = view;
 }
@@ -1759,7 +1759,7 @@ void wxCommandProcessor::SetMenuStrings()
        {
            wxCommand *command = (wxCommand *)m_currentCommand->Data();
            wxString commandName(command->GetName());
-            if (commandName == _T("")) commandName = _("Unnamed command");
+            if (commandName == T("")) commandName = _("Unnamed command");
            bool canUndo = command->CanUndo();
            if (canUndo)
                buf = wxString(_("&Undo ")) + commandName;
@@ -1774,7 +1774,7 @@ void wxCommandProcessor::SetMenuStrings()
            {
                wxCommand *redoCommand = (wxCommand *)m_currentCommand->Next()->Data();
                wxString redoCommandName(redoCommand->GetName());
-                if (redoCommandName == _T("")) redoCommandName = _("Unnamed command");
+                if (redoCommandName == T("")) redoCommandName = _("Unnamed command");
                buf = wxString(_("&Redo ")) + redoCommandName;
                m_commandEditMenu->SetLabel(wxID_REDO, buf);
                m_commandEditMenu->Enable(wxID_REDO, TRUE);
@@ -1801,7 +1801,7 @@ void wxCommandProcessor::SetMenuStrings()
                // we've undone to the start of the list, but can redo the first.
                wxCommand *redoCommand = (wxCommand *)m_commands.First()->Data();
                wxString redoCommandName(redoCommand->GetName());
-                if (redoCommandName == _T("")) redoCommandName = _("Unnamed command");
+                if (redoCommandName == T("")) redoCommandName = _("Unnamed command");
                buf = wxString(_("&Redo ")) + redoCommandName;
                m_commandEditMenu->SetLabel(wxID_REDO, buf);
                m_commandEditMenu->Enable(wxID_REDO, TRUE);
@@ -1900,7 +1900,7 @@ void wxFileHistory::AddFileToHistory(const wxString& file)
 void wxFileHistory::RemoveFileFromHistory(int i)
 {
    wxCHECK_RET( i < m_fileHistoryN,
-                 _T("invalid index in wxFileHistory::RemoveFileFromHistory") );
+                 T("invalid index in wxFileHistory::RemoveFileFromHistory") );

    wxNode* node = m_fileMenus.First();
    while ( node )
@@ -1932,7 +1932,7 @@ void wxFileHistory::RemoveFileFromHistory(int i)

        // to be removed as soon as wxMenu::Delete() is implemented
 #if 1
-        menu->SetLabel(wxID_FILE1 + m_fileHistoryN - 1, _T(""));
+        menu->SetLabel(wxID_FILE1 + m_fileHistoryN - 1, T(""));
 #endif

        node = node->Next();
@@ -1964,13 +1964,13 @@ void wxFileHistory::Load(wxConfigBase& config)
 {
    m_fileHistoryN = 0;
    wxString buf;
-    buf.Printf(_T("file%d"), m_fileHistoryN+1);
+    buf.Printf(T("file%d"), m_fileHistoryN+1);
    wxString historyFile;
-    while ((m_fileHistoryN <= m_fileMaxFiles) && config.Read(buf, &historyFile) && (historyFile != _T("")))
+    while ((m_fileHistoryN <= m_fileMaxFiles) && config.Read(buf, &historyFile) && (historyFile != T("")))
    {
        m_fileHistory[m_fileHistoryN] = copystring((const wxChar*) historyFile);
        m_fileHistoryN ++;
-        buf.Printf(_T("file%d"), m_fileHistoryN+1);
+        buf.Printf(T("file%d"), m_fileHistoryN+1);
        historyFile = "";
    }
    AddFilesToMenu();
@@ -1982,7 +1982,7 @@ void wxFileHistory::Save(wxConfigBase& config)
    for (i = 0; i < m_fileHistoryN; i++)
    {
        wxString buf;
-        buf.Printf(_T("file%d"), i+1);
+        buf.Printf(T("file%d"), i+1);
        config.Write(buf, wxString(m_fileHistory[i]));
    }
 }
--- a/src/common/dynarray.cpp
+++ b/src/common/dynarray.cpp
@@ -250,7 +250,7 @@ void wxBaseArray::Add(long lItem, CMPFUNC fnCompare)
 // add item at the given position
 void wxBaseArray::Insert(long lItem, size_t nIndex)
 {
-  wxCHECK_RET( nIndex <= m_nCount, _T("bad index in wxArray::Insert") );
+  wxCHECK_RET( nIndex <= m_nCount, T("bad index in wxArray::Insert") );

  Grow();

@@ -263,7 +263,7 @@ void wxBaseArray::Insert(long lItem, size_t nIndex)
 // removes item from array (by index)
 void wxBaseArray::Remove(size_t nIndex)
 {
-  wxCHECK_RET( nIndex <= m_nCount, _T("bad index in wxArray::Remove") );
+  wxCHECK_RET( nIndex <= m_nCount, T("bad index in wxArray::Remove") );

  memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1],
          (m_nCount - nIndex - 1)*sizeof(long));
@@ -276,7 +276,7 @@ void wxBaseArray::Remove(long lItem)
  int iIndex = Index(lItem);

  wxCHECK_RET( iIndex != wxNOT_FOUND,
-               _T("removing inexistent item in wxArray::Remove") );
+               T("removing inexistent item in wxArray::Remove") );

  Remove((size_t)iIndex);
 }
--- a/src/common/dynlib.cpp
+++ b/src/common/dynlib.cpp
@@ -322,7 +322,7 @@ wxLibrary *wxLibraries::LoadLibrary(const wxString& name)
    const char *envLibPath = getenv("LD_LIBRARY_PATH");
    if ( envLibPath )
        libPath << ':' << envLibPath;
-    wxStringTokenizer tokenizer(libPath, _T(':'));
+    wxStringTokenizer tokenizer(libPath, T(':'));
    while ( tokenizer.HasMoreToken() )
    {
        wxString fullname(tokenizer.NextToken());
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -6,7 +6,7 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:       wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifdef __GNUG__
@@ -22,46 +22,56 @@

 #ifndef WX_PRECOMP
    #include "wx/defs.h"
-    #include "wx/control.h"
-    #include "wx/utils.h"
    #include "wx/app.h"
-    #include "wx/dc.h"
+    #include "wx/list.h"
+
+    #if wxUSE_GUI
+        #include "wx/control.h"
+        #include "wx/utils.h"
+        #include "wx/dc.h"
+    #endif // wxUSE_GUI
 #endif

 #include "wx/event.h"
-#include "wx/validate.h"
+
+#if wxUSE_GUI
+    #include "wx/validate.h"
+#endif // wxUSE_GUI

 #if !USE_SHARED_LIBRARY
    IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
    IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
-    IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxScrollWinEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxShowEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxMaximizeEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxIconizeEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
    IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxCommandEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent, wxEvent)
-    IMPLEMENT_DYNAMIC_CLASS(wxWindowDestroyEvent, wxEvent)
+
+    #if wxUSE_GUI
+        IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxScrollWinEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxShowEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxMaximizeEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxIconizeEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxCommandEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent, wxEvent)
+        IMPLEMENT_DYNAMIC_CLASS(wxWindowDestroyEvent, wxEvent)
+    #endif // wxUSE_GUI

    const wxEventTable *wxEvtHandler::GetEventTable() const
        { return &wxEvtHandler::sm_eventTable; }
@@ -102,7 +112,7 @@ wxEvent::wxEvent(int theId)

 void wxEvent::CopyObject(wxObject& object_dest) const
 {
-    wxEvent *obj = (wxEvent *)&object_dest; 
+    wxEvent *obj = (wxEvent *)&object_dest;
    wxObject::CopyObject(object_dest);

    obj->m_eventType = m_eventType;
@@ -114,6 +124,8 @@ void wxEvent::CopyObject(wxObject& object_dest) const
    obj->m_isCommandEvent = m_isCommandEvent;
 }

+#if wxUSE_GUI
+
 /*
 * Command events
 *
@@ -133,7 +145,7 @@ wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)

 void wxCommandEvent::CopyObject(wxObject& obj_d) const
 {
-    wxCommandEvent *obj = (wxCommandEvent *)&obj_d; 
+    wxCommandEvent *obj = (wxCommandEvent *)&obj_d;

    wxEvent::CopyObject(obj_d);

@@ -172,7 +184,7 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,

 void wxScrollWinEvent::CopyObject(wxObject& obj_d) const
 {
-    wxScrollWinEvent *obj = (wxScrollWinEvent*)&obj_d; 
+    wxScrollWinEvent *obj = (wxScrollWinEvent*)&obj_d;

    wxEvent::CopyObject(obj_d);

@@ -231,7 +243,7 @@ bool wxMouseEvent::ButtonDClick(int but) const
        case 3:
            return RightDClick();
        default:
-            wxFAIL_MSG(_T("invalid parameter in wxMouseEvent::ButtonDClick"));
+            wxFAIL_MSG(T("invalid parameter in wxMouseEvent::ButtonDClick"));
    }

    return FALSE;
@@ -252,7 +264,7 @@ bool wxMouseEvent::ButtonDown(int but) const
        case 3:
            return RightDown();
        default:
-            wxFAIL_MSG(_T("invalid parameter in wxMouseEvent::ButtonDown"));
+            wxFAIL_MSG(T("invalid parameter in wxMouseEvent::ButtonDown"));
    }

    return FALSE;
@@ -272,7 +284,7 @@ bool wxMouseEvent::ButtonUp(int but) const
        case 3:
            return RightUp();
        default:
-            wxFAIL_MSG(_T("invalid parameter in wxMouseEvent::ButtonUp"));
+            wxFAIL_MSG(T("invalid parameter in wxMouseEvent::ButtonUp"));
    }

    return FALSE;
@@ -291,7 +303,7 @@ bool wxMouseEvent::Button(int but) const
        case 3:
            return (RightDown() || RightUp() || RightDClick());
        default:
-            wxFAIL_MSG(_T("invalid parameter in wxMouseEvent::Button"));
+            wxFAIL_MSG(T("invalid parameter in wxMouseEvent::Button"));
    }

    return FALSE;
@@ -309,7 +321,7 @@ bool wxMouseEvent::ButtonIsDown(int but) const
        case 3:
            return RightIsDown();
        default:
-            wxFAIL_MSG(_T("invalid parameter in wxMouseEvent::ButtonIsDown"));
+            wxFAIL_MSG(T("invalid parameter in wxMouseEvent::ButtonIsDown"));
    }

    return FALSE;
@@ -408,7 +420,7 @@ void wxCloseEvent::CopyObject(wxObject& obj_d) const
 #endif
    obj->m_canVeto = m_canVeto;
 }
- 
+
 void wxShowEvent::CopyObject(wxObject& obj_d) const
 {
    wxShowEvent *obj = (wxShowEvent *)&obj_d;
@@ -427,7 +439,7 @@ void wxJoystickEvent::CopyObject(wxObject& obj_d) const
    obj->m_buttonChange = m_buttonChange;
    obj->m_buttonState = m_buttonState;
    obj->m_joyStick = m_joyStick;
-} 
+}

 void wxDropFilesEvent::CopyObject(wxObject& obj_d) const
 {
@@ -437,15 +449,7 @@ void wxDropFilesEvent::CopyObject(wxObject& obj_d) const
    obj->m_noFiles = m_noFiles;
    obj->m_pos = m_pos;
    // TODO: Problem with obj->m_files. It should be deallocated by the
-    // destructor of the event. 
-}
-
-void wxIdleEvent::CopyObject(wxObject& obj_d) const
-{
-    wxIdleEvent *obj = (wxIdleEvent *)&obj_d;
-    wxEvent::CopyObject(obj_d);
-
-    obj->m_requestMore = m_requestMore;
+    // destructor of the event.
 }

 void wxUpdateUIEvent::CopyObject(wxObject &obj_d) const
@@ -489,6 +493,16 @@ wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
    SetEventObject(win);
 }

+#endif // wxUSE_GUI
+
+void wxIdleEvent::CopyObject(wxObject& obj_d) const
+{
+    wxIdleEvent *obj = (wxIdleEvent *)&obj_d;
+    wxEvent::CopyObject(obj_d);
+
+    obj->m_requestMore = m_requestMore;
+}
+
 /*
 * Event handler
 */
@@ -564,7 +578,7 @@ bool wxEvtHandler::ProcessThreadEvent(wxEvent& event)

    // TODO: Wake up idle handler for the other platforms.
 #ifdef __WXGTK__
-    if (g_isIdle) 
+    if (g_isIdle)
        wxapp_install_idle_handler();
 #endif

@@ -592,14 +606,16 @@ void wxEvtHandler::ProcessPendingEvents()

 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 {
+#if wxUSE_GUI
    /* check that our flag corresponds to reality */
    wxASSERT( m_isWindow == IsKindOf(CLASSINFO(wxWindow)) );
+#endif // wxUSE_GUI

    /* An event handler can be enabled or disabled */
    if ( GetEvtHandlerEnabled() )
    {
 #if wxUSE_THREADS
-	/* Check whether we are in a child thread. */
+        /* Check whether we are in a child thread. */
        if (!wxThread::IsMain())
          return ProcessThreadEvent(event);
 #endif
@@ -612,7 +628,7 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)

        const wxEventTable *table = GetEventTable();

-#if wxUSE_VALIDATORS
+#if wxUSE_GUI && wxUSE_VALIDATORS
        // Try the associated validator first, if this is a window.
        // Problem: if the event handler of the window has been replaced,
        // this wxEvtHandler may no longer be a window.
@@ -654,6 +670,7 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
            return TRUE;
    }

+#if wxUSE_GUI
    // Carry on up the parent-child hierarchy,
    // but only if event is a command event: it wouldn't
    // make sense for a parent to receive a child's size event, for example
@@ -664,6 +681,7 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
        if (parent && !parent->IsBeingDeleted())
            return parent->GetEventHandler()->ProcessEvent(event);
    }
+#endif // wxUSE_GUI

    // Last try - application object.
    if ( wxTheApp && (this != wxTheApp) )
@@ -735,7 +753,7 @@ void wxEvtHandler::Connect( int id, int lastId,
 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
 {
    wxCHECK_MSG( m_dynamicEvents, FALSE,
-                 _T("caller should check that we have dynamic events") );
+                 T("caller should check that we have dynamic events") );

    int commandId = event.GetId();

@@ -779,6 +797,8 @@ bool wxEvtHandler::OnClose()
 }
 #endif // WXWIN_COMPATIBILITY

+#if wxUSE_GUI
+
 // Find a window with the focus, that is also a descendant of the given window.
 // This is used to determine the window to initially send commands to.
 wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
@@ -802,3 +822,4 @@ wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
    return focusWin;
 }

+#endif // wxUSE_GUI
--- a/src/common/ffile.cpp
+++ b/src/common/ffile.cpp
@@ -54,7 +54,7 @@ wxFFile::wxFFile(const wxChar *filename, const char *mode)

 bool wxFFile::Open(const wxChar *filename, const char *mode)
 {
-    wxASSERT_MSG( !m_fp, _T("should close or detach the old file first") );
+    wxASSERT_MSG( !m_fp, T("should close or detach the old file first") );

 #if wxUSE_UNICODE
    char *tmp_fname;
@@ -107,8 +107,8 @@ bool wxFFile::Close()

 bool wxFFile::ReadAll(wxString *str)
 {
-    wxCHECK_MSG( str, FALSE, _T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, _T("can't read from closed file") );
+    wxCHECK_MSG( str, FALSE, T("invalid parameter") );
+    wxCHECK_MSG( IsOpened(), FALSE, T("can't read from closed file") );

    clearerr(m_fp);

@@ -137,8 +137,8 @@ bool wxFFile::ReadAll(wxString *str)

 size_t wxFFile::Read(void *pBuf, size_t nCount)
 {
-    wxCHECK_MSG( pBuf, FALSE, _T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, _T("can't read from closed file") );
+    wxCHECK_MSG( pBuf, FALSE, T("invalid parameter") );
+    wxCHECK_MSG( IsOpened(), FALSE, T("can't read from closed file") );

    size_t nRead = fread(pBuf, 1, nCount, m_fp);
    if ( (nRead < nCount) && Error() )
@@ -151,8 +151,8 @@ size_t wxFFile::Read(void *pBuf, size_t nCount)

 size_t wxFFile::Write(const void *pBuf, size_t nCount)
 {
-    wxCHECK_MSG( pBuf, FALSE, _T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, _T("can't write to closed file") );
+    wxCHECK_MSG( pBuf, FALSE, T("invalid parameter") );
+    wxCHECK_MSG( IsOpened(), FALSE, T("can't write to closed file") );

    size_t nWritten = fwrite(pBuf, 1, nCount, m_fp);
    if ( nWritten < nCount )
@@ -186,13 +186,13 @@ bool wxFFile::Flush()

 bool wxFFile::Seek(long ofs, wxSeekMode mode)
 {
-    wxCHECK_MSG( IsOpened(), FALSE, _T("can't seek on closed file") );
+    wxCHECK_MSG( IsOpened(), FALSE, T("can't seek on closed file") );

    int origin;
    switch ( mode )
    {
        default:
-            wxFAIL_MSG(_T("unknown seek mode"));
+            wxFAIL_MSG(T("unknown seek mode"));
            // still fall through

        case wxFromStart:
--- a/src/common/file.cpp
+++ b/src/common/file.cpp
@@ -169,7 +169,7 @@ bool wxFile::Exists(const wxChar *name)
    wxCharBuffer fname = wxConvFile.cWC2MB(name);

    return !access(fname, 0) &&
-           !stat(MBSTRINGCAST fname, &st) &&
+           !stat(wxMBSTRINGCAST fname, &st) &&
           (st.st_mode & S_IFREG);
 #else
    return !access(name, 0) &&
@@ -192,7 +192,7 @@ bool wxFile::Access(const wxChar *name, OpenMode mode)
            break;

        default:
-            wxFAIL_MSG(_T("bad wxFile::Access mode parameter."));
+            wxFAIL_MSG(T("bad wxFile::Access mode parameter."));
    }

    return access(wxFNCONV(name), how) == 0;
@@ -481,28 +481,29 @@ bool wxTempFile::Open(const wxString& strName)
    // different partitions for example). Unfortunately, the only standard
    // (POSIX) temp file creation function tmpnam() can't do it.
 #if defined(__UNIX__) || defined(__WXSTUBS__)|| defined( __WXMAC__ )
-    static const wxChar *szMktempSuffix = _T("XXXXXX");
+    static const wxChar *szMktempSuffix = T("XXXXXX");
    m_strTemp << strName << szMktempSuffix;
-    mktemp(MBSTRINGCAST m_strTemp.mb_str()); // will do because length doesn't change
+    // can use the cast because length doesn't change
+    mktemp(wxMBSTRINGCAST m_strTemp.mb_str());
 #elif  defined(__WXPM__)
    // for now just create a file
    // future enhancements can be to set some extended attributes for file systems
    // OS/2 supports that have them (HPFS, FAT32) and security (HPFS386)
-    static const wxChar *szMktempSuffix = _T("XXX");
+    static const wxChar *szMktempSuffix = T("XXX");
    m_strTemp << strName << szMktempSuffix;
    mkdir(m_strTemp.GetWriteBuf(MAX_PATH));
 #else // Windows
    wxString strPath;
    wxSplitPath(strName, &strPath, NULL, NULL);
    if ( strPath.IsEmpty() )
-        strPath = _T('.');  // GetTempFileName will fail if we give it empty string
+        strPath = T('.');  // GetTempFileName will fail if we give it empty string
 #ifdef __WIN32__
-    if ( !GetTempFileName(strPath, _T("wx_"),0, m_strTemp.GetWriteBuf(MAX_PATH)) )
+    if ( !GetTempFileName(strPath, T("wx_"),0, m_strTemp.GetWriteBuf(MAX_PATH)) )
 #else
        // Not sure why MSVC++ 1.5 header defines first param as BYTE - bug?
-        if ( !GetTempFileName((BYTE) (DWORD)(const wxChar*) strPath, _T("wx_"),0, m_strTemp.GetWriteBuf(MAX_PATH)) )
+        if ( !GetTempFileName((BYTE) (DWORD)(const wxChar*) strPath, T("wx_"),0, m_strTemp.GetWriteBuf(MAX_PATH)) )
 #endif
-            wxLogLastError(_T("GetTempFileName"));
+            wxLogLastError(T("GetTempFileName"));
    m_strTemp.UngetWriteBuf();
 #endif  // Windows/Unix

--- a/src/common/fileconf.cpp
+++ b/src/common/fileconf.cpp
@@ -99,7 +99,7 @@ wxString wxFileConfig::GetGlobalDir()
  wxString strDir;

  #ifdef __UNIX__
-    strDir = _T("/etc/");
+    strDir = T("/etc/");
  #elif defined(__WXPM__)
    ULONG                           aulSysInfo[QSV_MAX] = {0};
    UINT                            drive;
@@ -192,15 +192,15 @@ wxString wxFileConfig::GetGlobalDir()
        }
    }
  #elif defined(__WXSTUBS__)
-    wxASSERT_MSG( FALSE, _T("TODO") ) ;
+    wxASSERT_MSG( FALSE, T("TODO") ) ;
  #elif defined(__WXMAC__)
-    wxASSERT_MSG( FALSE, _T("TODO") ) ;
+    wxASSERT_MSG( FALSE, T("TODO") ) ;
  #else // Windows
    wxChar szWinDir[MAX_PATH];
    ::GetWindowsDirectory(szWinDir, MAX_PATH);

    strDir = szWinDir;
-    strDir << _T('\\');
+    strDir << T('\\');
  #endif // Unix/Windows

  return strDir;
@@ -213,9 +213,9 @@ wxString wxFileConfig::GetLocalDir()
  wxGetHomeDir(&strDir);

 #ifdef  __UNIX__
-  if (strDir.Last() != _T('/')) strDir << _T('/');
+  if (strDir.Last() != T('/')) strDir << T('/');
 #else
-  if (strDir.Last() != _T('\\')) strDir << _T('\\');
+  if (strDir.Last() != T('\\')) strDir << T('\\');
 #endif

  return strDir;
@@ -226,11 +226,11 @@ wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
  wxString str = GetGlobalDir();
  str << szFile;

-  if ( wxStrchr(szFile, _T('.')) == NULL )
+  if ( wxStrchr(szFile, T('.')) == NULL )
  #ifdef  __UNIX__
-    str << _T(".conf");
+    str << T(".conf");
  #else   // Windows
-    str << _T(".ini");
+    str << T(".ini");
  #endif  // UNIX/Win

  return str;
@@ -241,14 +241,14 @@ wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
  wxString str = GetLocalDir();

  #ifdef  __UNIX__
-    str << _T('.');
+    str << T('.');
  #endif

  str << szFile;

  #ifdef __WXMSW__
-    if ( wxStrchr(szFile, _T('.')) == NULL )
-      str << _T(".ini");
+    if ( wxStrchr(szFile, T('.')) == NULL )
+      str << T(".ini");
  #endif

  return str;
@@ -385,18 +385,18 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
      ;

    // skip blank/comment lines
-    if ( *pStart == _T('\0')|| *pStart == _T(';') || *pStart == _T('#') )
+    if ( *pStart == T('\0')|| *pStart == T(';') || *pStart == T('#') )
      continue;

-    if ( *pStart == _T('[') ) {          // a new group
+    if ( *pStart == T('[') ) {          // a new group
      pEnd = pStart;

-      while ( *++pEnd != _T(']') ) {
-        if ( *pEnd == _T('\n') || *pEnd == _T('\0') )
+      while ( *++pEnd != T(']') ) {
+        if ( *pEnd == T('\n') || *pEnd == T('\0') )
            break;
      }

-      if ( *pEnd != _T(']') ) {
+      if ( *pEnd != T(']') ) {
        wxLogError(_("file '%s': unexpected character %c at line %d."),
                   file.GetName(), *pEnd, n + 1);
        continue; // skip this line
@@ -416,15 +416,15 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)

      // check that there is nothing except comments left on this line
      bool bCont = TRUE;
-      while ( *++pEnd != _T('\0') && bCont ) {
+      while ( *++pEnd != T('\0') && bCont ) {
        switch ( *pEnd ) {
-          case _T('#'):
-          case _T(';'):
+          case T('#'):
+          case T(';'):
            bCont = FALSE;
            break;

-          case _T(' '):
-          case _T('\t'):
+          case T(' '):
+          case T('\t'):
            // ignore whitespace ('\n' impossible here)
            break;

@@ -438,8 +438,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
    }
    else {                        // a key
      const wxChar *pEnd = pStart;
-      while ( *pEnd != _T('=') && !wxIsspace(*pEnd) ) {
-        if ( *pEnd == _T('\\') ) {
+      while ( *pEnd != T('=') && !wxIsspace(*pEnd) ) {
+        if ( *pEnd == T('\\') ) {
          // next character may be space or not - still take it because it's
          // quoted
          pEnd++;
@@ -454,7 +454,7 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
      while ( isspace(*pEnd) )
        pEnd++;

-      if ( *pEnd++ != _T('=') ) {
+      if ( *pEnd++ != T('=') ) {
        wxLogError(_("file '%s', line %d: '=' expected."),
                   file.GetName(), n + 1);
      }
@@ -692,7 +692,7 @@ bool wxFileConfig::Write(const wxString& key, const wxString& szValue)
  wxString strName = path.Name();
  if ( strName.IsEmpty() ) {
    // setting the value of a group is an error
-    wxASSERT_MSG( wxIsEmpty(szValue), _T("can't set value of a group!") );
+    wxASSERT_MSG( wxIsEmpty(szValue), T("can't set value of a group!") );

    // ... except if it's empty in which case it's a way to force it's creation
    m_pCurrentGroup->SetDirty();
@@ -724,7 +724,7 @@ bool wxFileConfig::Write(const wxString& key, long lValue)
 {
  // ltoa() is not ANSI :-(
  wxString buf;
-  buf.Printf(_T("%ld"), lValue);
+  buf.Printf(T("%ld"), lValue);
  return Write(key, buf);
 }

@@ -809,7 +809,7 @@ bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
  if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
    if ( m_pCurrentGroup != m_pRootGroup ) {
      ConfigGroup *pGroup = m_pCurrentGroup;
-      SetPath(_T(".."));  // changes m_pCurrentGroup!
+      SetPath(T(".."));  // changes m_pCurrentGroup!
      m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
    }
    //else: never delete the root group
@@ -832,7 +832,7 @@ bool wxFileConfig::DeleteAll()
  if ( remove(m_strLocalFile.fn_str()) == -1 )
    wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());

-  m_strLocalFile = m_strGlobalFile = _T("");
+  m_strLocalFile = m_strGlobalFile = T("");
  Init();

  return TRUE;
@@ -1004,10 +1004,10 @@ LineList *ConfigGroup::GetGroupLine()
    // this group wasn't present in local config file, add it now
    if ( pParent != NULL ) {
      wxString strFullName;
-      strFullName << _T("[")
+      strFullName << T("[")
                  // +1: no '/'
                  << FilterOutEntryName(GetFullName().c_str() + 1)
-                  << _T("]");
+                  << T("]");
      m_pLine = m_pConfig->LineListInsert(strFullName,
                                          pParent->GetLastGroupLine());
      pParent->SetLastGroup(this);  // we're surely after all the others
@@ -1065,7 +1065,7 @@ void ConfigGroup::Rename(const wxString& newName)

    LineList *line = GetGroupLine();
    wxString strFullName;
-    strFullName << _T("[") << (GetFullName().c_str() + 1) << _T("]"); // +1: no '/'
+    strFullName << T("[") << (GetFullName().c_str() + 1) << T("]"); // +1: no '/'
    line->SetText(strFullName);

    SetDirty();
@@ -1076,7 +1076,7 @@ wxString ConfigGroup::GetFullName() const
  if ( Parent() )
    return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
  else
-    return _T("");
+    return T("");
 }

 // ----------------------------------------------------------------------------
@@ -1374,7 +1374,7 @@ void ConfigEntry::SetValue(const wxString& strValue, bool bUser)
  if ( bUser ) {
    wxString strVal = FilterOutValue(strValue);
    wxString strLine;
-    strLine << FilterOutEntryName(m_strName) << _T('=') << strVal;
+    strLine << FilterOutEntryName(m_strName) << T('=') << strVal;

    if ( m_pLine != NULL ) {
      // entry was read from the local config file, just modify the line
@@ -1440,31 +1440,31 @@ static wxString FilterInValue(const wxString& str)
  bool bQuoted = !str.IsEmpty() && str[0] == '"';

  for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
-    if ( str[n] == _T('\\') ) {
+    if ( str[n] == T('\\') ) {
      switch ( str[++n] ) {
-        case _T('n'):
-          strResult += _T('\n');
+        case T('n'):
+          strResult += T('\n');
          break;

-        case _T('r'):
-          strResult += _T('\r');
+        case T('r'):
+          strResult += T('\r');
          break;

-        case _T('t'):
-          strResult += _T('\t');
+        case T('t'):
+          strResult += T('\t');
          break;

-        case _T('\\'):
-          strResult += _T('\\');
+        case T('\\'):
+          strResult += T('\\');
          break;

-        case _T('"'):
-          strResult += _T('"');
+        case T('"'):
+          strResult += T('"');
          break;
      }
    }
    else {
-      if ( str[n] != _T('"') || !bQuoted )
+      if ( str[n] != T('"') || !bQuoted )
        strResult += str[n];
      else if ( n != str.Len() - 1 ) {
        wxLogWarning(_("unexpected \" at position %d in '%s'."),
@@ -1487,33 +1487,33 @@ static wxString FilterOutValue(const wxString& str)
  strResult.Alloc(str.Len());

  // quoting is necessary to preserve spaces in the beginning of the string
-  bool bQuote = wxIsspace(str[0]) || str[0] == _T('"');
+  bool bQuote = wxIsspace(str[0]) || str[0] == T('"');

  if ( bQuote )
-    strResult += _T('"');
+    strResult += T('"');

  wxChar c;
  for ( size_t n = 0; n < str.Len(); n++ ) {
    switch ( str[n] ) {
-      case _T('\n'):
-        c = _T('n');
+      case T('\n'):
+        c = T('n');
        break;

-      case _T('\r'):
-        c = _T('r');
+      case T('\r'):
+        c = T('r');
        break;

-      case _T('\t'):
-        c = _T('t');
+      case T('\t'):
+        c = T('t');
        break;

-      case _T('\\'):
-        c = _T('\\');
+      case T('\\'):
+        c = T('\\');
        break;

-      case _T('"'):
+      case T('"'):
        if ( bQuote ) {
-          c = _T('"');
+          c = T('"');
          break;
        }
        //else: fall through
@@ -1524,11 +1524,11 @@ static wxString FilterOutValue(const wxString& str)
    }

    // we get here only for special characters
-    strResult << _T('\\') << c;
+    strResult << T('\\') << c;
  }

  if ( bQuote )
-    strResult += _T('"');
+    strResult += T('"');

  return strResult;
 }
@@ -1540,7 +1540,7 @@ static wxString FilterInEntryName(const wxString& str)
  strResult.Alloc(str.Len());

  for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
-    if ( *pc == _T('\\') )
+    if ( *pc == T('\\') )
      pc++;

    strResult += *pc;
@@ -1555,15 +1555,15 @@ static wxString FilterOutEntryName(const wxString& str)
  wxString strResult;
  strResult.Alloc(str.Len());

-  for ( const wxChar *pc = str.c_str(); *pc != _T('\0'); pc++ ) {
+  for ( const wxChar *pc = str.c_str(); *pc != T('\0'); pc++ ) {
    wxChar c = *pc;

    // we explicitly allow some of "safe" chars and 8bit ASCII characters
    // which will probably never have special meaning
    // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
    //     should *not* be quoted
-    if ( !wxIsalnum(c) && !wxStrchr(_T("@_/-!.*%"), c) && ((c & 0x80) == 0) )
-      strResult += _T('\\');
+    if ( !wxIsalnum(c) && !wxStrchr(T("@_/-!.*%"), c) && ((c & 0x80) == 0) )
+      strResult += T('\\');

    strResult += c;
  }
--- a/src/common/filefn.cpp
+++ b/src/common/filefn.cpp
@@ -9,6 +9,14 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////

+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
    #pragma implementation "filefn.h"
 #endif
@@ -100,9 +108,12 @@
    #include "windows.h"
 #endif

+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
 #define _MAXPATHLEN 500

-extern wxChar *wxBuffer;
 #ifdef __WXMAC__
    extern wxChar gwxMacFileName[] ;
    extern wxChar gwxMacFileName2[] ;
@@ -113,6 +124,16 @@ extern wxChar *wxBuffer;
    IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
 #endif

+// ----------------------------------------------------------------------------
+// private globals
+// ----------------------------------------------------------------------------
+
+static wxChar wxFileFunctionsBuffer[4*_MAXPATHLEN];
+
+// ============================================================================
+// implementation
+// ============================================================================
+
 void wxPathList::Add (const wxString& path)
 {
    wxStringList::Add (WXSTRINGCAST path);
@@ -123,9 +144,9 @@ void wxPathList::AddEnvList (const wxString& envVariable)
 {
  static const wxChar PATH_TOKS[] =
 #ifdef __WINDOWS__
-        _T(" ;"); // Don't seperate with colon in DOS (used for drive)
+        T(" ;"); // Don't seperate with colon in DOS (used for drive)
 #else
-        _T(" :;");
+        T(" :;");
 #endif

  wxChar *val = wxGetenv (WXSTRINGCAST envVariable);
@@ -181,11 +202,11 @@ bool wxPathList::Member (const wxString& path)

 wxString wxPathList::FindValidPath (const wxString& file)
 {
-  if (wxFileExists (wxExpandPath(wxBuffer, file)))
-    return wxString(wxBuffer);
+  if (wxFileExists (wxExpandPath(wxFileFunctionsBuffer, file)))
+    return wxString(wxFileFunctionsBuffer);

  wxChar buf[_MAXPATHLEN];
-  wxStrcpy(buf, wxBuffer);
+  wxStrcpy(buf, wxFileFunctionsBuffer);

  wxChar *filename = (wxChar*) NULL; /* shut up buggy egcs warning */
  filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (wxChar *)buf;
@@ -193,48 +214,39 @@ wxString wxPathList::FindValidPath (const wxString& file)
  for (wxNode * node = First (); node; node = node->Next ())
    {
      wxChar *path = (wxChar *) node->Data ();
-      wxStrcpy (wxBuffer, path);
-      wxChar ch = wxBuffer[wxStrlen(wxBuffer)-1];
-      if (ch != _T('\\') && ch != _T('/'))
-        wxStrcat (wxBuffer, _T("/"));
-      wxStrcat (wxBuffer, filename);
+      wxStrcpy (wxFileFunctionsBuffer, path);
+      wxChar ch = wxFileFunctionsBuffer[wxStrlen(wxFileFunctionsBuffer)-1];
+      if (ch != T('\\') && ch != T('/'))
+        wxStrcat (wxFileFunctionsBuffer, T("/"));
+      wxStrcat (wxFileFunctionsBuffer, filename);
 #ifdef __WINDOWS__
-      Unix2DosFilename (wxBuffer);
+      Unix2DosFilename (wxFileFunctionsBuffer);
 #endif
-      if (wxFileExists (wxBuffer))
+      if (wxFileExists (wxFileFunctionsBuffer))
      {
-        return wxString(wxBuffer);        // Found!
+        return wxString(wxFileFunctionsBuffer);        // Found!
      }
    }                                // for()

-  return wxString(_T(""));                    // Not found
+  return wxString(T(""));                    // Not found
 }

 wxString wxPathList::FindAbsoluteValidPath (const wxString& file)
 {
-  wxString f = FindValidPath(file);
-  if (wxIsAbsolutePath(f))
-    return f;
-  else
-  {
-    wxChar buf[500];
-    wxGetWorkingDirectory(buf, 499);
-    int len = (int)wxStrlen(buf);
-    wxChar lastCh = 0;
-    if (len > 0)
-      lastCh = buf[len-1];
-    if (lastCh != _T('/') && lastCh != _T('\\'))
+    wxString f = FindValidPath(file);
+    if ( wxIsAbsolutePath(f) )
+        return f;
+
+    wxString buf;
+    wxGetWorkingDirectory(buf.GetWriteBuf(_MAXPATHLEN), _MAXPATHLEN - 1);
+    buf.UngetWriteBuf();
+    if ( !wxEndsWithPathSeparator(buf) )
    {
-#ifdef __WINDOWS__
-      wxStrcat(buf, _T("\\"));
-#else
-      wxStrcat(buf, _T("/"));
-#endif
+        buf += wxFILE_SEP_PATH;
    }
-    wxStrcat(buf, (const wxChar *)f);
-    wxStrcpy(wxBuffer, buf);
-    return wxString(wxBuffer);
-  }
+    buf += f;
+
+    return buf;
 }

 bool
@@ -260,7 +272,7 @@ wxFileExists (const wxString& filename)
  struct stat stbuf;
 #endif

-  if ((filename != _T("")) && stat (FNSTRINGCAST filename.fn_str(), &stbuf) == 0)
+  if ((filename != T("")) && stat (wxFNSTRINGCAST filename.fn_str(), &stbuf) == 0)
    return TRUE;
  return FALSE;
 #endif
@@ -281,15 +293,15 @@ bool wxFileExists(const char *pszFileName)
 bool
 wxIsAbsolutePath (const wxString& filename)
 {
-  if (filename != _T(""))
+  if (filename != T(""))
    {
-      if (filename[0] == _T('/')
+      if (filename[0] == T('/')
 #ifdef __VMS__
-      || (filename[0] == _T('[') && filename[1] != _T('.'))
+      || (filename[0] == T('[') && filename[1] != T('.'))
 #endif
 #ifdef __WINDOWS__
      /* MSDOS */
-      || filename[0] == _T('\\') || (wxIsalpha (filename[0]) && filename[1] == _T(':'))
+      || filename[0] == T('\\') || (wxIsalpha (filename[0]) && filename[1] == T(':'))
 #endif
        )
        return TRUE;
@@ -309,7 +321,7 @@ void wxStripExtension(wxChar *buffer)
  int i = len-1;
  while (i > 0)
  {
-    if (buffer[i] == _T('.'))
+    if (buffer[i] == T('.'))
    {
      buffer[i] = 0;
      break;
@@ -324,7 +336,7 @@ void wxStripExtension(wxString& buffer)
  size_t i = len-1;
  while (i > 0)
  {
-    if (buffer.GetChar(i) == _T('.'))
+    if (buffer.GetChar(i) == T('.'))
    {
      buffer = buffer.Left(i);
      break;
@@ -337,15 +349,15 @@ void wxStripExtension(wxString& buffer)
 wxChar *wxRealPath (wxChar *path)
 {
 #ifdef __WXMSW__
-  static const wxChar SEP = _T('\\');
+  static const wxChar SEP = T('\\');
  Unix2DosFilename(path);
 #else
-  static const wxChar SEP = _T('/');
+  static const wxChar SEP = T('/');
 #endif
  if (path[0] && path[1]) {
    /* MATTHEW: special case "/./x" */
    wxChar *p;
-    if (path[2] == SEP && path[1] == _T('.'))
+    if (path[2] == SEP && path[1] == T('.'))
      p = &path[0];
    else
      p = &path[2];
@@ -353,31 +365,31 @@ wxChar *wxRealPath (wxChar *path)
      {
        if (*p == SEP)
          {
-            if (p[1] == _T('.') && p[2] == _T('.') && (p[3] == SEP || p[3] == _T('\0')))
+            if (p[1] == T('.') && p[2] == T('.') && (p[3] == SEP || p[3] == T('\0')))
              {
                wxChar *q;
                for (q = p - 1; q >= path && *q != SEP; q--);
-                if (q[0] == SEP && (q[1] != _T('.') || q[2] != _T('.') || q[3] != SEP)
+                if (q[0] == SEP && (q[1] != T('.') || q[2] != T('.') || q[3] != SEP)
                    && (q - 1 <= path || q[-1] != SEP))
                  {
                    wxStrcpy (q, p + 3);
-                    if (path[0] == _T('\0'))
+                    if (path[0] == T('\0'))
                      {
                        path[0] = SEP;
-                        path[1] = _T('\0');
+                        path[1] = T('\0');
                      }
 #ifdef __WXMSW__
                    /* Check that path[2] is NULL! */
-                    else if (path[1] == _T(':') && !path[2])
+                    else if (path[1] == T(':') && !path[2])
                      {
                        path[2] = SEP;
-                        path[3] = _T('\0');
+                        path[3] = T('\0');
                      }
 #endif
                    p = q - 1;
                  }
              }
-            else if (p[1] == _T('.') && (p[2] == SEP || p[2] == _T('\0')))
+            else if (p[1] == T('.') && (p[2] == SEP || p[2] == T('\0')))
              wxStrcpy (p, p + 2);
          }
      }
@@ -388,25 +400,25 @@ wxChar *wxRealPath (wxChar *path)
 // Must be destroyed
 wxChar *wxCopyAbsolutePath(const wxString& filename)
 {
-  if (filename == _T(""))
+  if (filename == T(""))
    return (wxChar *) NULL;

-  if (! IsAbsolutePath(wxExpandPath(wxBuffer, filename))) {
+  if (! IsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename))) {
    wxChar  buf[_MAXPATHLEN];
-    buf[0] = _T('\0');
+    buf[0] = T('\0');
    wxGetWorkingDirectory(buf, WXSIZEOF(buf));
    wxChar ch = buf[wxStrlen(buf) - 1];
 #ifdef __WXMSW__
-    if (ch != _T('\\') && ch != _T('/'))
-        wxStrcat(buf, _T("\\"));
+    if (ch != T('\\') && ch != T('/'))
+        wxStrcat(buf, T("\\"));
 #else
-    if (ch != _T('/'))
-        wxStrcat(buf, _T("/"));
+    if (ch != T('/'))
+        wxStrcat(buf, T("/"));
 #endif
-    wxStrcat(buf, wxBuffer);
+    wxStrcat(buf, wxFileFunctionsBuffer);
    return copystring( wxRealPath(buf) );
  }
-  return copystring( wxBuffer );
+  return copystring( wxFileFunctionsBuffer );
 }

 /*-
@@ -439,21 +451,21 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
    int                                q;

    // Some compilers don't like this line.
-//    const wxChar    trimchars[] = _T("\n \t");
+//    const wxChar    trimchars[] = T("\n \t");

    wxChar      trimchars[4];
-    trimchars[0] = _T('\n');
-    trimchars[1] = _T(' ');
-    trimchars[2] = _T('\t');
+    trimchars[0] = T('\n');
+    trimchars[1] = T(' ');
+    trimchars[2] = T('\t');
    trimchars[3] = 0;

 #ifdef __WXMSW__
-     const wxChar     SEP = _T('\\');
+     const wxChar     SEP = T('\\');
 #else
-     const wxChar     SEP = _T('/');
+     const wxChar     SEP = T('/');
 #endif
-    buf[0] = _T('\0');
-    if (name == NULL || *name == _T('\0'))
+    buf[0] = T('\0');
+    if (name == NULL || *name == T('\0'))
        return buf;
    nm = copystring(name); // Make a scratch copy
    wxChar *nm_tmp = nm;
@@ -464,14 +476,14 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
    /* And strip off trailing whitespace and cr */
    s = nm + (q = wxStrlen(nm)) - 1;
    while (q-- && wxStrchr((wxChar *)trimchars, *s) != NULL)
-        *s = _T('\0');
+        *s = T('\0');

    s = nm;
    d = lnm;
 #ifdef __WXMSW__
    q = FALSE;
 #else
-    q = nm[0] == _T('\\') && nm[1] == _T('~');
+    q = nm[0] == T('\\') && nm[1] == T('~');
 #endif

    /* Expand inline environment variables */
@@ -479,7 +491,7 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
    while (*d)
    {
      *d++ = *s;
-      if(*s == _T('\\'))
+      if(*s == T('\\'))
      {
        *(d - 1) = *++s;
        if (*d)
@@ -494,7 +506,7 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
 #else
    while ((*d++ = *s)) {
 #  ifndef __WXMSW__
-        if (*s == _T('\\')) {
+        if (*s == T('\\')) {
            if ((*(d - 1) = *++s)) {
                s++;
                continue;
@@ -504,13 +516,13 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
 #  endif
 #endif
 #ifdef __WXMSW__
-        if (*s++ == _T('$') && (*s == _T('{') || *s == _T(')')))
+        if (*s++ == T('$') && (*s == T('{') || *s == T(')')))
 #else
-        if (*s++ == _T('$'))
+        if (*s++ == T('$'))
 #endif
        {
            register wxChar  *start = d;
-            register int     braces = (*s == _T('{') || *s == _T('('));
+            register int     braces = (*s == T('{') || *s == T('('));
            register wxChar  *value;
 #ifdef __VISAGECPP__
    // VA gives assignment in logical expr warning
@@ -519,7 +531,7 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
 #else
            while ((*d++ = *s))
 #endif
-                if (braces ? (*s == _T('}') || *s == _T(')')) : !(wxIsalnum(*s) || *s == _T('_')) )
+                if (braces ? (*s == T('}') || *s == T(')')) : !(wxIsalnum(*s) || *s == T('_')) )
                    break;
                else
                    s++;
@@ -541,14 +553,14 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)

    /* Expand ~ and ~user */
    nm = lnm;
-    s = _T("");
-    if (nm[0] == _T('~') && !q)
+    s = T("");
+    if (nm[0] == T('~') && !q)
    {
        /* prefix ~ */
        if (nm[1] == SEP || nm[1] == 0)
        {        /* ~/filename */
 	    // FIXME: wxGetUserHome could return temporary storage in Unicode mode
-            if ((s = WXSTRINGCAST wxGetUserHome(_T(""))) != NULL) {
+            if ((s = WXSTRINGCAST wxGetUserHome(T(""))) != NULL) {
                if (*++nm)
                    nm++;
            }
@@ -565,7 +577,7 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
            if ((home = WXSTRINGCAST wxGetUserHome(wxString(nm + 1))) == NULL) {
               if (was_sep) /* replace only if it was there: */
                   *s = SEP;
-                s = _T("");
+                s = T("");
            } else {
                nm = nnm;
                s = home;
@@ -576,7 +588,7 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
    d = buf;
    if (s && *s) { /* MATTHEW: s could be NULL if user '~' didn't exist */
        /* Copy home dir */
-        while (_T('\0') != (*d++ = *s++))
+        while (T('\0') != (*d++ = *s++))
          /* loop */;
        // Handle root home
        if (d - 1 > buf && *(d - 2) != SEP)
@@ -608,7 +620,7 @@ wxContractPath (const wxString& filename, const wxString& envname, const wxStrin
 {
  static wxChar dest[_MAXPATHLEN];

-  if (filename == _T(""))
+  if (filename == T(""))
    return (wxChar *) NULL;

  wxStrcpy (dest, WXSTRINGCAST filename);
@@ -622,12 +634,12 @@ wxContractPath (const wxString& filename, const wxString& envname, const wxStrin
  if (envname != WXSTRINGCAST NULL && (val = wxGetenv (WXSTRINGCAST envname)) != NULL &&
     (tcp = wxStrstr (dest, val)) != NULL)
    {
-        wxStrcpy (wxBuffer, tcp + wxStrlen (val));
-        *tcp++ = _T('$');
-        *tcp++ = _T('{');
+        wxStrcpy (wxFileFunctionsBuffer, tcp + wxStrlen (val));
+        *tcp++ = T('$');
+        *tcp++ = T('{');
        wxStrcpy (tcp, WXSTRINGCAST envname);
-        wxStrcat (tcp, _T("}"));
-        wxStrcat (tcp, wxBuffer);
+        wxStrcat (tcp, T("}"));
+        wxStrcat (tcp, wxFileFunctionsBuffer);
    }

  // Handle User's home (ignore root homes!)
@@ -636,16 +648,16 @@ wxContractPath (const wxString& filename, const wxString& envname, const wxStrin
      (len = wxStrlen(val)) > 2 &&
      wxStrncmp(dest, val, len) == 0)
    {
-      wxStrcpy(wxBuffer, _T("~"));
-      if (user != _T(""))
-             wxStrcat(wxBuffer, (const wxChar*) user);
+      wxStrcpy(wxFileFunctionsBuffer, T("~"));
+      if (user != T(""))
+             wxStrcat(wxFileFunctionsBuffer, (const wxChar*) user);
 #ifdef __WXMSW__
-//      strcat(wxBuffer, "\\");
+//      strcat(wxFileFunctionsBuffer, "\\");
 #else
-//      strcat(wxBuffer, "/");
+//      strcat(wxFileFunctionsBuffer, "/");
 #endif
-      wxStrcat(wxBuffer, dest + len);
-      wxStrcpy (dest, wxBuffer);
+      wxStrcat(wxFileFunctionsBuffer, dest + len);
+      wxStrcpy (dest, wxFileFunctionsBuffer);
    }

  return dest;
@@ -662,16 +674,16 @@ wxChar *wxFileNameFromPath (wxChar *path)
      tcp = path + wxStrlen (path);
      while (--tcp >= path)
        {
-          if (*tcp == _T('/') || *tcp == _T('\\')
+          if (*tcp == T('/') || *tcp == T('\\')
 #ifdef __VMS__
-     || *tcp == _T(':') || *tcp == _T(']'))
+     || *tcp == T(':') || *tcp == T(']'))
 #else
     )
 #endif
            return tcp + 1;
        }                        /* while */
 #if defined(__WXMSW__) || defined(__WXPM__)
-      if (wxIsalpha (*path) && *(path + 1) == _T(':'))
+      if (wxIsalpha (*path) && *(path + 1) == T(':'))
        return path + 2;
 #endif
    }
@@ -680,7 +692,7 @@ wxChar *wxFileNameFromPath (wxChar *path)

 wxString wxFileNameFromPath (const wxString& path1)
 {
-  if (path1 != _T(""))
+  if (path1 != T(""))
  {

      wxChar *path = WXSTRINGCAST path1 ;
@@ -689,16 +701,16 @@ wxString wxFileNameFromPath (const wxString& path1)
      tcp = path + wxStrlen (path);
      while (--tcp >= path)
          {
-            if (*tcp == _T('/') || *tcp == _T('\\')
+            if (*tcp == T('/') || *tcp == T('\\')
 #ifdef __VMS__
-        || *tcp == _T(':') || *tcp == _T(']'))
+        || *tcp == T(':') || *tcp == T(']'))
 #else
        )
 #endif
                return wxString(tcp + 1);
            }                        /* while */
 #if defined(__WXMSW__) || defined(__WXPM__)
-      if (wxIsalpha (*path) && *(path + 1) == _T(':'))
+      if (wxIsalpha (*path) && *(path + 1) == T(':'))
            return wxString(path + 2);
 #endif
    }
@@ -727,7 +739,7 @@ wxPathOnly (wxChar *path)
      while (!done && i > -1)
      {
        // ] is for VMS
-        if (path[i] == _T('/') || path[i] == _T('\\') || path[i] == _T(']'))
+        if (path[i] == T('/') || path[i] == T('\\') || path[i] == T(']'))
        {
          done = TRUE;
 #ifdef __VMS__
@@ -743,11 +755,11 @@ wxPathOnly (wxChar *path)

 #if defined(__WXMSW__) || defined(__WXPM__)
      // Try Drive specifier
-      if (wxIsalpha (buf[0]) && buf[1] == _T(':'))
+      if (wxIsalpha (buf[0]) && buf[1] == T(':'))
        {
          // A:junk --> A:. (since A:.\junk Not A:\junk)
-          buf[2] = _T('.');
-          buf[3] = _T('\0');
+          buf[2] = T('.');
+          buf[3] = T('\0');
          return buf;
        }
 #endif
@@ -759,7 +771,7 @@ wxPathOnly (wxChar *path)
 // Return just the directory, or NULL if no directory
 wxString wxPathOnly (const wxString& path)
 {
-  if (path != _T(""))
+  if (path != T(""))
    {
      wxChar buf[_MAXPATHLEN];

@@ -775,7 +787,7 @@ wxString wxPathOnly (const wxString& path)
      while (!done && i > -1)
      {
        // ] is for VMS
-        if (path[i] == _T('/') || path[i] == _T('\\') || path[i] == _T(']'))
+        if (path[i] == T('/') || path[i] == T('\\') || path[i] == T(']'))
        {
          done = TRUE;
 #ifdef __VMS__
@@ -791,17 +803,17 @@ wxString wxPathOnly (const wxString& path)

 #if defined(__WXMSW__) || defined(__WXPM__)
      // Try Drive specifier
-      if (wxIsalpha (buf[0]) && buf[1] == _T(':'))
+      if (wxIsalpha (buf[0]) && buf[1] == T(':'))
        {
          // A:junk --> A:. (since A:.\junk Not A:\junk)
-          buf[2] = _T('.');
-          buf[3] = _T('\0');
+          buf[2] = T('.');
+          buf[3] = T('\0');
          return wxString(buf);
        }
 #endif
    }

-  return wxString(_T(""));
+  return wxString(T(""));
 }

 // Utility for converting delimiters in DOS filenames to UNIX style
@@ -815,15 +827,15 @@ wxMac2UnixFilename (wxChar *s)
        if (s)
        {
                memmove( s+1 , s ,(strlen( s ) + 1)*sizeof(wxChar)) ;
-                if ( *s == _T(':') )
-                        *s = _T('.') ;
+                if ( *s == T(':') )
+                        *s = T('.') ;
                else
-                        *s = _T('/') ;
+                        *s = T('/') ;

                while (*s)
                {
-                        if (*s == _T(':'))
-                          *s = _T('/');
+                        if (*s == T(':'))
+                          *s = T('/');
                        else
                          *s = wxTolower(*s);        // Case INDEPENDENT
                        s++;
@@ -836,24 +848,24 @@ wxUnix2MacFilename (wxChar *s)
 {
        if (s)
        {
-                if ( *s == _T('.') )
+                if ( *s == T('.') )
                {
                        // relative path , since it goes on with slash which is translated to a :
                        memmove( s , s+1 ,strlen( s )*sizeof(wxChar) ) ;
                }
-                else if ( *s == _T('/') )
+                else if ( *s == T('/') )
                {
                        // absolute path -> on mac just start with the drive name
                        memmove( s , s+1 ,strlen( s )*sizeof(wxChar) ) ;
                }
                else
                {
-                        wxASSERT_MSG( 1 , _T("unknown path beginning") ) ;
+                        wxASSERT_MSG( 1 , T("unknown path beginning") ) ;
                }
                while (*s)
                {
-                        if (*s == _T('/') || *s == _T('\\'))
-                                  *s = _T(':');
+                        if (*s == T('/') || *s == T('\\'))
+                                  *s = T(':');

                        s++ ;
                }
@@ -866,8 +878,8 @@ wxDos2UnixFilename (wxChar *s)
  if (s)
    while (*s)
      {
-        if (*s == _T('\\'))
-          *s = _T('/');
+        if (*s == T('\\'))
+          *s = T('/');
 #if defined(__WXMSW__) || defined(__WXPM__)
        else
          *s = wxTolower(*s);        // Case INDEPENDENT
@@ -888,8 +900,8 @@ wxUnix2DosFilename (wxChar *WXUNUSED(s))
  if (s)
    while (*s)
      {
-        if (*s == _T('/'))
-          *s = _T('\\');
+        if (*s == T('/'))
+          *s = T('\\');
        s++;
      }
 #endif
@@ -917,8 +929,8 @@ wxConcatFiles (const wxString& file1, const wxString& file2, const wxString& fil
      (fp2 = fopen (gwxMacFileName2, "rb")) == NULL ||
      (fp3 = fopen (gwxMacFileName3, "wb")) == NULL)
 #else
-  if ((fp1 = fopen (FNSTRINGCAST file1.fn_str(), "rb")) == NULL ||
-      (fp2 = fopen (FNSTRINGCAST file2.fn_str(), "rb")) == NULL ||
+  if ((fp1 = fopen (wxFNSTRINGCAST file1.fn_str(), "rb")) == NULL ||
+      (fp2 = fopen (wxFNSTRINGCAST file2.fn_str(), "rb")) == NULL ||
      (fp3 = fopen (wxFNCONV(outfile), "wb")) == NULL)
 #endif
    {
@@ -964,9 +976,9 @@ wxCopyFile (const wxString& file1, const wxString& file2)
    return FALSE;
  if ((fd2 = fopen (gwxMacFileName2, "wb")) == NULL)
 #else
-  if ((fd1 = fopen (FNSTRINGCAST file1.fn_str(), "rb")) == NULL)
+  if ((fd1 = fopen (wxFNSTRINGCAST file1.fn_str(), "rb")) == NULL)
    return FALSE;
-  if ((fd2 = fopen (FNSTRINGCAST file2.fn_str(), "wb")) == NULL)
+  if ((fd2 = fopen (wxFNSTRINGCAST file2.fn_str(), "wb")) == NULL)
 #endif
    {
      fclose (fd1);
@@ -994,7 +1006,7 @@ wxRenameFile (const wxString& file1, const wxString& file2)
    return TRUE;
 #else
  // Normal system call
-  if (0 == rename (FNSTRINGCAST file1.fn_str(), FNSTRINGCAST file2.fn_str()))
+  if (0 == rename (wxFNSTRINGCAST file1.fn_str(), wxFNSTRINGCAST file2.fn_str()))
    return TRUE;
 #endif
  // Try to copy
@@ -1009,13 +1021,13 @@ wxRenameFile (const wxString& file1, const wxString& file2)
 bool wxRemoveFile(const wxString& file)
 {
 #if defined(__VISUALC__) || defined(__BORLANDC__) || defined(__WATCOMC__)
-  int flag = remove(FNSTRINGCAST file.fn_str());
+  int flag = remove(wxFNSTRINGCAST file.fn_str());
 #elif defined( __WXMAC__ )
        wxStrcpy( gwxMacFileName , file ) ;
        wxUnix2MacFilename( gwxMacFileName ) ;
  int flag = unlink(gwxMacFileName);
 #else
-  int flag = unlink(FNSTRINGCAST file.fn_str());
+  int flag = unlink(wxFNSTRINGCAST file.fn_str());
 #endif
  return (flag == 0) ;
 }
@@ -1035,7 +1047,7 @@ bool wxMkdir(const wxString& dir, int perm)
 #if (!(defined(__WXMSW__) || defined(__WXPM__))) || (defined(__GNUWIN32__) && !defined(__MINGW32__)) || defined(__WXWINE__)
    if ( mkdir(wxFNCONV(dirname), perm) != 0 )
 #else  // MSW and OS/2
-    if ( mkdir(FNSTRINGCAST wxFNCONV(dirname)) != 0 )
+    if ( mkdir(wxFNSTRINGCAST wxFNCONV(dirname)) != 0 )
 #endif // !MSW/MSW
    {
        wxLogSysError(_("Directory '%s' couldn't be created"), dirname);
@@ -1059,7 +1071,7 @@ bool wxRmdir(const wxString& dir, int WXUNUSED(flags))
 #ifdef __SALFORDC__
  return FALSE; // What to do?
 #else
-  return (rmdir(FNSTRINGCAST dir.fn_str()) == 0);
+  return (rmdir(wxFNSTRINGCAST dir.fn_str()) == 0);
 #endif

 #endif
@@ -1117,8 +1129,8 @@ bool wxPathExists(const wxChar *pszPathName)
  /* Windows API returns -1 from stat for "c:\dir\" if "c:\dir" exists
   * OTOH, we should change "d:" to "d:\" and leave "\" as is. */
  wxString strPath(pszPathName);
-  if ( wxEndsWithPathSeparator(pszPathName) && pszPathName[1] != _T('\0') )
-    strPath.Last() = _T('\0');
+  if ( wxEndsWithPathSeparator(pszPathName) && pszPathName[1] != T('\0') )
+    strPath.Last() = T('\0');

 #ifdef __SALFORDC__
  struct _stat st;
@@ -1126,7 +1138,7 @@ bool wxPathExists(const wxChar *pszPathName)
  struct stat st;
 #endif

-  return stat(FNSTRINGCAST strPath.fn_str(), &st) == 0 && (st.st_mode & S_IFDIR);
+  return stat(wxFNSTRINGCAST strPath.fn_str(), &st) == 0 && (st.st_mode & S_IFDIR);
 }

 // Get a temporary filename, opening and closing the file.
@@ -1154,7 +1166,7 @@ wxChar *wxGetTempFileName(const wxString& prefix, wxChar *buf)

  for (short suffix = last_temp + 1; suffix != last_temp; ++suffix %= 1000)
    {
-      wxSprintf (tmp, _T("/tmp/%s%d.%03x"), WXSTRINGCAST prefix, (int) getpid (), (int) suffix);
+      wxSprintf (tmp, T("/tmp/%s%d.%03x"), WXSTRINGCAST prefix, (int) getpid (), (int) suffix);
      if (!wxFileExists( tmp ))
        {
          // Touch the file to create it (reserve name)
@@ -1205,11 +1217,11 @@ wxString wxFindFirstFile(const wxChar *spec, int flags)
    wxString path(wxPathOnly(gs_strFileSpec));

    // special case: path is really "/"
-    if ( !path && gs_strFileSpec[0u] == _T('/') )
-        path = _T('/');
+    if ( !path && gs_strFileSpec[0u] == T('/') )
+        path = T('/');
    // path is empty => Local directory
    if ( !path )
-        path = _T('.');
+        path = T('.');

    gs_dirStream = opendir(path.fn_str());
    if ( !gs_dirStream )
@@ -1231,7 +1243,7 @@ wxString wxFindNextFile()
    wxString result;

 #ifndef __VMS__
-    wxCHECK_MSG( gs_dirStream, result, _T("must call wxFindFirstFile first") );
+    wxCHECK_MSG( gs_dirStream, result, T("must call wxFindFirstFile first") );

    // Find path only so we can concatenate
    // found file onto path
@@ -1239,8 +1251,8 @@ wxString wxFindNextFile()
    wxString name(wxFileNameFromPath(gs_strFileSpec));

    /* MATTHEW: special case: path is really "/" */
-    if ( !path && gs_strFileSpec[0u] == _T('/'))
-        path = _T('/');
+    if ( !path && gs_strFileSpec[0u] == T('/'))
+        path = T('/');

    // Do the reading
    struct dirent *nextDir;
@@ -1254,8 +1266,8 @@ wxString wxFindNextFile()
            if ( !path.IsEmpty() )
            {
                result = path;
-                if ( path != _T('/') )
-                    result += _T('/');
+                if ( path != T('/') )
+                    result += T('/');
            }

            result += nextDir->d_name;
@@ -1318,7 +1330,7 @@ wxString wxFindFirstFile(const wxChar *spec, int flags)
    // Find path only so we can concatenate found file onto path
    wxString path(wxPathOnly(gs_strFileSpec));
    if ( !path.IsEmpty() )
-        result << path << _T('\\');
+        result << path << T('\\');

 #ifdef __WIN32__
    if ( gs_hFileStruct != INVALID_HANDLE_VALUE )
@@ -1411,7 +1423,7 @@ try_again:
            goto try_again;

        if ( !path.IsEmpty() )
-            result << path << _T('\\');
+            result << path << T('\\');
        result << gs_findDataStruct.cFileName;
    }

@@ -1477,8 +1489,8 @@ wxChar *wxGetWorkingDirectory(wxChar *buf, int sz)
  if (getcwd(buf, sz) == NULL) {
 #endif
 #endif
-    buf[0] = _T('.');
-    buf[1] = _T('\0');
+    buf[0] = T('.');
+    buf[1] = T('\0');
  }
 #if wxUSE_UNICODE
  else {
@@ -1503,7 +1515,7 @@ wxString wxGetCwd()
 bool wxSetWorkingDirectory(const wxString& d)
 {
 #if defined( __UNIX__ ) || defined( __WXMAC__ ) || defined(__WXPM__)
-  return (chdir(FNSTRINGCAST d.fn_str()) == 0);
+  return (chdir(wxFNSTRINGCAST d.fn_str()) == 0);
 #elif defined(__WINDOWS__)

 #ifdef __WIN32__
@@ -1601,7 +1613,7 @@ void WXDLLEXPORT wxSplitPath(const wxChar *pszFileName,
                             wxString *pstrExt)
 {
    // it can be empty, but it shouldn't be NULL
-    wxCHECK_RET( pszFileName, _T("NULL file name in wxSplitPath") );
+    wxCHECK_RET( pszFileName, T("NULL file name in wxSplitPath") );

    const wxChar *pDot = wxStrrchr(pszFileName, wxFILE_SEP_EXT);

@@ -1661,9 +1673,9 @@ bool wxIsWild( const wxString& pattern )
  wxChar *pat = WXSTRINGCAST(tmp);
    while (*pat) {
        switch (*pat++) {
-        case _T('?'): case _T('*'): case _T('['): case _T('{'):
+        case T('?'): case T('*'): case T('['): case T('{'):
            return TRUE;
-        case _T('\\'):
+        case T('\\'):
            if (!*pat++)
                return FALSE;
        }
@@ -1697,57 +1709,57 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
    wxChar *cp;
    bool done = FALSE, ret_code, ok;
    // Below is for vi fans
-    const wxChar OB = _T('{'), CB = _T('}');
+    const wxChar OB = T('{'), CB = T('}');

    // dot_special means '.' only matches '.'
-    if (dot_special && *str == _T('.') && *pattern != *str)
+    if (dot_special && *str == T('.') && *pattern != *str)
        return FALSE;

-    while ((*pattern != _T('\0')) && (!done)
-    && (((*str==_T('\0'))&&((*pattern==OB)||(*pattern==_T('*'))))||(*str!=_T('\0')))) {
+    while ((*pattern != T('\0')) && (!done)
+    && (((*str==T('\0'))&&((*pattern==OB)||(*pattern==T('*'))))||(*str!=T('\0')))) {
        switch (*pattern) {
-        case _T('\\'):
+        case T('\\'):
            pattern++;
-            if (*pattern != _T('\0'))
+            if (*pattern != T('\0'))
                pattern++;
            break;
-        case _T('*'):
+        case T('*'):
            pattern++;
            ret_code = FALSE;
-            while ((*str!=_T('\0'))
+            while ((*str!=T('\0'))
            && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
                /*loop*/;
            if (ret_code) {
-                while (*str != _T('\0'))
+                while (*str != T('\0'))
                    str++;
-                while (*pattern != _T('\0'))
+                while (*pattern != T('\0'))
                    pattern++;
            }
            break;
-        case _T('['):
+        case T('['):
            pattern++;
          repeat:
-            if ((*pattern == _T('\0')) || (*pattern == _T(']'))) {
+            if ((*pattern == T('\0')) || (*pattern == T(']'))) {
                done = TRUE;
                break;
            }
-            if (*pattern == _T('\\')) {
+            if (*pattern == T('\\')) {
                pattern++;
-                if (*pattern == _T('\0')) {
+                if (*pattern == T('\0')) {
                    done = TRUE;
                    break;
                }
            }
-            if (*(pattern + 1) == _T('-')) {
+            if (*(pattern + 1) == T('-')) {
                c = *pattern;
                pattern += 2;
-                if (*pattern == _T(']')) {
+                if (*pattern == T(']')) {
                    done = TRUE;
                    break;
                }
-                if (*pattern == _T('\\')) {
+                if (*pattern == T('\\')) {
                    pattern++;
-                    if (*pattern == _T('\0')) {
+                    if (*pattern == T('\0')) {
                        done = TRUE;
                        break;
                    }
@@ -1761,51 +1773,51 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
                goto repeat;
            }
            pattern++;
-            while ((*pattern != _T(']')) && (*pattern != _T('\0'))) {
-                if ((*pattern == _T('\\')) && (*(pattern + 1) != _T('\0')))
+            while ((*pattern != T(']')) && (*pattern != T('\0'))) {
+                if ((*pattern == T('\\')) && (*(pattern + 1) != T('\0')))
                    pattern++;
                pattern++;
            }
-            if (*pattern != _T('\0')) {
+            if (*pattern != T('\0')) {
                pattern++, str++;
            }
            break;
-        case _T('?'):
+        case T('?'):
            pattern++;
            str++;
            break;
        case OB:
            pattern++;
-            while ((*pattern != CB) && (*pattern != _T('\0'))) {
+            while ((*pattern != CB) && (*pattern != T('\0'))) {
                cp = str;
                ok = TRUE;
-                while (ok && (*cp != _T('\0')) && (*pattern != _T('\0'))
-                &&  (*pattern != _T(',')) && (*pattern != CB)) {
-                    if (*pattern == _T('\\'))
+                while (ok && (*cp != T('\0')) && (*pattern != T('\0'))
+                &&  (*pattern != T(',')) && (*pattern != CB)) {
+                    if (*pattern == T('\\'))
                        pattern++;
                    ok = (*pattern++ == *cp++);
                }
-                if (*pattern == _T('\0')) {
+                if (*pattern == T('\0')) {
                    ok = FALSE;
                    done = TRUE;
                    break;
                } else if (ok) {
                    str = cp;
-                    while ((*pattern != CB) && (*pattern != _T('\0'))) {
-                        if (*++pattern == _T('\\')) {
+                    while ((*pattern != CB) && (*pattern != T('\0'))) {
+                        if (*++pattern == T('\\')) {
                            if (*++pattern == CB)
                                pattern++;
                        }
                    }
                } else {
-                    while (*pattern!=CB && *pattern!=_T(',') && *pattern!=_T('\0')) {
-                        if (*++pattern == _T('\\')) {
-                            if (*++pattern == CB || *pattern == _T(','))
+                    while (*pattern!=CB && *pattern!=T(',') && *pattern!=T('\0')) {
+                        if (*++pattern == T('\\')) {
+                            if (*++pattern == CB || *pattern == T(','))
                                pattern++;
                        }
                    }
                }
-                if (*pattern != _T('\0'))
+                if (*pattern != T('\0'))
                    pattern++;
            }
            break;
@@ -1817,9 +1829,9 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
            }
        }
    }
-    while (*pattern == _T('*'))
+    while (*pattern == T('*'))
        pattern++;
-    return ((*str == _T('\0')) && (*pattern == _T('\0')));
+    return ((*str == T('\0')) && (*pattern == T('\0')));
 };

 #endif
--- a/src/common/filesys.cpp
+++ b/src/common/filesys.cpp
@@ -53,9 +53,9 @@ wxString wxFileSystemHandler::GetMimeTypeFromExt(const wxString& location)
    l2 = l;
    for (int i = l-1; i >= 0; i--) {
        c = loc[(unsigned int) i];
-        if (c == _T('#')) l2 = i + 1;
-        if (c == _T('.')) {ext = loc.Right(l2-i-1); break;}
-        if ((c == _T('/')) || (c == _T('\\')) || (c == _T(':'))) {return wxEmptyString;}
+        if (c == T('#')) l2 = i + 1;
+        if (c == T('.')) {ext = loc.Right(l2-i-1); break;}
+        if ((c == T('/')) || (c == T('\\')) || (c == T(':'))) {return wxEmptyString;}
    }

    if (m_MimeMng == NULL) {
@@ -110,11 +110,11 @@ wxString wxFileSystemHandler::GetProtocol(const wxString& location) const
    bool fnd;

    fnd = FALSE;
-    for (i = l-1; (i >= 0) && ((location[i] != _T('#')) || (!fnd)); i--) {
-        if ((location[i] == _T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
+    for (i = l-1; (i >= 0) && ((location[i] != T('#')) || (!fnd)); i--) {
+        if ((location[i] == T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
    }
-    if (!fnd) return _T("file");
-    for (++i; (i < l) && (location[i] != _T(':')); i++) s << location[i];
+    if (!fnd) return T("file");
+    for (++i; (i < l) && (location[i] != T(':')); i++) s << location[i];
    return s;
 }

@@ -126,8 +126,8 @@ wxString wxFileSystemHandler::GetLeftLocation(const wxString& location) const

    fnd = FALSE;
    for (i = location.Length()-1; i >= 0; i--) {
-        if ((location[i] == _T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
-        else if (fnd && (location[i] == _T('#'))) return location.Left(i);
+        if ((location[i] == T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
+        else if (fnd && (location[i] == T('#'))) return location.Left(i);
    }
    return wxEmptyString;
 }
@@ -136,7 +136,7 @@ wxString wxFileSystemHandler::GetRightLocation(const wxString& location) const
 {
    int i, l = location.Length();
    int l2 = l + 1;
-    for (i = l-1; (i >= 0) && ((location[i] != _T(':')) || (i == 1) || (location[i-2] == _T(':'))); i--) {if (location[i] == _T('#')) l2 = i + 1;}
+    for (i = l-1; (i >= 0) && ((location[i] != T(':')) || (i == 1) || (location[i-2] == T(':'))); i--) {if (location[i] == T('#')) l2 = i + 1;}
    if (i == 0) return wxEmptyString;
    else return location.Mid(i + 1, l2 - i - 2);
 }
@@ -148,8 +148,8 @@ wxString wxFileSystemHandler::GetAnchor(const wxString& location) const

    for (int i = l-1; i >= 0; i--) {
        c = location[i];
-        if (c == _T('#')) return location.Right(l-i-1);
-        else if ((c == _T('.')) || (c == _T('/')) || (c == _T('\\')) || (c == _T(':'))) return wxEmptyString;
+        if (c == T('#')) return location.Right(l-i-1);
+        else if ((c == T('.')) || (c == T('/')) || (c == T('\\')) || (c == T(':'))) return wxEmptyString;
    }
    return wxEmptyString;
 }
@@ -168,7 +168,7 @@ class wxLocalFSHandler : public wxFileSystemHandler

 bool wxLocalFSHandler::CanOpen(const wxString& location)
 {
-    return GetProtocol(location) == _T("file");
+    return GetProtocol(location) == T("file");
 }

 wxFSFile* wxLocalFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
@@ -199,15 +199,15 @@ void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
    m_Path = location;

    for (i = m_Path.Length()-1; i >= 0; i--)
-        if (m_Path[(unsigned int) i] == _T('\\')) m_Path.GetWritableChar(i) = _T('/');         // wanna be windows-safe
+        if (m_Path[(unsigned int) i] == T('\\')) m_Path.GetWritableChar(i) = T('/');         // wanna be windows-safe

    if (is_dir == FALSE)
    {
        for (i = m_Path.Length()-1; i >= 0; i--)
 	{
-            if (m_Path[(unsigned int) i] == _T('/'))
+            if (m_Path[(unsigned int) i] == T('/'))
 	    {
-                if ((i > 1) && (m_Path[(unsigned int) (i-1)] == _T('/')) && (m_Path[(unsigned int) (i-2)] == _T(':')))
+                if ((i > 1) && (m_Path[(unsigned int) (i-1)] == T('/')) && (m_Path[(unsigned int) (i-2)] == T(':')))
 		{
                    i -= 2;
                    continue;
@@ -218,7 +218,7 @@ void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
                    break;
                }
            }
-        else if (m_Path[(unsigned int) i] == _T(':')) {
+        else if (m_Path[(unsigned int) i] == T(':')) {
            pathpos = i;
        break;
        }
@@ -227,9 +227,9 @@ void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
 	{
            for (i = 0; i < (int) m_Path.Length(); i++)
 	    {
-                if (m_Path[(unsigned int) i] == _T(':'))
+                if (m_Path[(unsigned int) i] == T(':'))
 		{
-                    //m_Path << _T('/');
+                    //m_Path << T('/');
                    m_Path.Remove(i+1);
                    break;
                }
@@ -239,8 +239,8 @@ void wxFileSystem::ChangePathTo(const wxString& location, bool is_dir)
        }
        else
 	{
-            if (m_Path[m_Path.Length()-1] != _T('/'))
-	        m_Path << _T('/');
+            if (m_Path[m_Path.Length()-1] != T('/'))
+	        m_Path << T('/');
            m_Path.Remove(pathpos+1);
        }
    }
@@ -260,16 +260,16 @@ wxFSFile* wxFileSystem::OpenFile(const wxString& location)
    meta = 0;
    for (i = 0; i < ln; i++)
    {
-        if (loc[(unsigned int) i] == _T('\\')) loc.GetWritableChar(i) = _T('/');         // wanna be windows-safe
+        if (loc[(unsigned int) i] == T('\\')) loc.GetWritableChar(i) = T('/');         // wanna be windows-safe
        if (!meta) switch (loc[(unsigned int) i])
 	{
-            case _T('/') : case _T(':') : case _T('#') : meta = loc[(unsigned int) i];
+            case T('/') : case T(':') : case T('#') : meta = loc[(unsigned int) i];
        }
    }
    m_LastName = wxEmptyString;

    // try relative paths first :
-    if (meta != _T(':'))
+    if (meta != T(':'))
    {
        node = m_Handlers.GetFirst();
        while (node)
--- a/src/common/fontcmn.cpp
+++ b/src/common/fontcmn.cpp
@@ -70,43 +70,43 @@ bool wxFontBase::operator!=(const wxFont& font) const

 wxString wxFontBase::GetFamilyString() const
 {
-    wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
+    wxCHECK_MSG( Ok(), T("wxDEFAULT("), T("invalid font") );

    switch ( GetFamily() )
    {
-        case wxDECORATIVE:   return _T("wxDECORATIVE");
-        case wxROMAN:        return _T("wxROMAN");
-        case wxSCRIPT:       return _T("wxSCRIPT");
-        case wxSWISS:        return _T("wxSWISS");
-        case wxMODERN:       return _T("wxMODERN");
-        case wxTELETYPE:     return _T("wxTELETYPE");
-        default:             return _T("wxDEFAULT");
+        case wxDECORATIVE:   return T("wxDECORATIVE");
+        case wxROMAN:        return T("wxROMAN");
+        case wxSCRIPT:       return T("wxSCRIPT(");
+        case wxSWISS:        return T("wxSWISS");
+        case wxMODERN:       return T("wxMODERN");
+        case wxTELETYPE:     return T("wxTELETYPE");
+        default:             return T("wxDEFAULT(");
    }
 }

 wxString wxFontBase::GetStyleString() const
 {
-    wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
+    wxCHECK_MSG( Ok(), T("wxDEFAULT("), T("invalid font") );

    switch ( GetStyle() )
    {
-        case wxNORMAL:   return _T("wxNORMAL");
-        case wxSLANT:    return _T("wxSLANT");
-        case wxITALIC:   return _T("wxITALIC");
-        default:         return _T("wxDEFAULT");
+        case wxNORMAL:   return T("wxNORMAL");
+        case wxSLANT:    return T("wxSLANT(");
+        case wxITALIC:   return T("wxITALIC");
+        default:         return T("wxDEFAULT(");
    }
 }

 wxString wxFontBase::GetWeightString() const
 {
-    wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
+    wxCHECK_MSG( Ok(), T("wxDEFAULT("), T("invalid font") );

    switch ( GetWeight() )
    {
-        case wxNORMAL:   return _T("wxNORMAL");
-        case wxBOLD:     return _T("wxBOLD");
-        case wxLIGHT:    return _T("wxLIGHT");
-        default:         return _T("wxDEFAULT");
+        case wxNORMAL:   return T("wxNORMAL");
+        case wxBOLD:     return T("wxBOLD");
+        case wxLIGHT:    return T("wxLIGHT(");
+        default:         return T("wxDEFAULT(");
    }
 }

--- a/src/common/fs_inet.cpp
+++ b/src/common/fs_inet.cpp
@@ -69,13 +69,13 @@ class wxInetCacheNode : public wxObject
 bool wxInternetFSHandler::CanOpen(const wxString& location)
 {
    wxString p = GetProtocol(location);
-    return (p == _T("http")) || (p == _T("ftp"));
+    return (p == T("http")) || (p == T("ftp"));
 }


 wxFSFile* wxInternetFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxString& location)
 {
-    wxString right = GetProtocol(location) + _T(":") + GetRightLocation(location);
+    wxString right = GetProtocol(location) + T(":") + GetRightLocation(location);
    wxInputStream *s;
    wxString content;
    wxInetCacheNode *info;
@@ -93,7 +93,7 @@ wxFSFile* wxInternetFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs), const wxStri
        {
            wxChar buf[256];

-            wxGetTempFileName( _T("wxhtml"), buf);
+            wxGetTempFileName( T("wxhtml"), buf);
            info = new wxInetCacheNode(buf, content);
            m_Cache.Put(right, info);

--- a/src/common/ftp.cpp
+++ b/src/common/ftp.cpp
@@ -50,7 +50,7 @@

 #if !USE_SHARED_LIBRARY
 IMPLEMENT_DYNAMIC_CLASS(wxFTP, wxProtocol)
-IMPLEMENT_PROTOCOL(wxFTP, _T("ftp"), _T("ftp"), TRUE)
+IMPLEMENT_PROTOCOL(wxFTP, T("ftp"), T("ftp"), TRUE)
 #endif

 ////////////////////////////////////////////////////////////////
@@ -63,7 +63,7 @@ wxFTP::wxFTP()
  m_lastError = wxPROTO_NOERR;
  m_streaming = FALSE;

-  m_user = _T("anonymous");
+  m_user = T("anonymous");
  m_passwd = wxGetUserId();
  m_passwd += '@';
  m_passwd += wxGetHostName();
@@ -74,7 +74,7 @@ wxFTP::wxFTP()

 wxFTP::~wxFTP()
 {
-  SendCommand("QUIT", '2');
+  SendCommand("QUIT(", '2');
 }

 ////////////////////////////////////////////////////////////////
@@ -99,13 +99,13 @@ bool wxFTP::Connect(wxSockAddress& addr, bool WXUNUSED(wait))
    return FALSE;
  }

-  command.sprintf(_T("USER %s"), (const wxChar *)m_user);
+  command.sprintf(T("USER %s"), (const wxChar *)m_user);
  if (!SendCommand(command, '3')) {
    Close();
    return FALSE;
  }

-  command.sprintf(_T("PASS %s"), (const wxChar *)m_passwd);
+  command.sprintf(T("PASS %s"), (const wxChar *)m_passwd);
  if (!SendCommand(command, '2')) {
    Close();
    return FALSE;
@@ -120,7 +120,7 @@ bool wxFTP::Connect(const wxString& host)
  wxString my_host = host;

  addr.Hostname(my_host);
-  addr.Service(_T("ftp"));
+  addr.Service(T("ftp"));

  return Connect(addr);
 }
@@ -132,7 +132,7 @@ bool wxFTP::Close()
    return FALSE;
  }
  if (m_connected)
-    SendCommand(wxString(_T("QUIT")), '2');
+    SendCommand(wxString(T("QUIT(")), '2');
  return wxSocketClient::Close();
 }

@@ -147,9 +147,9 @@ bool wxFTP::SendCommand(const wxString& command, char exp_ret)
    m_lastError = wxPROTO_STREAMING;
    return FALSE;
  }
-  tmp_str = command + _T("\r\n");
+  tmp_str = command + T("\r\n");
  const wxWX2MBbuf tmp_buf = tmp_str.mb_str();
-  if (Write(MBSTRINGCAST tmp_buf, strlen(tmp_buf)).Error()) {
+  if (Write(wxMBSTRINGCAST tmp_buf, strlen(tmp_buf)).Error()) {
    m_lastError = wxPROTO_NETERR;
    return FALSE;
  }
@@ -169,7 +169,7 @@ bool wxFTP::GetResult(char exp)
  if (m_lastResult.GetChar(3) == '-') {
    wxString key = m_lastResult.Left((size_t)3);

-    key += _T(' ');
+    key += T(' ');

    while (m_lastResult.Index(key) != 0) {
      m_lastError = GetLine(this, m_lastResult);
@@ -187,14 +187,14 @@ bool wxFTP::ChDir(const wxString& dir)
 {
  wxString str = dir;

-  str.Prepend(_T("CWD "));
+  str.Prepend(T("CWD "));
  return SendCommand(str, '2');
 }

 bool wxFTP::MkDir(const wxString& dir)
 {
  wxString str = dir;
-  str.Prepend(_T("MKD "));
+  str.Prepend(T("MKD "));
  return SendCommand(str, '2');
 }

@@ -202,7 +202,7 @@ bool wxFTP::RmDir(const wxString& dir)
 {
  wxString str = dir;
  
-  str.Prepend(_T("PWD "));
+  str.Prepend(T("PWD "));
  return SendCommand(str, '2');
 }

@@ -210,11 +210,11 @@ wxString wxFTP::Pwd()
 {
  int beg, end;

-  if (!SendCommand(_T("PWD"), '2'))
+  if (!SendCommand(T("PWD"), '2'))
    return wxString((char *)NULL);
  
-  beg = m_lastResult.Find(_T('\"'),FALSE);
-  end = m_lastResult.Find(_T('\"'),TRUE);
+  beg = m_lastResult.Find(T('\"'),FALSE);
+  end = m_lastResult.Find(T('\"'),TRUE);

  return wxString(beg+1, end);
 }
@@ -223,11 +223,11 @@ bool wxFTP::Rename(const wxString& src, const wxString& dst)
 {
  wxString str;

-  str = _T("RNFR ") + src;
+  str = T("RNFR ") + src;
  if (!SendCommand(str, '3'))
    return FALSE;

-  str = _T("RNTO ") + dst;
+  str = T("RNTO ") + dst;
  return SendCommand(str, '2');
 }

@@ -235,7 +235,7 @@ bool wxFTP::RmFile(const wxString& path)
 {
  wxString str;

-  str = _T("DELE ");
+  str = T("DELE ");
  str += path;
  return SendCommand(str, '2');
 }
@@ -288,16 +288,16 @@ wxSocketClient *wxFTP::GetPort()
  wxUint16 port;
  wxUint32 hostaddr;

-  if (!SendCommand(_T("PASV"), '2'))
+  if (!SendCommand(T("PASV"), '2'))
    return NULL;

-  addr_pos = m_lastResult.Find(_T('('));
+  addr_pos = m_lastResult.Find(T('('));
  if (addr_pos == -1) {
    m_lastError = wxPROTO_PROTERR;
    return NULL;
  }
  straddr = m_lastResult(addr_pos+1, m_lastResult.Length());
-  wxSscanf((const wxChar *)straddr,_T("%d,%d,%d,%d,%d,%d"),&a[2],&a[3],&a[4],&a[5],&a[0],&a[1]);
+  wxSscanf((const wxChar *)straddr,T("%d,%d,%d,%d,%d,%d"),&a[2],&a[3],&a[4],&a[5],&a[0],&a[1]);

  hostaddr = (wxUint16)a[5] << 24 | (wxUint16)a[4] << 16 |
             (wxUint16)a[3] << 8 | a[2]; 
@@ -319,7 +319,7 @@ wxSocketClient *wxFTP::GetPort()
 bool wxFTP::Abort(void)
 {
  m_streaming = FALSE;
-  if (!SendCommand(_T("ABOR"), '4'))
+  if (!SendCommand(T("ABOR"), '4'))
    return FALSE;
  return GetResult('2');
 }
@@ -330,7 +330,7 @@ wxInputStream *wxFTP::GetInputStream(const wxString& path)
  int pos_size;
  wxInputFTPStream *in_stream;

-  if (!SendCommand(_T("TYPE I"), '2'))
+  if (!SendCommand(T("TYPE I"), '2'))
    return NULL;

  wxSocketClient *sock = GetPort();
@@ -340,15 +340,15 @@ wxInputStream *wxFTP::GetInputStream(const wxString& path)
    return NULL;
  }

-  tmp_str = _T("RETR ") + wxURL::ConvertFromURI(path);
+  tmp_str = T("RETR ") + wxURL::ConvertFromURI(path);
  if (!SendCommand(tmp_str, '1'))
    return NULL;

  in_stream = new wxInputFTPStream(this, sock);

-  pos_size = m_lastResult.Index(_T('('));
+  pos_size = m_lastResult.Index(T('('));
  if (pos_size != wxNOT_FOUND) {
-    wxString str_size = m_lastResult(pos_size+1, m_lastResult.Index(_T(')'))-1);
+    wxString str_size = m_lastResult(pos_size+1, m_lastResult.Index(T(')'))-1);

    in_stream->m_ftpsize = wxAtoi(WXSTRINGCAST str_size);
  }
@@ -361,12 +361,12 @@ wxOutputStream *wxFTP::GetOutputStream(const wxString& path)
 {
  wxString tmp_str;

-  if (!SendCommand(_T("TYPE I"), '2'))
+  if (!SendCommand(T("TYPE I"), '2'))
    return NULL;

  wxSocketClient *sock = GetPort();

-  tmp_str = _T("STOR ") + path;
+  tmp_str = T("STOR ") + path;
  if (!SendCommand(tmp_str, '1'))
    return FALSE;

@@ -377,7 +377,7 @@ wxList *wxFTP::GetList(const wxString& wildcard)
 {
  wxList *file_list = new wxList;
  wxSocketBase *sock = GetPort();
-  wxString tmp_str = _T("NLST");
+  wxString tmp_str = T("NLST(");

  if (!wildcard.IsNull())
    tmp_str += wildcard;
--- a/src/common/gdicmn.cpp
+++ b/src/common/gdicmn.cpp
@@ -144,84 +144,84 @@ void wxColourDatabase::Initialize ()
  static cdef table[]={

 // #ifdef __WXMSW__
-   {_T("AQUAMARINE"),112, 219, 147},
-   {_T("BLACK"),0, 0, 0},
-   {_T("BLUE"), 0, 0, 255},
-   {_T("BLUE VIOLET"), 159, 95, 159},
-   {_T("BROWN"), 165, 42, 42},
-   {_T("CADET BLUE"), 95, 159, 159},
-   {_T("CORAL"), 255, 127, 0},
-   {_T("CORNFLOWER BLUE"), 66, 66, 111},
-   {_T("CYAN"), 0, 255, 255},
-   {_T("DARK GREY"), 47, 47, 47},   // ?
+   {T("AQUAMARINE"),112, 219, 147},
+   {T("BLACK"),0, 0, 0},
+   {T("BLUE"), 0, 0, 255},
+   {T("BLUE VIOLET("), 159, 95, 159},
+   {T("BROWN"), 165, 42, 42},
+   {T("CADET BLUE"), 95, 159, 159},
+   {T("CORAL"), 255, 127, 0},
+   {T("CORNFLOWER BLUE"), 66, 66, 111},
+   {T("CYAN"), 0, 255, 255},
+   {T("DARK GREY"), 47, 47, 47},   // ?

-   {_T("DARK GREEN"), 47, 79, 47},
-   {_T("DARK OLIVE GREEN"), 79, 79, 47},
-   {_T("DARK ORCHID"), 153, 50, 204},
-   {_T("DARK SLATE BLUE"), 107, 35, 142},
-   {_T("DARK SLATE GREY"), 47, 79, 79},
-   {_T("DARK TURQUOISE"), 112, 147, 219},
-   {_T("DIM GREY"), 84, 84, 84},
-   {_T("FIREBRICK"), 142, 35, 35},
-   {_T("FOREST GREEN"), 35, 142, 35},
-   {_T("GOLD"), 204, 127, 50},
-   {_T("GOLDENROD"), 219, 219, 112},
-   {_T("GREY"), 128, 128, 128},
-   {_T("GREEN"), 0, 255, 0},
-   {_T("GREEN YELLOW"), 147, 219, 112},
-   {_T("INDIAN RED"), 79, 47, 47},
-   {_T("KHAKI"), 159, 159, 95},
-   {_T("LIGHT BLUE"), 191, 216, 216},
-   {_T("LIGHT GREY"), 192, 192, 192},
-   {_T("LIGHT STEEL BLUE"), 143, 143, 188},
-   {_T("LIME GREEN"), 50, 204, 50},
-   {_T("LIGHT MAGENTA"), 255, 0, 255},
-   {_T("MAGENTA"), 255, 0, 255},
-   {_T("MAROON"), 142, 35, 107},
-   {_T("MEDIUM AQUAMARINE"), 50, 204, 153},
-   {_T("MEDIUM GREY"), 100, 100, 100},
-   {_T("MEDIUM BLUE"), 50, 50, 204},
-   {_T("MEDIUM FOREST GREEN"), 107, 142, 35},
-   {_T("MEDIUM GOLDENROD"), 234, 234, 173},
-   {_T("MEDIUM ORCHID"), 147, 112, 219},
-   {_T("MEDIUM SEA GREEN"), 66, 111, 66},
-   {_T("MEDIUM SLATE BLUE"), 127, 0, 255},
-   {_T("MEDIUM SPRING GREEN"), 127, 255, 0},
-   {_T("MEDIUM TURQUOISE"), 112, 219, 219},
-   {_T("MEDIUM VIOLET RED"), 219, 112, 147},
-   {_T("MIDNIGHT BLUE"), 47, 47, 79},
-   {_T("NAVY"), 35, 35, 142},
-   {_T("ORANGE"), 204, 50, 50},
-   {_T("ORANGE RED"), 255, 0, 127},
-   {_T("ORCHID"), 219, 112, 219},
-   {_T("PALE GREEN"), 143, 188, 143},
-   {_T("PINK"), 188, 143, 234},
-   {_T("PLUM"), 234, 173, 234},
-   {_T("PURPLE"), 176, 0, 255},
-   {_T("RED"), 255, 0, 0},
-   {_T("SALMON"), 111, 66, 66},
-   {_T("SEA GREEN"), 35, 142, 107},
-   {_T("SIENNA"), 142, 107, 35},
-   {_T("SKY BLUE"), 50, 153, 204},
-   {_T("SLATE BLUE"), 0, 127, 255},
-   {_T("SPRING GREEN"), 0, 255, 127},
-   {_T("STEEL BLUE"), 35, 107, 142},
-   {_T("TAN"), 219, 147, 112},
-   {_T("THISTLE"), 216, 191, 216},
-   {_T("TURQUOISE"), 173, 234, 234},
-   {_T("VIOLET"), 79, 47, 79},
-   {_T("VIOLET RED"), 204, 50, 153},
-   {_T("WHEAT"), 216, 216, 191},
-   {_T("WHITE"), 255, 255, 255},
-   {_T("YELLOW"), 255, 255, 0},
-   {_T("YELLOW GREEN"), 153, 204, 50},
+   {T("DARK GREEN"), 47, 79, 47},
+   {T("DARK OLIVE GREEN"), 79, 79, 47},
+   {T("DARK ORCHID"), 153, 50, 204},
+   {T("DARK SLATE BLUE"), 107, 35, 142},
+   {T("DARK SLATE GREY"), 47, 79, 79},
+   {T("DARK TURQUOISE"), 112, 147, 219},
+   {T("DIM GREY"), 84, 84, 84},
+   {T("FIREBRICK"), 142, 35, 35},
+   {T("FOREST GREEN"), 35, 142, 35},
+   {T("GOLD"), 204, 127, 50},
+   {T("GOLDENROD"), 219, 219, 112},
+   {T("GREY"), 128, 128, 128},
+   {T("GREEN"), 0, 255, 0},
+   {T("GREEN YELLOW"), 147, 219, 112},
+   {T("INDIAN RED"), 79, 47, 47},
+   {T("KHAKI"), 159, 159, 95},
+   {T("LIGHT BLUE"), 191, 216, 216},
+   {T("LIGHT GREY"), 192, 192, 192},
+   {T("LIGHT STEEL BLUE"), 143, 143, 188},
+   {T("LIME GREEN"), 50, 204, 50},
+   {T("LIGHT MAGENTA"), 255, 0, 255},
+   {T("MAGENTA"), 255, 0, 255},
+   {T("MAROON"), 142, 35, 107},
+   {T("MEDIUM AQUAMARINE"), 50, 204, 153},
+   {T("MEDIUM GREY"), 100, 100, 100},
+   {T("MEDIUM BLUE"), 50, 50, 204},
+   {T("MEDIUM FOREST GREEN"), 107, 142, 35},
+   {T("MEDIUM GOLDENROD"), 234, 234, 173},
+   {T("MEDIUM ORCHID"), 147, 112, 219},
+   {T("MEDIUM SEA GREEN"), 66, 111, 66},
+   {T("MEDIUM SLATE BLUE"), 127, 0, 255},
+   {T("MEDIUM SPRING GREEN"), 127, 255, 0},
+   {T("MEDIUM TURQUOISE"), 112, 219, 219},
+   {T("MEDIUM VIOLET RED"), 219, 112, 147},
+   {T("MIDNIGHT BLUE"), 47, 47, 79},
+   {T("NAVY"), 35, 35, 142},
+   {T("ORANGE"), 204, 50, 50},
+   {T("ORANGE RED"), 255, 0, 127},
+   {T("ORCHID"), 219, 112, 219},
+   {T("PALE GREEN"), 143, 188, 143},
+   {T("PINK"), 188, 143, 234},
+   {T("PLUM"), 234, 173, 234},
+   {T("PURPLE"), 176, 0, 255},
+   {T("RED"), 255, 0, 0},
+   {T("SALMON"), 111, 66, 66},
+   {T("SEA GREEN"), 35, 142, 107},
+   {T("SIENNA"), 142, 107, 35},
+   {T("SKY BLUE"), 50, 153, 204},
+   {T("SLATE BLUE"), 0, 127, 255},
+   {T("SPRING GREEN"), 0, 255, 127},
+   {T("STEEL BLUE"), 35, 107, 142},
+   {T("TAN"), 219, 147, 112},
+   {T("THISTLE"), 216, 191, 216},
+   {T("TURQUOISE"), 173, 234, 234},
+   {T("VIOLET("), 79, 47, 79},
+   {T("VIOLET RED"), 204, 50, 153},
+   {T("WHEAT("), 216, 216, 191},
+   {T("WHITE"), 255, 255, 255},
+   {T("YELLOW"), 255, 255, 0},
+   {T("YELLOW GREEN"), 153, 204, 50},
 // #endif

 #if defined(__WXGTK__) || defined(__X__)
-   {_T("MEDIUM GOLDENROD"), 234, 234, 173},
-   {_T("MEDIUM FOREST GREEN"), 107, 142, 35},
-   {_T("LIGHT MAGENTA"), 255, 0, 255},
-   {_T("MEDIUM GREY"), 100, 100, 100},
+   {T("MEDIUM GOLDENROD"), 234, 234, 173},
+   {T("MEDIUM FOREST GREEN"), 107, 142, 35},
+   {T("LIGHT MAGENTA"), 255, 0, 255},
+   {T("MEDIUM GREY"), 100, 100, 100},
 #endif

   {0,0,0,0}
@@ -604,7 +604,7 @@ wxFont *wxFontList::
 #else
          each_font->GetFamily() == FamilyOrFontId &&
 #endif
-          ((each_font->GetFaceName() == _T("")) || each_font->GetFaceName() == Face))
+          ((each_font->GetFaceName() == T("")) || each_font->GetFaceName() == Face))
        //#endif
        return each_font;
    }
--- a/src/common/http.cpp
+++ b/src/common/http.cpp
@@ -34,7 +34,7 @@

 #if !USE_SHARED_LIBRARY
 IMPLEMENT_DYNAMIC_CLASS(wxHTTP, wxProtocol)
-IMPLEMENT_PROTOCOL(wxHTTP, _T("http"), _T("80"), TRUE)
+IMPLEMENT_PROTOCOL(wxHTTP, T("http"), T("80"), TRUE)
 #endif

 #define HTTP_BSIZE 2048
@@ -65,7 +65,7 @@ wxHTTP::~wxHTTP()

 wxString wxHTTP::GetContentType()
 {
-  return GetHeader(_T("Content-Type"));
+  return GetHeader(T("Content-Type"));
 }

 void wxHTTP::SetProxyMode(bool on)
@@ -113,7 +113,7 @@ void wxHTTP::SendHeaders()
    wxString *str = (wxString *)head->Data();

    wxString buf;
-    buf.Printf(_T("%s: %s\n\r"), head->GetKeyString(), str->GetData());
+    buf.Printf(T("%s: %s\n\r"), head->GetKeyString(), str->GetData());

    const wxWX2MBbuf cbuf = buf.mb_str();
    Write(cbuf, strlen(cbuf));
@@ -171,7 +171,7 @@ bool wxHTTP::Connect(const wxString& host)
    return FALSE;
  }

-  if (!addr->Service(_T("http")))
+  if (!addr->Service(T("http")))
    addr->Service(80);

  return TRUE;
@@ -196,12 +196,12 @@ bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req)
  wxString tmp_str = path;

  // If there is no User-Agent defined, define it.
-  if (GetHeader(_T("User-Agent")).IsNull())
-    SetHeader(_T("User-Agent"), _T("wxWindows 2.x")); 
+  if (GetHeader(T("User-Agent")).IsNull())
+    SetHeader(T("User-Agent"), T("wxWindows 2.x")); 

  switch (req) {
  case wxHTTP_GET:
-    tmp_buf = _T("GET");
+    tmp_buf = T("GET(");
    break;
  default:
    return FALSE;
@@ -211,9 +211,9 @@ bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req)
  SetFlags(NONE);
  Notify(FALSE);

-  wxSprintf(buf, _T("%s %s HTTP/1.0\n\r"), tmp_buf, tmp_str.GetData());
+  wxSprintf(buf, T("%s %s HTTP/1.0\n\r"), tmp_buf, tmp_str.GetData());
  const wxWX2MBbuf pathbuf = wxConvLibc.cWX2MB(buf);
-  Write(pathbuf, strlen(MBSTRINGCAST pathbuf));
+  Write(pathbuf, strlen(wxMBSTRINGCAST pathbuf));
  SendHeaders();
  Write("\n\r", 2);

@@ -223,16 +223,16 @@ bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req)
    return FALSE;
  }

-  if (!tmp_str.Contains(_T("HTTP/"))) {
+  if (!tmp_str.Contains(T("HTTP/"))) {
    // TODO: support HTTP v0.9 which can have no header.
    // FIXME: tmp_str is not put back in the in-queue of the socket.
-    SetHeader(_T("Content-Length"), _T("-1"));
-    SetHeader(_T("Content-Type"), _T("none/none"));
+    SetHeader(T("Content-Length"), T("-1"));
+    SetHeader(T("Content-Type"), T("none/none"));
    RestoreState();
    return TRUE;
  }

-  wxStringTokenizer token(tmp_str,_T(' '));
+  wxStringTokenizer token(tmp_str,T(' '));
  wxString tmp_str2;
  bool ret_value;

@@ -240,13 +240,13 @@ bool wxHTTP::BuildRequest(const wxString& path, wxHTTP_Req req)
  tmp_str2 = token.NextToken();

  switch (tmp_str2[(unsigned int) 0]) {
-  case _T('1'):
+  case T('1'):
    /* INFORMATION / SUCCESS */
    break;
-  case _T('2'):
+  case T('2'):
    /* SUCCESS */
    break;
-  case _T('3'):
+  case T('3'):
    /* REDIRECTION */
    break;
  default:
@@ -312,8 +312,8 @@ wxInputStream *wxHTTP::GetInputStream(const wxString& path)
  if (!BuildRequest(path, wxHTTP_GET))
    return NULL;

-  if (!GetHeader(_T("Content-Length")).IsEmpty())
-    inp_stream->m_httpsize = wxAtoi(WXSTRINGCAST GetHeader(_T("Content-Length")));
+  if (!GetHeader(T("Content-Length")).IsEmpty())
+    inp_stream->m_httpsize = wxAtoi(WXSTRINGCAST GetHeader(T("Content-Length")));
  else
    inp_stream->m_httpsize = (size_t)-1;

--- a/src/common/imagbmp.cpp
+++ b/src/common/imagbmp.cpp
@@ -97,12 +97,12 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
    int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] );
    if (width > 32767)
    {
-        wxLogError( _T("Image width > 32767 pixels for file.") );
+        wxLogError( T("Image width > 32767 pixels for file.") );
        return FALSE;
    }
    if (height > 32767)
    {
-        wxLogError( _T("Image height > 32767 pixels for file.") );
+        wxLogError( T("Image height > 32767 pixels for file.") );
        return FALSE;
    }

@@ -115,7 +115,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
    int bpp = (int)wxUINT16_SWAP_ON_BE( aWord );
    if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
    {
-        wxLogError( _T("unknown bitdepth in file.") );
+        wxLogError( T("unknown bitdepth in file.") );
        return FALSE;
    }

@@ -123,7 +123,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
    int comp = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
    if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
    {
-        wxLogError( _T("unknown encoding in Windows BMP file.") );
+        wxLogError( T("unknown encoding in Windows BMP file.") );
        return FALSE;
    }

@@ -136,7 +136,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
        ((comp == BI_RLE8) && (bpp != 8)) ||
        ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
    {
-        wxLogError( _T("encoding of BMP doesn't match bitdepth.") );
+        wxLogError( T("encoding of BMP doesn't match bitdepth.") );
        return FALSE;
    }
    if (bpp < 16)
@@ -144,7 +144,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
        cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
        if (!cmap)
        {
-            wxLogError( _T("Cannot allocate RAM for color map in BMP file.") );
+            wxLogError( T("Cannot allocate RAM for color map in BMP file.") );
            return FALSE;
        }
    }
@@ -155,7 +155,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
    unsigned char *ptr = image->GetData();
    if (!ptr)
    {
-        wxLogError( _T("Cannot allocate RAM for RGB data in file.") );
+        wxLogError( T("Cannot allocate RAM for RGB data in file.") );
        if (cmap)
            free(cmap);
        return FALSE;
@@ -263,7 +263,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
                {
                    if (comp == BI_RLE4)
                    {
-                        wxLogError( _T("Can't deal with 4bit encoded yet.") );
+                        wxLogError( T("Can't deal with 4bit encoded yet.") );
                        image->Destroy();
                        free(cmap);
                        return FALSE;
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -154,15 +154,15 @@ wxImage wxImage::Scale( int width, int height ) const
 {
    wxImage image;

-    wxCHECK_MSG( Ok(), image, _T("invalid image") );
+    wxCHECK_MSG( Ok(), image, T("invalid image") );

-    wxCHECK_MSG( (width > 0) && (height > 0), image, _T("invalid image size") );
+    wxCHECK_MSG( (width > 0) && (height > 0), image, T("invalid image size") );

    image.Create( width, height );

    char unsigned *data = image.GetData();

-    wxCHECK_MSG( data, image, _T("unable to create image") );
+    wxCHECK_MSG( data, image, T("unable to create image") );

    if (M_IMGDATA->m_hasMask)
        image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
@@ -193,10 +193,10 @@ wxImage wxImage::GetSubImage( const wxRect &rect ) const
 {
    wxImage image;

-    wxCHECK_MSG( Ok(), image, _T("invalid image") );
+    wxCHECK_MSG( Ok(), image, T("invalid image") );

    wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight())
-		 , image, _T("invalid subimage size") );
+		 , image, T("invalid subimage size") );

    int subwidth=rect.GetWidth();
    const int subheight=rect.GetHeight();
@@ -205,7 +205,7 @@ wxImage wxImage::GetSubImage( const wxRect &rect ) const

    char unsigned *subdata = image.GetData(), *data=GetData();

-    wxCHECK_MSG( subdata, image, _T("unable to create image") );
+    wxCHECK_MSG( subdata, image, T("unable to create image") );

    if (M_IMGDATA->m_hasMask)
        image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
@@ -228,12 +228,12 @@ wxImage wxImage::GetSubImage( const wxRect &rect ) const

 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
 {
-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), T("invalid image") );

    int w = M_IMGDATA->m_width;
    int h = M_IMGDATA->m_height;

-    wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), _T("invalid image index") );
+    wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), T("invalid image index") );

    long pos = (y * w + x) * 3;

@@ -244,12 +244,12 @@ void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned c

 unsigned char wxImage::GetRed( int x, int y )
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    int w = M_IMGDATA->m_width;
    int h = M_IMGDATA->m_height;

-    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
+    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, T("invalid image index") );

    long pos = (y * w + x) * 3;

@@ -258,12 +258,12 @@ unsigned char wxImage::GetRed( int x, int y )

 unsigned char wxImage::GetGreen( int x, int y )
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    int w = M_IMGDATA->m_width;
    int h = M_IMGDATA->m_height;

-    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
+    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, T("invalid image index") );

    long pos = (y * w + x) * 3;

@@ -272,12 +272,12 @@ unsigned char wxImage::GetGreen( int x, int y )

 unsigned char wxImage::GetBlue( int x, int y )
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    int w = M_IMGDATA->m_width;
    int h = M_IMGDATA->m_height;

-    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, _T("invalid image index") );
+    wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, T("invalid image index") );

    long pos = (y * w + x) * 3;

@@ -291,14 +291,14 @@ bool wxImage::Ok() const

 char unsigned *wxImage::GetData() const
 {
-    wxCHECK_MSG( Ok(), (char unsigned *)NULL, _T("invalid image") );
+    wxCHECK_MSG( Ok(), (char unsigned *)NULL, T("invalid image") );

    return M_IMGDATA->m_data;
 }

 void wxImage::SetData( char unsigned *data )
 {
-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), T("invalid image") );

    wxImageRefData *newRefData = new wxImageRefData();

@@ -318,7 +318,7 @@ void wxImage::SetData( char unsigned *data )

 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
 {
-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), T("invalid image") );

    M_IMGDATA->m_maskRed = r;
    M_IMGDATA->m_maskGreen = g;
@@ -328,49 +328,49 @@ void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )

 unsigned char wxImage::GetMaskRed() const
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    return M_IMGDATA->m_maskRed;
 }

 unsigned char wxImage::GetMaskGreen() const
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    return M_IMGDATA->m_maskGreen;
 }

 unsigned char wxImage::GetMaskBlue() const
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    return M_IMGDATA->m_maskBlue;
 }

 void wxImage::SetMask( bool mask )
 {
-    wxCHECK_RET( Ok(), _T("invalid image") );
+    wxCHECK_RET( Ok(), T("invalid image") );

    M_IMGDATA->m_hasMask = mask;
 }

 bool wxImage::HasMask() const
 {
-    wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
+    wxCHECK_MSG( Ok(), FALSE, T("invalid image") );

    return M_IMGDATA->m_hasMask;
 }

 int wxImage::GetWidth() const
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    return M_IMGDATA->m_width;
 }

 int wxImage::GetHeight() const
 {
-    wxCHECK_MSG( Ok(), 0, _T("invalid image") );
+    wxCHECK_MSG( Ok(), 0, T("invalid image") );

    return M_IMGDATA->m_height;
 }
@@ -385,7 +385,7 @@ bool wxImage::LoadFile( const wxString& filename, long type )
    }

    else {
-        wxLogError( _T("Can't load image from file '%s': file does not exist."), filename.c_str() );
+        wxLogError( T("Can't load image from file '%s': file does not exist."), filename.c_str() );

        return FALSE;
    }
@@ -404,7 +404,7 @@ bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
    }

    else {
-        wxLogError( _T("Can't load image from file '%s': file does not exist."), filename.c_str() );
+        wxLogError( T("Can't load image from file '%s': file does not exist."), filename.c_str() );

        return FALSE;
    }
@@ -459,7 +459,7 @@ bool wxImage::LoadFile( wxInputStream& stream, long type )

 	}

-	wxLogWarning( _T("No handler found for this image.") );
+	wxLogWarning( T("No handler found for this image.") );
 	return FALSE;
    }

@@ -467,7 +467,7 @@ bool wxImage::LoadFile( wxInputStream& stream, long type )

    if (handler == NULL)
    {
-        wxLogWarning( _T("No image handler for type %d defined."), type );
+        wxLogWarning( T("No image handler for type %d defined."), type );

        return FALSE;
    }
@@ -485,7 +485,7 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )

    if (handler == NULL)
    {
-        wxLogWarning( _T("No image handler for type %s defined."), mimetype.GetData() );
+        wxLogWarning( T("No image handler for type %s defined."), mimetype.GetData() );

        return FALSE;
    }
@@ -495,13 +495,13 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype )

 bool wxImage::SaveFile( wxOutputStream& stream, int type )
 {
-    wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
+    wxCHECK_MSG( Ok(), FALSE, T("invalid image") );

    wxImageHandler *handler = FindHandler(type);

    if (handler == NULL)
    {
-        wxLogWarning( _T("No image handler for type %d defined."), type );
+        wxLogWarning( T("No image handler for type %d defined."), type );

        return FALSE;
    }
@@ -511,13 +511,13 @@ bool wxImage::SaveFile( wxOutputStream& stream, int type )

 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype )
 {
-    wxCHECK_MSG( Ok(), FALSE, _T("invalid image") );
+    wxCHECK_MSG( Ok(), FALSE, T("invalid image") );

    wxImageHandler *handler = FindHandlerMime(mimetype);

    if (handler == NULL)
    {
-        wxLogWarning( _T("No image handler for type %s defined."), mimetype.GetData() );
+        wxLogWarning( T("No image handler for type %s defined."), mimetype.GetData() );

        return FALSE;
    }
@@ -657,7 +657,7 @@ bool wxImageHandler::CanRead( const wxString& name )
    }

    else {
-        wxLogError( _T("Can't check image format of file '%s': file does not exist."), name.c_str() );
+        wxLogError( T("Can't check image format of file '%s': file does not exist."), name.c_str() );

        return FALSE;
    }
@@ -717,7 +717,7 @@ wxBitmap wxImage::ConvertToBitmap() const

    // set bitmap parameters
    wxBitmap bitmap;
-    wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
+    wxCHECK_MSG( Ok(), bitmap, T("invalid image") );
    bitmap.SetWidth( width );
    bitmap.SetHeight( bmpHeight );
    bitmap.SetDepth( wxDisplayDepth() );
@@ -725,7 +725,7 @@ wxBitmap wxImage::ConvertToBitmap() const
    // create a DIB header
    int headersize = sizeof(BITMAPINFOHEADER);
    LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
-    wxCHECK_MSG( lpDIBh, bitmap, _T("could not allocate memory for DIB header") );
+    wxCHECK_MSG( lpDIBh, bitmap, T("could not allocate memory for DIB header") );
    // Fill in the DIB header
    lpDIBh->bmiHeader.biSize = headersize;
    lpDIBh->bmiHeader.biWidth = (DWORD)width;
@@ -746,7 +746,7 @@ wxBitmap wxImage::ConvertToBitmap() const
    lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
    if( !lpBits )
    {
-        wxFAIL_MSG( _T("could not allocate memory for DIB") );
+        wxFAIL_MSG( T("could not allocate memory for DIB") );
        free( lpDIBh );
        return bitmap;
    }
@@ -889,7 +889,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
    // check the bitmap
    if( !bitmap.Ok() )
    {
-        wxFAIL_MSG( _T("invalid bitmap") );
+        wxFAIL_MSG( T("invalid bitmap") );
        return;
    }

@@ -900,7 +900,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
    unsigned char *data = GetData();
    if( !data )
    {
-        wxFAIL_MSG( _T("could not allocate data for image") );
+        wxFAIL_MSG( T("could not allocate data for image") );
        return;
    }

@@ -920,7 +920,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
    LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
    if( !lpDIBh )
    {
-        wxFAIL_MSG( _T("could not allocate data for DIB header") );
+        wxFAIL_MSG( T("could not allocate data for DIB header") );
        free( data );
        return;
    }
@@ -942,7 +942,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
    lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
    if( !lpBits )
    {
-        wxFAIL_MSG( _T("could not allocate data for DIB") );
+        wxFAIL_MSG( T("could not allocate data for DIB") );
        free( data );
        free( lpDIBh );
        return;
@@ -1033,7 +1033,7 @@ wxBitmap wxImage::ConvertToBitmap() const
 {
    wxBitmap bitmap;

-    wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
+    wxCHECK_MSG( Ok(), bitmap, T("invalid image") );

    int width = GetWidth();
    int height = GetHeight();
@@ -1241,13 +1241,13 @@ wxBitmap wxImage::ConvertToBitmap() const

 wxImage::wxImage( const wxBitmap &bitmap )
 {
-    wxCHECK_RET( bitmap.Ok(), _T("invalid bitmap") );
+    wxCHECK_RET( bitmap.Ok(), T("invalid bitmap") );

    GdkImage *gdk_image = gdk_image_get( bitmap.GetPixmap(),
        0, 0,
        bitmap.GetWidth(), bitmap.GetHeight() );

-    wxCHECK_RET( gdk_image, _T("couldn't create image") );
+    wxCHECK_RET( gdk_image, T("couldn't create image") );

    Create( bitmap.GetWidth(), bitmap.GetHeight() );
    char unsigned *data = GetData();
@@ -1255,7 +1255,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
    if (!data)
    {
        gdk_image_destroy( gdk_image );
-        wxFAIL_MSG( _T("couldn't create image") );
+        wxFAIL_MSG( T("couldn't create image") );
        return;
    }

@@ -1340,7 +1340,7 @@ wxBitmap wxImage::ConvertToBitmap() const
 {
    wxBitmap bitmap;

-    wxCHECK_MSG( Ok(), bitmap, _T("invalid image") );
+    wxCHECK_MSG( Ok(), bitmap, T("invalid image") );

    int width = GetWidth();
    int height = GetHeight();
@@ -1389,7 +1389,7 @@ wxBitmap wxImage::ConvertToBitmap() const

    vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );

-    wxCHECK_MSG( vi, wxNullBitmap, _T("no visual") );
+    wxCHECK_MSG( vi, wxNullBitmap, T("no visual") );

    XFree( vi );

@@ -1540,7 +1540,7 @@ wxBitmap wxImage::ConvertToBitmap() const

 wxImage::wxImage( const wxBitmap &bitmap )
 {
-    wxCHECK_RET( bitmap.Ok(), _T("invalid bitmap") );
+    wxCHECK_RET( bitmap.Ok(), T("invalid bitmap") );

    Display *dpy = (Display*) wxGetDisplay();
    Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
@@ -1552,7 +1552,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
        bitmap.GetWidth(), bitmap.GetHeight(),
        AllPlanes, ZPixmap );

-    wxCHECK_RET( ximage, _T("couldn't create image") );
+    wxCHECK_RET( ximage, T("couldn't create image") );

    Create( bitmap.GetWidth(), bitmap.GetHeight() );
    char unsigned *data = GetData();
@@ -1560,7 +1560,7 @@ wxImage::wxImage( const wxBitmap &bitmap )
    if (!data)
    {
        XDestroyImage( ximage );
-        wxFAIL_MSG( _T("couldn't create image") );
+        wxFAIL_MSG( T("couldn't create image") );
        return;
    }

@@ -1588,7 +1588,7 @@ wxImage::wxImage( const wxBitmap &bitmap )

    vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );

-    wxCHECK_RET( vi, _T("no visual") );
+    wxCHECK_RET( vi, T("no visual") );

    if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;

--- a/src/common/imaggif.cpp
+++ b/src/common/imaggif.cpp
@@ -54,9 +54,9 @@ bool wxGIFHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
        {
            switch (error)
            {
-                case E_FORMATO: wxLogError(_T("wxGIFHandler: error in image format")); break;
-                case E_MEMORIA: wxLogError(_T("wxGIFHandler: couldn't allocate memory")); break;
-                default:        wxLogError(_T("wxGIFHandler: unknown error !!!"));
+                case E_FORMATO: wxLogError(T("wxGIFHandler: error in image format")); break;
+                case E_MEMORIA: wxLogError(T("wxGIFHandler: couldn't allocate memory")); break;
+                default:        wxLogError(T("wxGIFHandler: unknown error !!!"));
            }
        }
        delete decod;
@@ -74,7 +74,7 @@ bool wxGIFHandler::SaveFile( wxImage * WXUNUSED(image),
                             wxOutputStream& WXUNUSED(stream), bool verbose )
 {
    if (verbose)
-        wxLogDebug(_T("wxGIFHandler is read-only!!"));
+        wxLogDebug(T("wxGIFHandler is read-only!!"));

    return FALSE;
 }
--- a/src/common/imagpcx.cpp
+++ b/src/common/imagpcx.cpp
@@ -229,7 +229,7 @@ bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
    if (!CanRead(stream))
    {
        if (verbose)
-            wxLogError(_T("wxPCXHandler: this is not a PCX file"));
+            wxLogError(T("wxPCXHandler: this is not a PCX file"));

        return FALSE;
    }
@@ -242,10 +242,10 @@ bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
        {
            switch (error)
            {
-                case E_FORMATO: wxLogError(_T("wxPCXHandler: image format unsupported")); break;
-                case E_MEMORIA: wxLogError(_T("wxPCXHandler: couldn't allocate memory")); break;
-                case E_VERSION: wxLogError(_T("wxPCXHandler: version number too low")); break;
-                default:        wxLogError(_T("wxPCXHandler: unknown error !!!"));
+                case E_FORMATO: wxLogError(T("wxPCXHandler: image format unsupported")); break;
+                case E_MEMORIA: wxLogError(T("wxPCXHandler: couldn't allocate memory")); break;
+                case E_VERSION: wxLogError(T("wxPCXHandler: version number too low")); break;
+                default:        wxLogError(T("wxPCXHandler: unknown error !!!"));
            }
        }
        image->Destroy();
@@ -258,7 +258,7 @@ bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose
 bool wxPCXHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool verbose )
 {
    if (verbose)
-        wxLogError(_T("wxPCXHandler::SaveFile still not implemented"));
+        wxLogError(T("wxPCXHandler::SaveFile still not implemented"));

    return FALSE;
 }
--- a/src/common/imagpnm.cpp
+++ b/src/common/imagpnm.cpp
@@ -44,7 +44,7 @@ void Skip_Comment(wxInputStream &stream)
  wxString line;
  wxTextInputStream text_stream(stream);

-  if (stream.Peek()==_T('#')) 
+  if (stream.Peek()==T('#')) 
    {
      text_stream >> line;
      Skip_Comment(stream);
@@ -68,19 +68,19 @@ bool wxPNMHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
    wxTextInputStream text_stream(buf_stream);

    Skip_Comment(buf_stream);
-    if (buf_stream.GetC()==_T('P')) c=buf_stream.GetC();
+    if (buf_stream.GetC()==T('P')) c=buf_stream.GetC();

    switch (c)
      {
-      case _T('2'):
-	wxLogError(_T("Loading Grey Ascii PNM image is not yet implemented."));
+      case T('2'):
+	wxLogError(T("Loading Grey Ascii PNM image is not yet implemented."));
 	return FALSE;
-      case _T('5'):
-	wxLogError(_T("Loading Grey Raw PNM image is not yet implemented."));
+      case T('5'):
+	wxLogError(T("Loading Grey Raw PNM image is not yet implemented."));
 	return FALSE;
-      case _T('3'): case _T('6'): break;
+      case T('3'): case T('6'): break;
 	default :
-	wxLogError(_T("Loading PNM image : file not recognized."));
+	wxLogError(T("Loading PNM image : file not recognized."));
 	return FALSE;
      }

@@ -95,7 +95,7 @@ bool wxPNMHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE
    unsigned char *ptr = image->GetData();
    if (!ptr)
    {
-        wxLogError( _T("Cannot allocate RAM for RGB data in PNM file.") );
+        wxLogError( T("Cannot allocate RAM for RGB data in PNM file.") );
 	return FALSE;
    }

@@ -111,7 +111,7 @@ bool wxPNMHandler::LoadFile( wxImage *image, wxInputStream& stream, bool WXUNUSE

 	    if (buf_stream.LastError()!=wxSTREAM_NOERROR)
 	      {
-		wxLogError(_T("Loading PNM image : file seems truncated."));
+		wxLogError(T("Loading PNM image : file seems truncated."));
 		return FALSE;
 	      }
 	  }
@@ -143,10 +143,10 @@ bool wxPNMHandler::CanRead( wxInputStream& stream )

    Skip_Comment(stream);

-    if (stream.GetC()==_T('P'))
+    if (stream.GetC()==T('P'))
      switch (stream.GetC())
 	{
-	case _T('3'): case _T('6'):
+	case T('3'): case T('6'):
 	  stream.SeekI(pos);
 	  return TRUE;
 	}
--- a/src/common/init.cpp
+++ b/src/common/init.cpp
@@ -0,0 +1,80 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        common/init.cpp
+// Purpose:     initialisation for the library
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     04.10.99
+// RCS-ID:      $Id$
+// Copyright:   (c) Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "appbase.h"
+#endif
+
+#include "wx/app.h"
+#include "wx/debug.h"
+
+// ----------------------------------------------------------------------------
+// global vars
+// ----------------------------------------------------------------------------
+
+wxApp * WXDLLEXPORT wxTheApp = NULL;
+
+wxAppInitializerFunction
+    wxAppBase::m_appInitFn = (wxAppInitializerFunction)NULL;
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class /* no WXDLLEXPORT */ wxConsoleApp : public wxApp
+{
+public:
+    virtual int OnRun() { wxFAIL_MSG(T("unreachable")); return 0; }
+};
+
+// ----------------------------------------------------------------------------
+// private vars
+// ----------------------------------------------------------------------------
+
+static size_t gs_nInitCount = 0;
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+bool WXDLLEXPORT wxInitialize()
+{
+    if ( gs_nInitCount++ )
+    {
+        // already initialized
+        return TRUE;
+    }
+
+    wxASSERT_MSG( !wxTheApp,
+                  T("either call wxInitialize or create app, not both!") );
+
+    wxTheApp = new wxConsoleApp;
+
+    return wxTheApp != NULL;
+}
+
+void WXDLLEXPORT wxUninitialize()
+{
+    if ( !--gs_nInitCount )
+    {
+        // delete the application object
+        delete wxTheApp;
+        wxTheApp = (wxApp *)NULL;
+    }
+}
--- a/src/common/intl.cpp
+++ b/src/common/intl.cpp
@@ -267,7 +267,7 @@ static wxString GetAllMsgCatalogSubdirs(const wxChar *prefix,
    // search first in prefix/fr/LC_MESSAGES, then in prefix/fr and finally in
    // prefix (assuming the language is 'fr')
    searchPath << prefix << wxFILE_SEP_PATH << lang << wxFILE_SEP_PATH
-                         << _T("LC_MESSAGES") << wxPATH_SEP
+                         << T("LC_MESSAGES") << wxPATH_SEP
               << prefix << wxFILE_SEP_PATH << lang << wxPATH_SEP
               << prefix << wxPATH_SEP;

@@ -289,13 +289,13 @@ static wxString GetFullSearchPath(const wxChar *lang)

    // then take the current directory
    // FIXME it should be the directory of the executable
-    searchPath << GetAllMsgCatalogSubdirs(_T("."), lang) << wxPATH_SEP;
+    searchPath << GetAllMsgCatalogSubdirs(T("."), lang) << wxPATH_SEP;

    // and finally add some standard ones
    searchPath
-        << GetAllMsgCatalogSubdirs(_T("/usr/share/locale"), lang) << wxPATH_SEP
-        << GetAllMsgCatalogSubdirs(_T("/usr/lib/locale"), lang) << wxPATH_SEP
-        << GetAllMsgCatalogSubdirs(_T("/usr/local/share/locale"), lang);
+        << GetAllMsgCatalogSubdirs(T("/usr/share/locale"), lang) << wxPATH_SEP
+        << GetAllMsgCatalogSubdirs(T("/usr/lib/locale"), lang) << wxPATH_SEP
+        << GetAllMsgCatalogSubdirs(T("/usr/local/share/locale"), lang);

    return searchPath;
 }
@@ -320,7 +320,7 @@ bool wxMsgCatalog::Load(const wxChar *szDirPrefix, const wxChar *szName0)
 #endif // 0

  wxString searchPath = GetFullSearchPath(szDirPrefix);
-  const wxChar *sublocale = wxStrchr(szDirPrefix, _T('_'));
+  const wxChar *sublocale = wxStrchr(szDirPrefix, T('_'));
  if ( sublocale )
  {
      // also add just base locale name: for things like "fr_BE" (belgium
@@ -340,9 +340,7 @@ bool wxMsgCatalog::Load(const wxChar *szDirPrefix, const wxChar *szName0)
  // (we're using an object because we have several return paths)

  NoTransErr noTransErr;
-//  Then why do you translate at all? Just use _T() and not _(). RR.
-
-  wxLogVerbose(_("looking for catalog '%s' in path '%s'."),
+  wxLogVerbose(T("looking for catalog '%s' in path '%s'."),
               szName.c_str(), searchPath.c_str());

  wxString strFullName;
@@ -498,7 +496,7 @@ bool wxLocale::Init(const wxChar *szName,
  m_pMsgCat = NULL;
  bool bOk = TRUE;
  if ( bLoadDefault )
-    bOk = AddCatalog(_T("wxstd"));
+    bOk = AddCatalog(T("wxstd"));

  return bOk;
 }
@@ -530,13 +528,17 @@ wxLocale::~wxLocale()

 // get the translation of given string in current locale
 const wxMB2WXbuf wxLocale::GetString(const wxChar *szOrigString,
-				     const wxChar *szDomain) const
+                                     const wxChar *szDomain) const
 {
  if ( wxIsEmpty(szOrigString) )
      return szDomain;

  const char *pszTrans = NULL;
+#if wxUSE_UNICODE
  const wxWX2MBbuf szOrgString = wxConvCurrent->cWX2MB(szOrigString);
+#else // ANSI
+  #define szOrgString szOrigString
+#endif // Unicode/ANSI

  wxMsgCatalog *pMsgCat;
  if ( szDomain != NULL ) {
@@ -583,7 +585,16 @@ const wxMB2WXbuf wxLocale::GetString(const wxChar *szOrigString,
    return (wxMB2WXbuf)(szOrigString);
  }
  else
-    return (wxMB2WXbuf)(wxConvCurrent->cMB2WX(pszTrans));
+  {
+    // FIXME it was
+    // return (wxMB2WXbuf)(wxConvCurrent->cMB2WX(pszTrans));
+    //       before, but we don't want to use wxConvCurrent explicitly to
+    //       avoid linking unnecessary code in ANSI programs without MB
+    //       support
+    return (wxMB2WXbuf)(pszTrans);
+  }
+
+  #undef szOrgString
 }

 // find catalog by name in a linked list, return NULL if !found
--- a/src/common/list.cpp
+++ b/src/common/list.cpp
@@ -52,7 +52,7 @@ bool wxListKey::operator==(wxListKeyValue value) const
    switch ( m_keyType )
    {
        default:
-            wxFAIL_MSG(_T("bad key type."));
+            wxFAIL_MSG(T("bad key type."));
            // let compiler optimize the line above away in release build
            // by not putting return here...

@@ -92,7 +92,7 @@ wxNodeBase::wxNodeBase(wxListBase *list,
            break;

        default:
-            wxFAIL_MSG(_T("invalid key type"));
+            wxFAIL_MSG(T("invalid key type"));
    }

    if ( previous )
@@ -120,7 +120,7 @@ wxNodeBase::~wxNodeBase()

 int wxNodeBase::IndexOf() const
 {
-    wxCHECK_MSG( m_list, wxNOT_FOUND, _T("node doesn't belong to a list in IndexOf"));
+    wxCHECK_MSG( m_list, wxNOT_FOUND, T("node doesn't belong to a list in IndexOf"));

    // It would be more efficient to implement IndexOf() completely inside
    // wxListBase (only traverse the list once), but this is probably a more
@@ -163,7 +163,7 @@ wxListBase::wxListBase(size_t count, void *elements[])
 void wxListBase::DoCopy(const wxListBase& list)
 {
    wxASSERT_MSG( !list.m_destroy,
-                  _T("copying list which owns it's elements is a bad idea") );
+                  T("copying list which owns it's elements is a bad idea") );

    m_count = list.m_count;
    m_destroy = list.m_destroy;
@@ -210,7 +210,7 @@ wxNodeBase *wxListBase::Append(void *object)
 {
    // all objects in a keyed list should have a key
    wxCHECK_MSG( m_keyType == wxKEY_NONE, (wxNodeBase *)NULL,
-                 _T("need a key for the object to append") );
+                 T("need a key for the object to append") );

    wxNodeBase *node = CreateNode(m_nodeLast, (wxNodeBase *)NULL, object);

@@ -222,7 +222,7 @@ wxNodeBase *wxListBase::Append(long key, void *object)
    wxCHECK_MSG( (m_keyType == wxKEY_INTEGER) ||
                 (m_keyType == wxKEY_NONE && m_count == 0),
                 (wxNodeBase *)NULL,
-                 _T("can't append object with numeric key to this list") );
+                 T("can't append object with numeric key to this list") );

    wxNodeBase *node = CreateNode(m_nodeLast, (wxNodeBase *)NULL, object, key);
    return AppendCommon(node);
@@ -233,7 +233,7 @@ wxNodeBase *wxListBase::Append (const wxChar *key, void *object)
    wxCHECK_MSG( (m_keyType == wxKEY_STRING) ||
                 (m_keyType == wxKEY_NONE && m_count == 0),
                 (wxNodeBase *)NULL,
-                 _T("can't append object with string key to this list") );
+                 T("can't append object with string key to this list") );

    wxNodeBase *node = CreateNode(m_nodeLast, (wxNodeBase *)NULL, object, key);
    return AppendCommon(node);
@@ -243,10 +243,10 @@ wxNodeBase *wxListBase::Insert(wxNodeBase *position, void *object)
 {
    // all objects in a keyed list should have a key
    wxCHECK_MSG( m_keyType == wxKEY_NONE, (wxNodeBase *)NULL,
-                 _T("need a key for the object to insert") );
+                 T("need a key for the object to insert") );

    wxCHECK_MSG( !position || position->m_list == this, (wxNodeBase *)NULL,
-                 _T("can't insert before a node from another list") );
+                 T("can't insert before a node from another list") );

    // previous and next node for the node being inserted
    wxNodeBase *prev, *next;
@@ -288,7 +288,7 @@ wxNodeBase *wxListBase::Item(size_t n) const
        }
    }

-    wxFAIL_MSG( _T("invalid index in wxListBase::Item") );
+    wxFAIL_MSG( T("invalid index in wxListBase::Item") );

    return (wxNodeBase *)NULL;
 }
@@ -296,7 +296,7 @@ wxNodeBase *wxListBase::Item(size_t n) const
 wxNodeBase *wxListBase::Find(const wxListKey& key) const
 {
    wxASSERT_MSG( m_keyType == key.GetKeyType(),
-                  _T("this list is not keyed on the type of this key") );
+                  T("this list is not keyed on the type of this key") );

    for ( wxNodeBase *current = GetFirst(); current; current = current->GetNext() )
    {
@@ -349,9 +349,9 @@ void wxListBase::DoDeleteNode(wxNodeBase *node)

 wxNodeBase *wxListBase::DetachNode(wxNodeBase *node)
 {
-    wxCHECK_MSG( node, NULL, _T("detaching NULL wxNodeBase") );
+    wxCHECK_MSG( node, NULL, T("detaching NULL wxNodeBase") );
    wxCHECK_MSG( node->m_list == this, NULL,
-                 _T("detaching node which is not from this list") );
+                 T("detaching node which is not from this list") );

    // update the list
    wxNodeBase **prevNext = node->GetPrevious() ? &node->GetPrevious()->m_next
--- a/src/common/log.cpp
+++ b/src/common/log.cpp
@@ -30,17 +30,17 @@

 // wxWindows
 #ifndef WX_PRECOMP
-  #include "wx/window.h"
-  #ifdef __WXMSW__
-    #include "wx/msw/private.h"
-  #endif
-  #include  "wx/event.h"
-  #include  "wx/app.h"
-  #include  "wx/string.h"
-  #include  "wx/intl.h"
-  #ifndef wxUSE_NOGUI
-    #include "wx/msgdlg.h"
-  #endif  
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/app.h"
+
+    #if wxUSE_GUI
+        #include "wx/window.h"
+        #ifdef __WXMSW__
+            #include "wx/msw/private.h"
+        #endif
+        #include "wx/msgdlg.h"
+    #endif
 #endif //WX_PRECOMP

 #include  "wx/file.h"
@@ -249,15 +249,11 @@ wxLog *wxLog::GetActiveTarget()
        if ( !s_bInGetActiveTarget ) {
            s_bInGetActiveTarget = TRUE;

-#ifdef wxUSE_NOGUI
-            ms_pLogger = new wxLogStderr;
-#else // GUI
            // ask the application to create a log target for us
            if ( wxTheApp != NULL )
                ms_pLogger = wxTheApp->CreateLogTarget();
            else
                ms_pLogger = new wxLogStderr;
-#endif // !GUI/GUI

            s_bInGetActiveTarget = FALSE;

@@ -299,7 +295,7 @@ void wxLog::TimeStamp(wxString *str)
        wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));

        str->Empty();
-        *str << buf << _T(": ");
+        *str << buf << T(": ");
    }
 }

@@ -343,7 +339,7 @@ void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)

 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
 {
-    wxFAIL_MSG(_T("DoLogString must be overriden if it's called."));
+    wxFAIL_MSG(T("DoLogString must be overriden if it's called."));
 }

 void wxLog::Flush()
@@ -367,7 +363,7 @@ void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 {
    wxString str;
    TimeStamp(&str);
-    str << szString << _T('\n');
+    str << szString << T('\n');

    fputs(str.mb_str(), m_fp);
    fflush(m_fp);
@@ -375,7 +371,7 @@ void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
    // under Windows, programs usually don't have stderr at all, so make show the
    // messages also under debugger
 #ifdef __WXMSW__
-    OutputDebugString(str + _T('\r'));
+    OutputDebugString(str + T('\r'));
 #endif // MSW
 }

@@ -394,7 +390,7 @@ wxLogStream::wxLogStream(ostream *ostr)

 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 {
-    (*m_ostr) << wxConvCurrent->cWX2MB(szString) << endl << flush;
+    (*m_ostr) << wxConvertWX2MB(szString) << endl;
 }
 #endif // wxUSE_STD_IOSTREAM

@@ -410,7 +406,7 @@ wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 bool            wxLog::ms_doLog        = TRUE;
 bool            wxLog::ms_bAutoCreate  = TRUE;

-const wxChar   *wxLog::ms_timestamp    = _T("%X");  // time only, no date
+const wxChar   *wxLog::ms_timestamp    = T("%X");  // time only, no date

 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 wxArrayString   wxLog::ms_aTraceMasks;
@@ -491,7 +487,7 @@ const wxChar *wxSysErrorMsg(unsigned long nErrCode)

    // copy it to our buffer and free memory
    wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
-    s_szBuf[WXSIZEOF(s_szBuf) - 1] = _T('\0');
+    s_szBuf[WXSIZEOF(s_szBuf) - 1] = T('\0');
    LocalFree(lpMsgBuf);

    // returned string is capitalized and ended with '\r\n' - bad
@@ -499,8 +495,8 @@ const wxChar *wxSysErrorMsg(unsigned long nErrCode)
    size_t len = wxStrlen(s_szBuf);
    if ( len > 0 ) {
        // truncate string
-        if ( s_szBuf[len - 2] == _T('\r') )
-            s_szBuf[len - 2] = _T('\0');
+        if ( s_szBuf[len - 2] == T('\r') )
+            s_szBuf[len - 2] = T('\0');
    }

    return s_szBuf;
@@ -566,30 +562,28 @@ void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
    // make life easier for people using VC++ IDE: clicking on the message
    // will take us immediately to the place of the failed assert
 #ifdef __VISUALC__
-    wxSprintf(szBuf, _T("%s(%d): assert failed"), szFile, nLine);
+    wxSprintf(szBuf, T("%s(%d): assert failed"), szFile, nLine);
 #else  // !VC++
    // make the error message more clear for all the others
-    wxSprintf(szBuf, _T("Assert failed in file %s at line %d"), szFile, nLine);
+    wxSprintf(szBuf, T("Assert failed in file %s at line %d"), szFile, nLine);
 #endif // VC/!VC

    if ( szMsg != NULL ) {
-        wxStrcat(szBuf, _T(": "));
+        wxStrcat(szBuf, T(": "));
        wxStrcat(szBuf, szMsg);
    }
    else {
-        wxStrcat(szBuf, _T("."));
+        wxStrcat(szBuf, T("."));
    }

    if ( !s_bNoAsserts ) {
        // send it to the normal log destination
        wxLogDebug(szBuf);

-#if wxUSE_NOGUI
-        Trap();
-#else // GUI
+#if wxUSE_GUI
        // this message is intentionally not translated - it is for
        // developpers only
-        wxStrcat(szBuf, _T("\nDo you want to stop the program?"
+        wxStrcat(szBuf, T("\nDo you want to stop the program?"
                "\nYou can also choose [Cancel] to suppress "
                "further warnings."));

@@ -605,7 +599,9 @@ void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)

                //case wxNO: nothing to do
        }
-#endif // !GUI/GUI
+#else // !GUI
+        Trap();
+#endif // GUI/!GUI
    }

    s_bInAssert = FALSE;
--- a/src/common/memory.cpp
+++ b/src/common/memory.cpp
@@ -110,7 +110,7 @@
 */
 void wxMemStruct::ErrorMsg (const char * mesg)
 {
-  wxLogDebug(_T("wxWindows memory checking error: %s"), mesg);
+  wxLogDebug(T("wxWindows memory checking error: %s"), mesg);
  PrintNode ();

 //         << m_fileName << ' ' << m_lineNum << endl;
@@ -121,7 +121,7 @@ void wxMemStruct::ErrorMsg (const char * mesg)
 */
 void wxMemStruct::ErrorMsg ()
 {
-  wxLogDebug(_T("wxWindows over/underwrite memory error:"));
+  wxLogDebug(T("wxWindows over/underwrite memory error:"));
  PrintNode ();

 //    cerr << m_fileName << ' ' << m_lineNum << endl;
@@ -329,18 +329,18 @@ void wxMemStruct::PrintNode ()

    // Let's put this in standard form so IDEs can load the file at the appropriate
    // line
-    wxString msg(_T(""));
+    wxString msg(T(""));

    if (m_fileName)
-      msg.Printf(_T("%s(%d): "), m_fileName, (int)m_lineNum);
+      msg.Printf(T("%s(%d): "), m_fileName, (int)m_lineNum);

    if (info && info->GetClassName())
      msg += info->GetClassName();
    else
-      msg += _T("object");
+      msg += T("object");

    wxString msg2;
-    msg2.Printf(_T(" at $%lX, size %d"), (long)GetActualData(), (int)RequestSize());
+    msg2.Printf(T(" at $%lX, size %d"), (long)GetActualData(), (int)RequestSize());
    msg += msg2;

    wxLogDebug(msg);
@@ -350,10 +350,10 @@ void wxMemStruct::PrintNode ()
    wxString msg("");

    if (m_fileName)
-      msg.Printf(_T("%s(%d): "), m_fileName, (int)m_lineNum);
-    msg += _T("non-object data");
+      msg.Printf(T("%s(%d): "), m_fileName, (int)m_lineNum);
+    msg += T("non-object data");
    wxString msg2;
-    msg2.Printf(_T(" at $%lX, size %d\n"), (long)GetActualData(), (int)RequestSize());
+    msg2.Printf(T(" at $%lX, size %d\n"), (long)GetActualData(), (int)RequestSize());
    msg += msg2;

    wxLogDebug(msg);
@@ -368,9 +368,9 @@ void wxMemStruct::Dump ()
  {
    wxObject *obj = (wxObject *)m_actualData;

-    wxString msg(_T(""));
+    wxString msg(T(""));
    if (m_fileName)
-      msg.Printf(_T("%s(%d): "), m_fileName, (int)m_lineNum);
+      msg.Printf(T("%s(%d): "), m_fileName, (int)m_lineNum);


    /* TODO: We no longer have a stream (using wxLogDebug) so we can't dump it.
@@ -383,22 +383,22 @@ void wxMemStruct::Dump ()
    if (obj->GetClassInfo() && obj->GetClassInfo()->GetClassName())
      msg += obj->GetClassInfo()->GetClassName();
    else
-      msg += _T("unknown object class");
+      msg += T("unknown object class");

    wxString msg2("");
-    msg2.Printf(_T(" at $%lX, size %d"), (long)GetActualData(), (int)RequestSize());
+    msg2.Printf(T(" at $%lX, size %d"), (long)GetActualData(), (int)RequestSize());
    msg += msg2;

    wxLogDebug(msg);
  }
  else
  {
-    wxString msg(_T(""));
+    wxString msg(T(""));
    if (m_fileName)
-      msg.Printf(_T("%s(%d): "), m_fileName, (int)m_lineNum);
+      msg.Printf(T("%s(%d): "), m_fileName, (int)m_lineNum);

    wxString msg2("");
-    msg2.Printf(_T("non-object data at $%lX, size %d"), (long)GetActualData(), (int)RequestSize() );
+    msg2.Printf(T("non-object data at $%lX, size %d"), (long)GetActualData(), (int)RequestSize() );
    msg += msg2;
    wxLogDebug(msg);
  }
@@ -418,7 +418,7 @@ int wxMemStruct::ValidateNode ()
        else {
            // Can't use the error routines as we have no recognisable object.
 #ifndef __WXGTK__
-             wxLogDebug(_T("Can't verify memory struct - all bets are off!"));
+             wxLogDebug(T("Can't verify memory struct - all bets are off!"));
 #endif
        }
        return 0;
@@ -666,23 +666,23 @@ bool wxDebugContext::Dump(void)

 //  if (TRUE)
  {
-    wxChar* appName = _T("application");
+    wxChar* appName = T("application");
    wxString appNameStr("");
    if (wxTheApp)
    {
        appNameStr = wxTheApp->GetAppName();
        appName = WXSTRINGCAST appNameStr;
-        wxLogDebug(_T("----- Memory dump of %s at %s -----"), appName, WXSTRINGCAST wxNow() );
+        wxLogDebug(T("----- Memory dump of %s at %s -----"), appName, WXSTRINGCAST wxNow() );
    }
    else
    {
-      wxLogDebug( _T("----- Memory dump -----") );
+      wxLogDebug( T("----- Memory dump -----") );
    }
  }
  TraverseList ((PmSFV)&wxMemStruct::Dump, (checkPoint ? checkPoint->m_next : (wxMemStruct*)NULL));

-  wxLogDebug( _T("") );
-  wxLogDebug( _T("") );
+  wxLogDebug( T("") );
+  wxLogDebug( T("") );

  return TRUE;
 #else
@@ -723,17 +723,17 @@ bool wxDebugContext::PrintStatistics(bool detailed)

 //  if (TRUE)
  {
-    wxChar* appName = _T("application");
-    wxString appNameStr(_T(""));
+    wxChar* appName = T("application");
+    wxString appNameStr(T(""));
    if (wxTheApp)
    {
        appNameStr = wxTheApp->GetAppName();
        appName = WXSTRINGCAST appNameStr;
-        wxLogDebug(_T("----- Memory statistics of %s at %s -----"), appName, WXSTRINGCAST wxNow() );
+        wxLogDebug(T("----- Memory statistics of %s at %s -----"), appName, WXSTRINGCAST wxNow() );
    }
    else
    {
-      wxLogDebug( _T("----- Memory statistics -----") );
+      wxLogDebug( T("----- Memory statistics -----") );
    }
  }

@@ -757,7 +757,7 @@ bool wxDebugContext::PrintStatistics(bool detailed)
 //    if (detailed && (data != (void*)m_debugStream) && (data != (void*) m_streamBuf))
      if (detailed && (data != (void*) wxLog::GetActiveTarget()))
    {
-      wxChar *className = _T("nonobject");
+      wxChar *className = T("nonobject");
      if (st->m_isObject && st->GetActualData())
      {
        wxObject *obj = (wxObject *)st->GetActualData();
@@ -792,22 +792,22 @@ bool wxDebugContext::PrintStatistics(bool detailed)
  {
    while (list)
    {
-      wxLogDebug(_T("%ld objects of class %s, total size %ld"),
+      wxLogDebug(T("%ld objects of class %s, total size %ld"),
          list->instanceCount, list->instanceClass, list->totalSize);
      wxDebugStatsStruct *old = list;
      list = old->next;
      free((char *)old);
    }
-    wxLogDebug(_T(""));
+    wxLogDebug(T(""));
  }

  SetDebugMode(currentMode);

-  wxLogDebug(_T("Number of object items: %ld"), noObjectNodes);
-  wxLogDebug(_T("Number of non-object items: %ld"), noNonObjectNodes);
-  wxLogDebug(_T("Total allocated size: %ld"), totalSize);
-  wxLogDebug(_T(""));
-  wxLogDebug(_T(""));
+  wxLogDebug(T("Number of object items: %ld"), noObjectNodes);
+  wxLogDebug(T("Number of non-object items: %ld"), noNonObjectNodes);
+  wxLogDebug(T("Total allocated size: %ld"), totalSize);
+  wxLogDebug(T(""));
+  wxLogDebug(T(""));

  return TRUE;
 #else
@@ -822,13 +822,13 @@ bool wxDebugContext::PrintClasses(void)

 //  if (TRUE)
  {
-    wxChar* appName = _T("application");
-    wxString appNameStr(_T(""));
+    wxChar* appName = T("application");
+    wxString appNameStr(T(""));
    if (wxTheApp)
    {
        appNameStr = wxTheApp->GetAppName();
        appName = WXSTRINGCAST appNameStr;
-        wxLogDebug(_T("----- Classes in %s -----"), appName);
+        wxLogDebug(T("----- Classes in %s -----"), appName);
    }
  }

@@ -844,32 +844,32 @@ bool wxDebugContext::PrintClasses(void)
    if (info->GetClassName())
    {
        wxString msg(info->GetClassName());
-        msg += _T(" ");
+        msg += T(" ");

        if (info->GetBaseClassName1() && !info->GetBaseClassName2())
        {
-            msg += _T("is a ");
+            msg += T("is a ");
            msg += info->GetBaseClassName1();
        }
        else if (info->GetBaseClassName1() && info->GetBaseClassName2())
        {
-            msg += _T("is a ");
+            msg += T("is a ");
            msg += info->GetBaseClassName1() ;
-            msg += _T(", ");
+            msg += T(", ");
            msg += info->GetBaseClassName2() ;
        }
        if (info->GetConstructor())
-            msg += _T(": dynamic");
+            msg += T(": dynamic");

        wxLogDebug(msg);
    }
    node = wxClassInfo::sm_classTable->Next();
    n ++;
  }
-  wxLogDebug(_T(""));
-  wxLogDebug(_T("There are %d classes derived from wxObject."), n);
-  wxLogDebug(_T(""));
-  wxLogDebug(_T(""));
+  wxLogDebug(T(""));
+  wxLogDebug(T("There are %d classes derived from wxObject."), n);
+  wxLogDebug(T(""));
+  wxLogDebug(T(""));
  return TRUE;
 }

@@ -1040,7 +1040,7 @@ void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject,
    int totSize = wxDebugContext::TotSize (size);
    char * buf = (char *) malloc(totSize);
    if (!buf) {
-        wxLogDebug(_T("Call to malloc (%ld) failed."), (long)size);
+        wxLogDebug(T("Call to malloc (%ld) failed."), (long)size);
        return 0;
    }
    wxMemStruct * st = (wxMemStruct *)buf;
--- a/src/common/mimetype.cpp
+++ b/src/common/mimetype.cpp
@@ -249,7 +249,7 @@ public:
                break;
        }

-        wxASSERT_MSG( n == pos, _T("invalid position in MailCapEntry::Insert") );
+        wxASSERT_MSG( n == pos, T("invalid position in MailCapEntry::Insert") );

        m_next = cur->m_next;
        cur->m_next = this;
@@ -257,7 +257,7 @@ public:
        // append this element to the list
    void Append(MailCapEntry *next)
    {
-        wxCHECK_RET( next != NULL, _T("Append()ing to what?") );
+        wxCHECK_RET( next != NULL, T("Append()ing to what?") );

        // FIXME slooow...
        MailCapEntry *cur;
@@ -266,7 +266,7 @@ public:

        cur->m_next = this;

-        wxASSERT_MSG( !m_next, _T("Append()ing element already in the list?") );
+        wxASSERT_MSG( !m_next, T("Append()ing element already in the list?") );
    }

 private:
@@ -413,57 +413,57 @@ wxString wxFileType::ExpandCommand(const wxString& command,
    bool hasFilename = FALSE;

    wxString str;
-    for ( const wxChar *pc = command.c_str(); *pc != _T('\0'); pc++ ) {
-        if ( *pc == _T('%') ) {
+    for ( const wxChar *pc = command.c_str(); *pc != T('\0'); pc++ ) {
+        if ( *pc == T('%') ) {
            switch ( *++pc ) {
-                case _T('s'):
+                case T('s'):
                    // '%s' expands into file name (quoted because it might
                    // contain spaces) - except if there are already quotes
                    // there because otherwise some programs may get confused
                    // by double double quotes
 #if 0
-                    if ( *(pc - 2) == _T('"') )
+                    if ( *(pc - 2) == T('"') )
                        str << params.GetFileName();
                    else
-                        str << _T('"') << params.GetFileName() << _T('"');
+                        str << T('"') << params.GetFileName() << T('"');
 #endif
                    str << params.GetFileName();
                    hasFilename = TRUE;
                    break;

-                case _T('t'):
+                case T('t'):
                    // '%t' expands into MIME type (quote it too just to be
                    // consistent)
-                    str << _T('\'') << params.GetMimeType() << _T('\'');
+                    str << T('\'') << params.GetMimeType() << T('\'');
                    break;

-                case _T('{'):
+                case T('{'):
                    {
-                        const wxChar *pEnd = wxStrchr(pc, _T('}'));
+                        const wxChar *pEnd = wxStrchr(pc, T('}'));
                        if ( pEnd == NULL ) {
                            wxString mimetype;
                            wxLogWarning(_("Unmatched '{' in an entry for "
                                           "mime type %s."),
                                         params.GetMimeType().c_str());
-                            str << _T("%{");
+                            str << T("%{");
                        }
                        else {
                            wxString param(pc + 1, pEnd - pc - 1);
-                            str << _T('\'') << params.GetParamValue(param) << _T('\'');
+                            str << T('\'') << params.GetParamValue(param) << T('\'');
                            pc = pEnd;
                        }
                    }
                    break;

-                case _T('n'):
-                case _T('F'):
+                case T('n'):
+                case T('F'):
                    // TODO %n is the number of parts, %F is an array containing
                    //      the names of temp files these parts were written to
                    //      and their mime types.
                    break;

                default:
-                    wxLogDebug(_T("Unknown field %%%c in command '%s'."),
+                    wxLogDebug(T("Unknown field %%%c in command '%s'."),
                               *pc, command.c_str());
                    str << *pc;
            }
@@ -476,7 +476,7 @@ wxString wxFileType::ExpandCommand(const wxString& command,
    // metamail(1) man page states that if the mailcap entry doesn't have '%s'
    // the program will accept the data on stdin: so give it to it!
    if ( !hasFilename && !str.IsEmpty() ) {
-        str << _T(" < '") << params.GetFileName() << _T('\'');
+        str << T(" < '") << params.GetFileName() << T('\'');
    }

    return str;
@@ -533,16 +533,16 @@ wxFileType::GetPrintCommand(wxString *printCmd,
 bool wxMimeTypesManager::IsOfType(const wxString& mimeType,
                                  const wxString& wildcard)
 {
-    wxASSERT_MSG( mimeType.Find(_T('*')) == wxNOT_FOUND,
-                  _T("first MIME type can't contain wildcards") );
+    wxASSERT_MSG( mimeType.Find(T('*')) == wxNOT_FOUND,
+                  T("first MIME type can't contain wildcards") );

    // all comparaisons are case insensitive (2nd arg of IsSameAs() is FALSE)
-    if ( wildcard.BeforeFirst(_T('/')).IsSameAs(mimeType.BeforeFirst(_T('/')), FALSE) )
+    if ( wildcard.BeforeFirst(T('/')).IsSameAs(mimeType.BeforeFirst(T('/')), FALSE) )
    {
-        wxString strSubtype = wildcard.AfterFirst(_T('/'));
+        wxString strSubtype = wildcard.AfterFirst(T('/'));

-        if ( strSubtype == _T("*") ||
-             strSubtype.IsSameAs(mimeType.AfterFirst(_T('/')), FALSE) )
+        if ( strSubtype == T("*") ||
+             strSubtype.IsSameAs(mimeType.AfterFirst(T('/')), FALSE) )
        {
            // matches (either exactly or it's a wildcard)
            return TRUE;
@@ -602,13 +602,13 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
    // suppress possible error messages
    wxLogNull nolog;
    wxString strKey;
-    strKey << m_strFileType << _T("\\shell\\") << verb << _T("\\command");
+    strKey << m_strFileType << T("\\shell\\") << verb << T("\\command");
    wxRegKey key(wxRegKey::HKCR, strKey);

    wxString command;
    if ( key.Open() ) {
        // it's the default value of the key
-        if ( key.QueryValue(_T(""), command) ) {
+        if ( key.QueryValue(T(""), command) ) {
            // transform it from '%1' to '%s' style format string

            // NB: we don't make any attempt to verify that the string is valid,
@@ -617,10 +617,10 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
            bool foundFilename = FALSE;
            size_t len = command.Len();
            for ( size_t n = 0; (n < len) && !foundFilename; n++ ) {
-                if ( command[n] == _T('%') &&
-                     (n + 1 < len) && command[n + 1] == _T('1') ) {
+                if ( command[n] == T('%') &&
+                     (n + 1 < len) && command[n + 1] == T('1') ) {
                    // replace it with '%s'
-                    command[n + 1] = _T('s');
+                    command[n + 1] = T('s');

                    foundFilename = TRUE;
                }
@@ -629,7 +629,7 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
            if ( !foundFilename ) {
                // we didn't find any '%1'!
                // HACK: append the filename at the end, hope that it will do
-                command << _T(" %s");
+                command << T(" %s");
            }
        }
    }
@@ -648,7 +648,7 @@ wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
        cmd = m_info->GetOpenCommand();
    }
    else {
-        cmd = GetCommand(_T("open"));
+        cmd = GetCommand(T("open"));
    }

    *openCmd = wxFileType::ExpandCommand(cmd, params);
@@ -666,7 +666,7 @@ wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
        cmd = m_info->GetPrintCommand();
    }
    else {
-        cmd = GetCommand(_T("print"));
+        cmd = GetCommand(T("print"));
    }

    *printCmd = wxFileType::ExpandCommand(cmd, params);
@@ -707,8 +707,8 @@ bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const

    // suppress possible error messages
    wxLogNull nolog;
-    wxRegKey key(wxRegKey::HKCR, /*m_strFileType*/ _T(".") + m_ext);
-    if ( key.Open() && key.QueryValue(_T("Content Type"), *mimeType) ) {
+    wxRegKey key(wxRegKey::HKCR, /*m_strFileType*/ T(".") + m_ext);
+    if ( key.Open() && key.QueryValue(T("Content Type"), *mimeType) ) {
        return TRUE;
    }
    else {
@@ -724,7 +724,7 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
    }

    wxString strIconKey;
-    strIconKey << m_strFileType << _T("\\DefaultIcon");
+    strIconKey << m_strFileType << T("\\DefaultIcon");

    // suppress possible error messages
    wxLogNull nolog;
@@ -733,18 +733,18 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
    if ( key.Open() ) {
        wxString strIcon;
        // it's the default value of the key
-        if ( key.QueryValue(_T(""), strIcon) ) {
+        if ( key.QueryValue(T(""), strIcon) ) {
            // the format is the following: <full path to file>, <icon index>
            // NB: icon index may be negative as well as positive and the full
            //     path may contain the environment variables inside '%'
-            wxString strFullPath = strIcon.BeforeLast(_T(',')),
-            strIndex = strIcon.AfterLast(_T(','));
+            wxString strFullPath = strIcon.BeforeLast(T(',')),
+            strIndex = strIcon.AfterLast(T(','));

            // index may be omitted, in which case BeforeLast(',') is empty and
            // AfterLast(',') is the whole string
            if ( strFullPath.IsEmpty() ) {
                strFullPath = strIndex;
-                strIndex = _T("0");
+                strIndex = T("0");
            }

            wxString strExpPath = wxExpandEnvVars(strFullPath);
@@ -754,7 +754,7 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
            switch ( (int)hIcon ) {
                case 0: // means no icons were found
                case 1: // means no such file or it wasn't a DLL/EXE/OCX/ICO/...
-                    wxLogDebug(_T("incorrect registry entry '%s': no such icon."),
+                    wxLogDebug(T("incorrect registry entry '%s': no such icon."),
                               key.GetName().c_str());
                    break;

@@ -784,7 +784,7 @@ bool wxFileTypeImpl::GetDescription(wxString *desc) const

    if ( key.Open() ) {
        // it's the default value of the key
-        if ( key.QueryValue(_T(""), *desc) ) {
+        if ( key.QueryValue(T(""), *desc) ) {
            return TRUE;
        }
    }
@@ -798,8 +798,8 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 {
    // add the leading point if necessary
    wxString str;
-    if ( ext[0u] != _T('.') ) {
-        str = _T('.');
+    if ( ext[0u] != T('.') ) {
+        str = T('.');
    }
    str << ext;

@@ -810,7 +810,7 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
    wxRegKey key(wxRegKey::HKCR, str);
    if ( key.Open() ) {
        // it's the default value of the key
-        if ( key.QueryValue(_T(""), strFileType) ) {
+        if ( key.QueryValue(T(""), strFileType) ) {
            // create the new wxFileType object
            wxFileType *fileType = new wxFileType;
            fileType->m_impl->Init(strFileType, ext);
@@ -842,7 +842,7 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 {
    // HACK I don't know of any official documentation which mentions this
    //      location, but as a matter of fact IE uses it, so why not we?
-    static const wxChar *szMimeDbase = _T("MIME\\Database\\Content Type\\");
+    static const wxChar *szMimeDbase = T("MIME\\Database\\Content Type\\");

    wxString strKey = szMimeDbase;
    strKey << mimeType;
@@ -853,7 +853,7 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
    wxString ext;
    wxRegKey key(wxRegKey::HKCR, strKey);
    if ( key.Open() ) {
-        if ( key.QueryValue(_T("Extension"), ext) ) {
+        if ( key.QueryValue(T("Extension"), ext) ) {
            return GetFileTypeFromExtension(ext);
        }
    }
@@ -889,12 +889,12 @@ wxFileTypeImpl::GetEntry(const wxFileType::MessageParameters& params) const

        if ( command.IsEmpty() || (wxSystem(command) == 0) ) {
            // ok, passed
-            wxLogTrace(_T("Test '%s' for mime type '%s' succeeded."),
+            wxLogTrace(T("Test '%s' for mime type '%s' succeeded."),
                       command.c_str(), params.GetMimeType().c_str());
            break;
        }
        else {
-            wxLogTrace(_T("Test '%s' for mime type '%s' failed."),
+            wxLogTrace(T("Test '%s' for mime type '%s' failed."),
                       command.c_str(), params.GetMimeType().c_str());
        }

@@ -933,7 +933,7 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
    // one extension in the space or comma delimitid list
    wxString strExt;
    for ( const wxChar *p = strExtensions; ; p++ ) {
-        if ( *p == _T(' ') || *p == _T(',') || *p == _T('\0') ) {
+        if ( *p == T(' ') || *p == T(',') || *p == T('\0') ) {
            if ( !strExt.IsEmpty() ) {
                extensions.Add(strExt);
                strExt.Empty();
@@ -941,13 +941,13 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
            //else: repeated spaces (shouldn't happen, but it's not that
            //      important if it does happen)

-            if ( *p == _T('\0') )
+            if ( *p == T('\0') )
                break;
        }
-        else if ( *p == _T('.') ) {
+        else if ( *p == T('.') ) {
            // remove the dot from extension (but only if it's the first char)
            if ( !strExt.IsEmpty() ) {
-                strExt += _T('.');
+                strExt += T('.');
            }
            //else: no, don't append it
        }
@@ -966,38 +966,38 @@ wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
    // (taken from metamail(1) sources)
    static const wxChar *aStandardLocations[] =
    {
-        _T("/etc"),
-        _T("/usr/etc"),
-        _T("/usr/local/etc"),
-        _T("/etc/mail"),
-        _T("/usr/public/lib")
+        T("/etc"),
+        T("/usr/etc"),
+        T("/usr/local/etc"),
+        T("/etc/mail"),
+        T("/usr/public/lib")
    };

    // first read the system wide file(s)
    for ( size_t n = 0; n < WXSIZEOF(aStandardLocations); n++ ) {
        wxString dir = aStandardLocations[n];

-        wxString file = dir + _T("/mailcap");
+        wxString file = dir + T("/mailcap");
        if ( wxFile::Exists(file) ) {
            ReadMailcap(file);
        }

-        file = dir + _T("/mime.types");
+        file = dir + T("/mime.types");
        if ( wxFile::Exists(file) ) {
            ReadMimeTypes(file);
        }
    }

-    wxString strHome = wxGetenv(_T("HOME"));
+    wxString strHome = wxGetenv(T("HOME"));

    // and now the users mailcap
-    wxString strUserMailcap = strHome + _T("/.mailcap");
+    wxString strUserMailcap = strHome + T("/.mailcap");
    if ( wxFile::Exists(strUserMailcap) ) {
        ReadMailcap(strUserMailcap);
    }

    // read the users mime.types
-    wxString strUserMimeTypes = strHome + _T("/.mime.types");
+    wxString strUserMimeTypes = strHome + T("/.mime.types");
    if ( wxFile::Exists(strUserMimeTypes) ) {
        ReadMimeTypes(strUserMimeTypes);
    }
@@ -1010,8 +1010,8 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
    for ( size_t n = 0; n < count; n++ ) {
        wxString extensions = m_aExtensions[n];
        while ( !extensions.IsEmpty() ) {
-            wxString field = extensions.BeforeFirst(_T(' '));
-            extensions = extensions.AfterFirst(_T(' '));
+            wxString field = extensions.BeforeFirst(T(' '));
+            extensions = extensions.AfterFirst(T(' '));

            // consider extensions as not being case-sensitive
            if ( field.IsSameAs(ext, FALSE /* no case */) ) {
@@ -1041,12 +1041,12 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
        // then try to find "text/*" as match for "text/plain" (for example)
        // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return
        //     the whole string - ok.
-        wxString strCategory = mimetype.BeforeFirst(_T('/'));
+        wxString strCategory = mimetype.BeforeFirst(T('/'));

        size_t nCount = m_aTypes.Count();
        for ( size_t n = 0; n < nCount; n++ ) {
-            if ( (m_aTypes[n].BeforeFirst(_T('/')) == strCategory ) &&
-                 m_aTypes[n].AfterFirst(_T('/')) == _T("*") ) {
+            if ( (m_aTypes[n].BeforeFirst(T('/')) == strCategory ) &&
+                 m_aTypes[n].AfterFirst(T('/')) == T("*") ) {
                    index = n;
                    break;
            }
@@ -1072,7 +1072,7 @@ void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
    size_t nExts = exts.GetCount();
    for ( size_t nExt = 0; nExt < nExts; nExt++ ) {
        if ( nExt > 0 ) {
-            extensions += _T(' ');
+            extensions += T(' ');
        }
        extensions += exts[nExt];
    }
@@ -1084,7 +1084,7 @@ void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
    AddMailcapInfo(filetype.GetMimeType(),
                   filetype.GetOpenCommand(),
                   filetype.GetPrintCommand(),
-                   _T(""),
+                   T(""),
                   filetype.GetDescription());
 }

@@ -1123,7 +1123,7 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
        m_aTypes.Add(strType);

        m_aEntries.Add(entry);
-        m_aExtensions.Add(_T(""));
+        m_aExtensions.Add(T(""));
        m_aDescriptions.Add(strDesc);
    }
    else {
@@ -1139,7 +1139,7 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,

 bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 {
-    wxLogTrace(_T("--- Parsing mime.types file '%s' ---"), strFileName.c_str());
+    wxLogTrace(T("--- Parsing mime.types file '%s' ---"), strFileName.c_str());

    wxTextFile file(strFileName);
    if ( !file.Open() )
@@ -1165,20 +1165,20 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
            pc++;

        // comment?
-        if ( *pc == _T('#') ) {
+        if ( *pc == T('#') ) {
            // skip the whole line
            pc = NULL;
            continue;
        }

        // detect file format
-        const wxChar *pEqualSign = wxStrchr(pc, _T('='));
+        const wxChar *pEqualSign = wxStrchr(pc, T('='));
        if ( pEqualSign == NULL ) {
            // brief format
            // ------------

            // first field is mime type
-            for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != _T('\0'); pc++ ) {
+            for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != T('\0'); pc++ ) {
                strMimeType += *pc;
            }

@@ -1204,9 +1204,9 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
                ;

            const wxChar *pEnd;
-            if ( *pc == _T('"') ) {
+            if ( *pc == T('"') ) {
                // the string is quoted and ends at the matching quote
-                pEnd = wxStrchr(++pc, _T('"'));
+                pEnd = wxStrchr(++pc, T('"'));
                if ( pEnd == NULL ) {
                    wxLogWarning(_("Mime.types file %s, line %d: unterminated "
                                   "quoted string."),
@@ -1223,7 +1223,7 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
            wxString strRHS(pc, pEnd - pc);

            // check what follows this entry
-            if ( *pEnd == _T('"') ) {
+            if ( *pEnd == T('"') ) {
                // skip this quote
                pEnd++;
            }
@@ -1233,20 +1233,20 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)

            // if there is something left, it may be either a '\\' to continue
            // the line or the next field of the same entry
-            bool entryEnded = *pc == _T('\0'),
+            bool entryEnded = *pc == T('\0'),
                 nextFieldOnSameLine = FALSE;
            if ( !entryEnded ) {
-                nextFieldOnSameLine = ((*pc != _T('\\')) || (pc[1] != _T('\0')));
+                nextFieldOnSameLine = ((*pc != T('\\')) || (pc[1] != T('\0')));
            }

            // now see what we got
-            if ( strLHS == _T("type") ) {
+            if ( strLHS == T("type") ) {
                strMimeType = strRHS;
            }
-            else if ( strLHS == _T("desc") ) {
+            else if ( strLHS == T("desc") ) {
                strDesc = strRHS;
            }
-            else if ( strLHS == _T("exts") ) {
+            else if ( strLHS == T("exts") ) {
                strExtensions = strRHS;
            }
            else {
@@ -1269,10 +1269,10 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
        // although it doesn't seem to be covered by RFCs, some programs
        // (notably Netscape) create their entries with several comma
        // separated extensions (RFC mention the spaces only)
-        strExtensions.Replace(_T(","), _T(" "));
+        strExtensions.Replace(T(","), T(" "));

        // also deal with the leading dot
-        if ( !strExtensions.IsEmpty() && strExtensions[0] == _T('.') ) {
+        if ( !strExtensions.IsEmpty() && strExtensions[0] == T('.') ) {
            strExtensions.erase(0, 1);
        }

@@ -1293,7 +1293,7 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                         bool fallback)
 {
-    wxLogTrace(_T("--- Parsing mailcap file '%s' ---"), strFileName.c_str());
+    wxLogTrace(T("--- Parsing mailcap file '%s' ---"), strFileName.c_str());

    wxTextFile file(strFileName);
    if ( !file.Open() )
@@ -1317,7 +1317,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
            pc++;

        // comment or empty string?
-        if ( *pc == _T('#') || *pc == _T('\0') )
+        if ( *pc == T('#') || *pc == T('\0') )
            continue;

        // no, do parse
@@ -1343,10 +1343,10 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                 curField; // accumulator
        for ( bool cont = TRUE; cont; pc++ ) {
            switch ( *pc ) {
-                case _T('\\'):
+                case T('\\'):
                    // interpret the next character literally (notice that
                    // backslash can be used for line continuation)
-                    if ( *++pc == _T('\0') ) {
+                    if ( *++pc == T('\0') ) {
                        // fetch the next line.

                        // pc currently points to nowhere, but after the next
@@ -1360,12 +1360,12 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                    }
                    break;

-                case _T('\0'):
+                case T('\0'):
                    cont = FALSE;   // end of line reached, exit the loop

                    // fall through

-                case _T(';'):
+                case T(';'):
                    // store this field and start looking for the next one

                    // trim whitespaces from both sides
@@ -1374,9 +1374,9 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                    switch ( currentToken ) {
                        case Field_Type:
                            strType = curField;
-                            if ( strType.Find(_T('/')) == wxNOT_FOUND ) {
+                            if ( strType.Find(T('/')) == wxNOT_FOUND ) {
                                // we interpret "type" as "type/*"
-                                strType += _T("/*");
+                                strType += T("/*");
                            }

                            currentToken = Field_OpenCmd;
@@ -1394,22 +1394,22 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                bool ok = TRUE;

                                // is this something of the form foo=bar?
-                                const wxChar *pEq = wxStrchr(curField, _T('='));
+                                const wxChar *pEq = wxStrchr(curField, T('='));
                                if ( pEq != NULL ) {
-                                    wxString lhs = curField.BeforeFirst(_T('=')),
-                                             rhs = curField.AfterFirst(_T('='));
+                                    wxString lhs = curField.BeforeFirst(T('=')),
+                                             rhs = curField.AfterFirst(T('='));

                                    lhs.Trim(TRUE);     // from right
                                    rhs.Trim(FALSE);    // from left

-                                    if ( lhs == _T("print") )
+                                    if ( lhs == T("print") )
                                        strPrintCmd = rhs;
-                                    else if ( lhs == _T("test") )
+                                    else if ( lhs == T("test") )
                                        strTest = rhs;
-                                    else if ( lhs == _T("description") ) {
+                                    else if ( lhs == T("description") ) {
                                        // it might be quoted
-                                        if ( rhs[0u] == _T('"') &&
-                                             rhs.Last() == _T('"') ) {
+                                        if ( rhs[0u] == T('"') &&
+                                             rhs.Last() == T('"') ) {
                                            strDesc = wxString(rhs.c_str() + 1,
                                                               rhs.Len() - 2);
                                        }
@@ -1417,10 +1417,10 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                            strDesc = rhs;
                                        }
                                    }
-                                    else if ( lhs == _T("compose") ||
-                                              lhs == _T("composetyped") ||
-                                              lhs == _T("notes") ||
-                                              lhs == _T("edit") )
+                                    else if ( lhs == T("compose") ||
+                                              lhs == T("composetyped") ||
+                                              lhs == T("notes") ||
+                                              lhs == T("edit") )
                                        ;   // ignore
                                    else
                                        ok = FALSE;
@@ -1431,11 +1431,11 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                    // TODO support the flags:
                                    //  1. create an xterm for 'needsterminal'
                                    //  2. append "| $PAGER" for 'copiousoutput'
-                                    if ( curField == _T("needsterminal") )
+                                    if ( curField == T("needsterminal") )
                                        needsterminal = TRUE;
-                                    else if ( curField == _T("copiousoutput") )
+                                    else if ( curField == T("copiousoutput") )
                                        copiousoutput = TRUE;
-                                    else if ( curField == _T("textualnewlines") )
+                                    else if ( curField == T("textualnewlines") )
                                        ;   // ignore
                                    else
                                        ok = FALSE;
@@ -1450,7 +1450,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                    // programmer
                                    wxLogDebug
                                    (
-                                      _T("Mailcap file %s, line %d: unknown "
+                                      T("Mailcap file %s, line %d: unknown "
                                      "field '%s' for the MIME type "
                                      "'%s' ignored."),
                                      strFileName.c_str(),
@@ -1466,7 +1466,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                            break;

                        default:
-                            wxFAIL_MSG(_T("unknown field type in mailcap"));
+                            wxFAIL_MSG(T("unknown field type in mailcap"));
                    }

                    // next token starts immediately after ';'
@@ -1498,7 +1498,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                m_aTypes.Add(strType);

                m_aEntries.Add(entry);
-                m_aExtensions.Add(_T(""));
+                m_aExtensions.Add(T(""));
                m_aDescriptions.Add(strDesc);
            }
            else {
--- a/src/common/object.cpp
+++ b/src/common/object.cpp
@@ -45,7 +45,7 @@
 #endif

 #if !USE_SHARED_LIBRARY
-wxClassInfo wxObject::sm_classwxObject((wxChar *) _T("wxObject"), (wxChar *) NULL, (wxChar *) NULL, (int ) sizeof(wxObject), (wxObjectConstructorFn) NULL);
+wxClassInfo wxObject::sm_classwxObject((wxChar *) T("wxObject"), (wxChar *) NULL, (wxChar *) NULL, (int ) sizeof(wxObject), (wxObjectConstructorFn) NULL);
 wxClassInfo* wxClassInfo::sm_first = (wxClassInfo *) NULL;
 wxHashTable* wxClassInfo::sm_classTable = (wxHashTable*) NULL;
 #endif
--- a/src/common/objstrm.cpp
+++ b/src/common/objstrm.cpp
@@ -45,7 +45,7 @@ wxString wxObjectOutputStream::GetObjectName(wxObject *obj)
 {
  wxString name;

-  name.Printf(_T("%x"), (unsigned long)obj);
+  name.Printf(T("%x"), (unsigned long)obj);
  return name;
 }

@@ -58,16 +58,16 @@ void wxObjectOutputStream::WriteObjectDef(wxObjectStreamInfo& info)
  if (info.duplicate) {
    data_s.WriteString(TAG_DUPLICATE_OBJECT);
    data_s.WriteString(GetObjectName(info.object));
-    wxPrintf(_T("info.object (dup %s)\n"), info.object->GetClassInfo()->GetClassName());
+    wxPrintf(T("info.object (dup %s)\n"), info.object->GetClassInfo()->GetClassName());
    return;
  }

  if (info.object) {
    data_s.WriteString(info.object->GetClassInfo()->GetClassName());
-    wxPrintf(_T("info.object (%s)\n"), info.object->GetClassInfo()->GetClassName());
+    wxPrintf(T("info.object (%s)\n"), info.object->GetClassInfo()->GetClassName());
  } else {
    data_s.WriteString(TAG_EMPTY_OBJECT);
-    wxPrintf(_T("info.object (NULL)\n"));
+    wxPrintf(T("info.object (NULL)\n"));
    return;
  }

--- a/src/common/prntbase.cpp
+++ b/src/common/prntbase.cpp
@@ -409,7 +409,7 @@ void wxPreviewControlBar::SetZoomControl(int zoom)
 int wxPreviewControlBar::GetZoomControl()
 {
    wxChar buf[20];
-    if (m_zoomControl && (m_zoomControl->GetStringSelection() != _T("")))
+    if (m_zoomControl && (m_zoomControl->GetStringSelection() != T("")))
    {
        wxStrcpy(buf, m_zoomControl->GetStringSelection());
        buf[wxStrlen(buf) - 1] = 0;
--- a/src/common/resourc2.cpp
+++ b/src/common/resourc2.cpp
@@ -422,7 +422,7 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxLB_EXTENDED", wxLB_EXTENDED },
  { "wxLB_NEEDED_SB", wxLB_NEEDED_SB },
  { "wxLB_ALWAYS_SB", wxLB_ALWAYS_SB },
-  { "wxLB_SORT", wxLB_SORT },
+  { "wxLB_SORT(", wxLB_SORT },
  { "wxLB_OWNERDRAW", wxLB_OWNERDRAW },
  { "wxLB_HSCROLL", wxLB_HSCROLL },

@@ -430,7 +430,7 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxCB_SIMPLE", wxCB_SIMPLE },
  { "wxCB_DROPDOWN", wxCB_DROPDOWN },
  { "wxCB_READONLY", wxCB_READONLY },
-  { "wxCB_SORT", wxCB_SORT },
+  { "wxCB_SORT(", wxCB_SORT },

  /* wxGauge */
  { "wxGA_PROGRESSBAR", wxGA_PROGRESSBAR },
@@ -457,9 +457,9 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxSL_VERTICAL", wxSL_VERTICAL },
  { "wxSL_AUTOTICKS", wxSL_AUTOTICKS },
  { "wxSL_LABELS", wxSL_LABELS },
-  { "wxSL_LEFT", wxSL_LEFT },
+  { "wxSL_LEFT(", wxSL_LEFT },
  { "wxSL_TOP", wxSL_TOP },
-  { "wxSL_RIGHT", wxSL_RIGHT },
+  { "wxSL_RIGHT(", wxSL_RIGHT },
  { "wxSL_BOTTOM", wxSL_BOTTOM },
  { "wxSL_BOTH", wxSL_BOTH },
  { "wxSL_SELRANGE", wxSL_SELRANGE },
@@ -475,17 +475,17 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  /* wxTreeCtrl */
  { "wxTR_HAS_BUTTONS", wxTR_HAS_BUTTONS },
  { "wxTR_EDIT_LABELS", wxTR_EDIT_LABELS },
-  { "wxTR_LINES_AT_ROOT", wxTR_LINES_AT_ROOT },
+  { "wxTR_LINES_AT_ROOT(", wxTR_LINES_AT_ROOT },

  /* wxListCtrl */
  { "wxLC_ICON", wxLC_ICON },
  { "wxLC_SMALL_ICON", wxLC_SMALL_ICON },
-  { "wxLC_LIST", wxLC_LIST },
-  { "wxLC_REPORT", wxLC_REPORT },
+  { "wxLC_LIST(", wxLC_LIST },
+  { "wxLC_REPORT(", wxLC_REPORT },
  { "wxLC_ALIGN_TOP", wxLC_ALIGN_TOP },
-  { "wxLC_ALIGN_LEFT", wxLC_ALIGN_LEFT },
+  { "wxLC_ALIGN_LEFT(", wxLC_ALIGN_LEFT },
  { "wxLC_AUTOARRANGE", wxLC_AUTOARRANGE },
-  { "wxLC_USER_TEXT", wxLC_USER_TEXT },
+  { "wxLC_USER_TEXT(", wxLC_USER_TEXT },
  { "wxLC_EDIT_LABELS", wxLC_EDIT_LABELS },
  { "wxLC_NO_HEADER", wxLC_NO_HEADER },
  { "wxLC_NO_SORT_HEADER", wxLC_NO_SORT_HEADER },
@@ -515,17 +515,17 @@ static wxResourceBitListStruct wxResourceBitListTable[] =

  /* wxControl */
  { "wxFIXED_LENGTH", wxFIXED_LENGTH},
-  { "wxALIGN_LEFT", wxALIGN_LEFT},
+  { "wxALIGN_LEFT(", wxALIGN_LEFT},
  { "wxALIGN_CENTER", wxALIGN_CENTER},
  { "wxALIGN_CENTRE", wxALIGN_CENTRE},
-  { "wxALIGN_RIGHT", wxALIGN_RIGHT},
+  { "wxALIGN_RIGHT(", wxALIGN_RIGHT},
  { "wxCOLOURED", wxCOLOURED},

  /* wxToolBar */
  { "wxTB_3DBUTTONS", wxTB_3DBUTTONS},
  { "wxTB_HORIZONTAL", wxTB_HORIZONTAL},
  { "wxTB_VERTICAL", wxTB_VERTICAL},
-  { "wxTB_FLAT", wxTB_FLAT},
+  { "wxTB_FLAT(", wxTB_FLAT},

  /* Generic */
  { "wxVSCROLL", wxVSCROLL },
@@ -536,7 +536,7 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxMINIMIZE", wxICONIZE},
  { "wxMAXIMIZE", wxMAXIMIZE},
  { "wxSDI", 0},
-  { "wxMDI_PARENT", 0},
+  { "wxMDI_PARENT(", 0},
  { "wxMDI_CHILD", 0},
  { "wxTHICK_FRAME", wxTHICK_FRAME},
  { "wxRESIZE_BORDER", wxRESIZE_BORDER},
@@ -552,7 +552,7 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxNATIVE_IMPL", 0},
  { "wxEXTENDED_IMPL", 0},
  { "wxBACKINGSTORE", wxBACKINGSTORE},
-//  { "wxFLAT", wxFLAT},
+//  { "wxFLAT(", wxFLAT},
 //  { "wxMOTIF_RESIZE", wxMOTIF_RESIZE},
  { "wxFIXED_LENGTH", 0},
  { "wxDOUBLE_BORDER", wxDOUBLE_BORDER},
@@ -565,30 +565,30 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxCLIP_CHILDREN", wxCLIP_CHILDREN},

  { "wxTINY_CAPTION_HORIZ", wxTINY_CAPTION_HORIZ},
-  { "wxTINY_CAPTION_VERT", wxTINY_CAPTION_VERT},
+  { "wxTINY_CAPTION_VERT(", wxTINY_CAPTION_VERT},

  // Text font families
-  { "wxDEFAULT", wxDEFAULT},
+  { "wxDEFAULT(", wxDEFAULT},
  { "wxDECORATIVE", wxDECORATIVE},
  { "wxROMAN", wxROMAN},
-  { "wxSCRIPT", wxSCRIPT},
+  { "wxSCRIPT(", wxSCRIPT},
  { "wxSWISS", wxSWISS},
  { "wxMODERN", wxMODERN},
  { "wxTELETYPE", wxTELETYPE},
  { "wxVARIABLE", wxVARIABLE},
  { "wxFIXED", wxFIXED},
  { "wxNORMAL", wxNORMAL},
-  { "wxLIGHT", wxLIGHT},
+  { "wxLIGHT(", wxLIGHT},
  { "wxBOLD", wxBOLD},
  { "wxITALIC", wxITALIC},
-  { "wxSLANT", wxSLANT},
+  { "wxSLANT(", wxSLANT},
  { "wxSOLID", wxSOLID},
-  { "wxDOT", wxDOT},
+  { "wxDOT(", wxDOT},
  { "wxLONG_DASH", wxLONG_DASH},
  { "wxSHORT_DASH", wxSHORT_DASH},
  { "wxDOT_DASH", wxDOT_DASH},
  { "wxUSER_DASH", wxUSER_DASH},
-  { "wxTRANSPARENT", wxTRANSPARENT},
+  { "wxTRANSPARENT(", wxTRANSPARENT},
  { "wxSTIPPLE", wxSTIPPLE},
  { "wxBDIAGONAL_HATCH", wxBDIAGONAL_HATCH},
  { "wxCROSSDIAG_HATCH", wxCROSSDIAG_HATCH},
@@ -601,25 +601,25 @@ static wxResourceBitListStruct wxResourceBitListTable[] =
  { "wxJOIN_ROUND", wxJOIN_ROUND},
  { "wxCAP_ROUND", wxCAP_ROUND},
  { "wxCAP_PROJECTING", wxCAP_PROJECTING},
-  { "wxCAP_BUTT", wxCAP_BUTT},
+  { "wxCAP_BUTT(", wxCAP_BUTT},

  // Logical ops
  { "wxCLEAR", wxCLEAR},
  { "wxXOR", wxXOR},
-  { "wxINVERT", wxINVERT},
+  { "wxINVERT(", wxINVERT},
  { "wxOR_REVERSE", wxOR_REVERSE},
  { "wxAND_REVERSE", wxAND_REVERSE},
  { "wxCOPY", wxCOPY},
  { "wxAND", wxAND},
-  { "wxAND_INVERT", wxAND_INVERT},
+  { "wxAND_INVERT(", wxAND_INVERT},
  { "wxNO_OP", wxNO_OP},
  { "wxNOR", wxNOR},
  { "wxEQUIV", wxEQUIV},
-  { "wxSRC_INVERT", wxSRC_INVERT},
-  { "wxOR_INVERT", wxOR_INVERT},
+  { "wxSRC_INVERT(", wxSRC_INVERT},
+  { "wxOR_INVERT(", wxOR_INVERT},
  { "wxNAND", wxNAND},
  { "wxOR", wxOR},
-  { "wxSET", wxSET},
+  { "wxSET(", wxSET},

  { "wxFLOOD_SURFACE", wxFLOOD_SURFACE},
  { "wxFLOOD_BORDER", wxFLOOD_BORDER},
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bryan Petty	c5691153e4	This commit was manufactured by cvs2svn to create tag 'wxPy-2-1-4'. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/wxPy-2-1-4@3889 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-07 23:40:33 +00:00
Robin Dunn	064f8bf6f8	removed some test code that accidentally was left in git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3850 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 16:27:10 +00:00
Karsten Ballüder	74697a5713	cvs debugging git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3849 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 15:42:04 +00:00
Karsten Ballüder	e87d60c93b	cvs debugging git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3848 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 15:40:04 +00:00
Julian Smart	a181ac202f	Corrected setting back git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3847 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 15:04:05 +00:00
Michael Bedward	e685e57bbd	Have to set focus to edit control when it is shown otherwise the insertion point stays at the beginning of the text control under wxMotif. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3846 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 08:23:29 +00:00
Robin Dunn	13971833d8	now supports wxCURSOR_BULLSEYE git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3845 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 07:09:26 +00:00
Robin Dunn	8f17924e73	added font encoding support some more demos some contributed items into the library many little tweaks and such git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3844 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 07:03:36 +00:00
Robin Dunn	f0261a7246	added font encoding support some more demos some contributed items into the library many little tweaks and such git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3843 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 06:22:25 +00:00
Michael Bedward	91233253ec	ifdef'd out wxEmptyString. This is defined in string.cpp. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3842 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 05:45:05 +00:00
Michael Bedward	f85afd4e46	Added new wxGrid classes. This is a work in progress ! Define wxUSE_NEW_GRID as 1 in setup.h to compile the new wxGrid otherwise the old wxGrid class will be compiled. Treat with caution and expect bugs and missing bits at this stage. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3841 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 05:13:20 +00:00
Michael Bedward	10434f3c24	Added comments git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3840 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 04:58:38 +00:00
Michael Bedward	e442cc0d9d	Sample program for new wxGrid classes. Define wxUSE_NEW_GRID as 1 in setup.h to use the new wxGrid. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3839 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-06 04:55:17 +00:00
Václav Slavík	704d25e2a3	PS printing now uses afm instead of gs_afm metrics git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3838 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 22:56:29 +00:00
David Webster	f0a56ab0c3	wxOS2 updates for 10/5/99 git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3837 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 22:10:56 +00:00
Robert Roebling	f7a11f8c8e	Updated configure (not only configure.in) Refresh improvements git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3836 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 19:38:05 +00:00
Sylvain Bougnoux	fe8aa971c4	after a seek, reset error if error==EOF git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3835 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 07:34:27 +00:00
Sylvain Bougnoux	a20cd16ca0	warn if visual isn't found git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3834 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 07:22:36 +00:00
Unknown (JL)	aee3892569	Debug version with compiler switch /MDd git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3833 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 06:40:42 +00:00
Robin Dunn	d6d2b6ae8f	Inceremented the version number for the DLL git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3832 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 06:32:15 +00:00
David Webster	27476f7368	* empty log message * git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3831 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-05 04:22:59 +00:00
Vadim Zeitlin	1bd1d102fd	use BMPs and npt PNGs under MSW git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3830 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-04 22:55:47 +00:00
Vadim Zeitlin	73974df1f9	MSW compilation (and other) fixes git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3829 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-04 22:55:10 +00:00
Vadim Zeitlin	e90c1d2a19	many changes; major ones: 1. start of !wxUSE_GUI support 2. _T() macro renamed to T() 3. wxConvertWX2MB and MB2WX macro added git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3828 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-04 20:15:38 +00:00
Karsten Ballüder	9841339c74	ping method almost there git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3827 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-04 20:03:07 +00:00
Robert Roebling	1d61ebaca1	OpenGl updates (still gives warnings..) git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3826 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775	1999-10-04 19:54:25 +00:00