This commit was manufactured by cvs2svn to create tag

'BEFORE_LIB_SPLIT'.

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

Makefile.in

@@ -1821,53 +1821,14 @@ 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
 
-BASE_DEPS = \
+OBJECTS = $(@GUIOBJS@) $(@COMMONOBJS@) $(@GENERICOBJS@) $(@UNIXOBJS@) $(HTMLOBJS) \
-    dynarray.d \
+	  $(JPEGOBJS) $(PNGOBJS) $(ZLIBOBJS)
-    event.d \
-    hash.d \
-    intl.d \
-    init.d \
-    file.d \
-    filefn.d \
-    list.d \
-    log.d \
-    object.d \
-    string.d \
-    utilscmn.d \
-    utilsunx.d
 
-BASE_HEADERS =
+DEPFILES = $(@GUIDEPS@) $(@COMMONDEPS@) $(@GENERICDEPS@) $(UNIXDEPS) $(HTMLDEPS)
 
-GUIOBJS = @GUIOBJS@
+HEADERS = $(@GUIHEADERS@) $(HTML_HEADERS) $(UNIX_HEADERS) $(PROTOCOL_HEADERS) \
-GUIDEPS = @GUIDEPS@
+	  $(GENERIC_HEADERS) $(WX_HEADERS)
-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@
 

configure.in

@@ -880,85 +880,6 @@ 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])
@@ -1008,6 +929,15 @@ 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 ---------------------------------------------------------------------------
@@ -1209,8 +1139,6 @@ 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
@@ -1259,11 +1187,6 @@ 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 ---------------------------------------------------------------------------
@@ -1467,8 +1390,6 @@ dnl ----------------------------------------------------------------
 dnl search for toolkit (widget sets)
 dnl ----------------------------------------------------------------
 
-if test "$wxUSE_GUI" = "yes"; then
-
 TOOLKIT=
 TOOLKIT_INCLUDE=
 
@@ -1508,10 +1429,10 @@ if test "$wxUSE_CYGWIN" = 1 || test "$wxUSE_MINGW" = 1 ; then
 
     TOOLKIT=MSW
 
-    GUIOBJS="\$(MSW_GUIOBJS)"
+    GUIOBJS=MSW_GUIOBJS
-    GUIHEADERS="\$(MSW_HEADERS)"
+    GUIHEADERS=MSW_HEADERS
-    COMMONOBJS="\$(MSW_COMMONOBJS)"
+    COMMONOBJS=MSW_COMMONOBJS
-    GENERICOBJS="\$(MSW_GENERICOBJS)"
+    GENERICOBJS=MSW_GENERICOBJS
     UNIXOBJS=
     GUIDIST=MSW_DIST
     PROGRAM_EXT=.exe
@@ -1529,14 +1450,14 @@ if test "$wxUSE_GTK" = 1; then
     GUI_TK_LIBRARY="$GTK_LIBS"
     TOOLKIT=GTK
 
-    GUIOBJS="\$(GTK_GUIOBJS)"
+    GUIHEADERS=GTK_HEADERS
-    GUIHEADERS="\$(GTK_HEADERS)"
+    GUIOBJS=GTK_GUIOBJS
-    COMMONOBJS="\$(GTK_COMMONOBJS)"
+    COMMONOBJS=GTK_COMMONOBJS
-    GENERICOBJS="\$(GTK_GENERICOBJS)"
+    GENERICOBJS=GTK_GENERICOBJS
-    GUIDEPS="\$(GTK_GUIDEPS)"
+    GUIDEPS=GTK_GUIDEPS
-    COMMONDEPS="\$(GTK_COMMONDEPS)"
+    COMMONDEPS=GTK_COMMONDEPS
-    GENERICDEPS="\$(GTK_GENERICDEPS)"
+    GENERICDEPS=GTK_GENERICDEPS
-    UNIXOBJS="\$(UNIX_OBJS)"
+    UNIXOBJS=UNIXOBJS
     GUIDIST=GTK_DIST
 fi
 
@@ -1580,14 +1501,14 @@ if test "$wxUSE_WINE" = 1; then
     WXWINE=1
     TOOLKIT=MSW
 
-    GUIHEADERS="\$(MSW_HEADERS)"
+    GUIHEADERS=MSW_HEADERS
-    GUIOBJS="\$(MSW_GUIOBJS)"
+    GUIOBJS=MSW_GUIOBJS
-    COMMONOBJS="\$(MSW_COMMONOBJS)"
+    COMMONOBJS=MSW_COMMONOBJS
-    GENERICOBJS="\$(MSW_GENERICOBJS)"
+    GENERICOBJS=MSW_GENERICOBJS
-    GUIDEPS="\$(MSW_GUIDEPS)"
+    GUIDEPS=MSW_GUIDEPS
-    COMMONDEPS="\$(MSW_COMMONDEPS)"
+    COMMONDEPS=MSW_COMMONDEPS
-    GENERICDEPS="\$(MSW_GENERICDEPS)"
+    GENERICDEPS=MSW_GENERICDEPS
-    UNIXOBJS="\$(UNIX_OBJS)"
+    UNIXOBJS=UNIXOBJS
     GUIDIST=MSW_DIST
 fi
 
@@ -1655,14 +1576,14 @@ if test "$wxUSE_MOTIF" = 1; then
     GUI_TK_LIBRARY="$GUI_TK_LIBRARY $GUI_TK_LINK"
     TOOLKIT=MOTIF
 
-    GUIHEADERS="\$(MOTIF_HEADERS)"
+    GUIHEADERS=MOTIF_HEADERS
-    GUIOBJS="\$(MOTIF_GUIOBJS)"
+    GUIOBJS=MOTIF_GUIOBJS
-    COMMONOBJS="\$(MOTIF_COMMONOBJS)"
+    COMMONOBJS=MOTIF_COMMONOBJS
-    GENERICOBJS="\$(MOTIF_GENERICOBJS)"
+    GENERICOBJS=MOTIF_GENERICOBJS
-    GUIDEPS="\$(MOTIF_GUIDEPS)"
+    GUIDEPS=MOTIF_GUIDEPS
-    COMMONDEPS="\$(MOTIF_COMMONDEPS)"
+    COMMONDEPS=MOTIF_COMMONDEPS
-    GENERICDEPS="\$(MOTIF_GENERICDEPS)"
+    GENERICDEPS=MOTIF_GENERICDEPS
-    UNIXOBJS="\$(UNIX_OBJS)"
+    UNIXOBJS=UNIXOBJS
     GUIDIST=MOTIF_DIST
 fi
 
@@ -1682,35 +1603,19 @@ 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="lib${WX_LIBRARY}.la"
+WX_LIBRARY_NAME="libwx_${TOOLKIT_DIR}.la"
 
 dnl the name of the static library
-WX_LIBRARY_NAME_STATIC="lib${WX_LIBRARY}.a"
+WX_LIBRARY_NAME_STATIC="libwx_${TOOLKIT_DIR}.a"
 
 dnl the name of the shared library
-WX_LIBRARY_NAME_SHARED="lib${WX_LIBRARY}-${WX_RELEASE}.so.${WX_CURRENT}.${WX_REVISION}.${WX_AGE}"
+WX_LIBRARY_NAME_SHARED="libwx_${TOOLKIT_DIR}-${WX_RELEASE}.so.${WX_CURRENT}.${WX_REVISION}.${WX_AGE}"
 
 dnl the name of the links to the shared library
-WX_LIBRARY_LINK1="lib${WX_LIBRARY}-${WX_RELEASE}.so.${WX_CURRENT}"
+WX_LIBRARY_LINK1="libwx_${TOOLKIT_DIR}-${WX_RELEASE}.so.${WX_CURRENT}"
-WX_LIBRARY_LINK2="lib${WX_LIBRARY}-${WX_RELEASE}.so"
+WX_LIBRARY_LINK2="libwx_${TOOLKIT_DIR}-${WX_RELEASE}.so"
-WX_LIBRARY_LINK3="lib${WX_LIBRARY}.so"
+WX_LIBRARY_LINK3="libwx_${TOOLKIT_DIR}.so"
 
 dnl shared library settings
 SHARED_LD=
@@ -1820,11 +1725,8 @@ dnl defines HAVE_WCSTR_H
 AC_CHECK_HEADERS(wcstr.h)
 dnl defines HAVE_FNMATCH_H
 AC_CHECK_HEADERS(fnmatch.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
@@ -1961,9 +1863,6 @@ 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)
@@ -2773,13 +2672,16 @@ 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"
+EXTRA_LIBS="$LIBS $POSIX4_LINK $WCHAR_LINK $THREADS_LINK $DMALLOC_LINK $GUILIBS"
-if test "$wxUSE_GUI" = "yes"; then
+
-    EXTRA_LIBS="$EXTRA_LIBS $GUILIBS"
+dnl all the libraries needed to link wxWindows programs (when the library is not
-fi
+dnl yet installed)
+LIBS="\${top_builddir}/src/${TOOLKIT_DIR}/${WX_LIBRARY_NAME} $EXTRA_LIBS"
 
 dnl all the libraries needed to link wxWindows programs when using the
 dnl makefile system without libtool
@@ -2792,8 +2694,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 FIXME: there is one weird warning in docview.h:71 which prevents me from
+    dnl there is one weird warning in docview.h:71 which prevents me from doing
-    dnl        doing this... (VZ)
+    dnl this...
     dnl CXXWARNINGS="-Wall -Werror"
 fi
 EXTRA_CFLAGS="$WXDEBUG $PROFILE $OPTIMISE $INCLUDES"
@@ -2810,8 +2712,6 @@ 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
@@ -2860,10 +2760,6 @@ 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

distrib/msw/tmake/filelist.txt

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

docs/html/roadmap.htm

@@ -116,7 +116,6 @@ 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>

docs/html/standard.htm

@@ -50,7 +50,6 @@ 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>
@@ -333,25 +332,6 @@ 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>

docs/latex/wx/dc.tex

@@ -418,9 +418,6 @@ 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}}

docs/latex/wx/listctrl.tex

@@ -376,10 +376,6 @@ 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}}

docs/latex/wx/log.tex

@@ -52,7 +52,6 @@ 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}
@@ -143,16 +142,6 @@ 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}

docs/latex/wx/topics.tex

@@ -9,7 +9,6 @@ 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

docs/latex/wx/wxPython.tex

@@ -365,11 +365,10 @@ 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}
@@ -402,14 +401,14 @@ as possible to the C++ spec over time.
 \item wxGridCell
 \item wxGridEvent
 \item \helpref{wxGrid}{wxgrid}
-\item \helpref{wxHtmlCell}{wxhtmlcell}
+\item \helpref{wxHtmlCell}{wxHtmlCell}
-\item \helpref{wxHtmlContainerCell}{wxhtmlcontainercell}
+\item \helpref{wxHtmlContainerCell}{wxHtmlContainerCell}
-\item \helpref{wxHtmlParser}{wxhtmlparser}
+\item \helpref{wxHtmlParser}{wxHtmlParser}
-\item \helpref{wxHtmlTagHandler}{wxhtmltaghandler}
+\item \helpref{wxHtmlTagHandler}{wxHtmlTagHandler}
-\item \helpref{wxHtmlTag}{wxhtmltag}
+\item \helpref{wxHtmlTag}{wxHtmlTag}
-\item \helpref{wxHtmlWinParser}{wxhtmlwinparser}
+\item \helpref{wxHtmlWinParser}{wxHtmlWinParser}
-\item \helpref{wxHtmlWinTagHandler}{wxhtmlwintaghandler}
+\item \helpref{wxHtmlWinTagHandler}{wxHtmlWinTagHandler}
-\item \helpref{wxHtmlWindow}{wxhtmlwindow}
+\item \helpref{wxHtmlWindow}{wxHtmlWindow}
 \item wxIconizeEvent
 \item \helpref{wxIcon}{wxicon}
 \item \helpref{wxIdleEvent}{wxidleevent}
@@ -481,7 +480,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}
@@ -489,7 +488,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}

include/wx/app.h

@@ -37,9 +37,7 @@
 
 #include "wx/event.h"       // for the base class
 
-#if wxUSE_GUI
 #include "wx/window.h"      // for wxTopLevelWindows
-#endif // wxUSE_GUI
 
 #if wxUSE_LOG
     #include "wx/log.h"
@@ -66,33 +64,22 @@ public:
         // prevents the program from continuing - it's a good place to create
         // the top level program window and return TRUE.
         //
-        // Override: always in GUI application, rarely in console ones.
+        // Override: always.
-#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. In console mode programs, the execution
+        // ExitMainLoop() is called.
-        // of the program really starts here
         //
-        // Override: rarely in GUI applications, always in console ones.
+        // Override: rarely.
-#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
@@ -115,7 +102,6 @@ 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;
 
@@ -132,7 +118,6 @@ 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
     // -------------------------------------------
@@ -159,7 +144,6 @@ public:
     const wxString& GetVendorName() const { return m_vendorName; }
     void SetVendorName(const wxString& name) { m_vendorName = name; }
 
-#if wxUSE_GUI
     // top level window functions
     // --------------------------
 
@@ -187,8 +171,6 @@ public:
     void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
     bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }
 
-#endif // wxUSE_GUI
-
     // miscellaneous customization functions
     // -------------------------------------
 
@@ -197,15 +179,10 @@ public:
         // user-defined class (default implementation creates a wxLogGui
         // object) - this log object is used by default by all wxLogXXX()
         // functions.
-    virtual wxLog *CreateLogTarget()
+    virtual wxLog *CreateLogTarget() { return new wxLogGui; }
-#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
@@ -221,7 +198,6 @@ public:
         // printing.
     virtual void SetPrintMode(int WXUNUSED(mode)) { }
     int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
-#endif // wxUSE_GUI
 
     // implementation only from now on
     // -------------------------------
@@ -252,17 +228,14 @@ 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 wxUSE_GUI
 #if defined(__WXMSW__)
     #include "wx/msw/app.h"
 #elif defined(__WXMOTIF__)
@@ -278,9 +251,6 @@ protected:
 #elif defined(__WXSTUBS__)
     #include "wx/stubs/app.h"
 #endif
-#else // !GUI
-    typedef wxAppBase wxApp;
-#endif // GUI/!GUI
 
 // ----------------------------------------------------------------------------
 // the global data
@@ -296,34 +266,11 @@ 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
-extern void WXDLLEXPORT wxExit();
+void WXDLLEXPORT wxExit();
 
 // Yield to other apps/messages
-extern bool WXDLLEXPORT wxYield();
+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

include/wx/arrimpl.cpp

@@ -20,9 +20,6 @@
  *          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
@@ -61,7 +58,7 @@ void name::Empty()                                                            \
                                                                               \
 void name::Remove(size_t uiIndex)                                             \
 {                                                                             \
-  wxCHECK_RET( uiIndex < Count(), _WX_ERROR_REMOVE2(name) );                  \
+  wxCHECK_RET( uiIndex < Count(), _T("bad index in " #name "::Remove()") );   \
                                                                               \
   delete (T*)wxBaseArray::Item(uiIndex);                                      \
                                                                               \

include/wx/buffer.h

@@ -15,7 +15,6 @@
 #define _WX_BUFFER_H
 
 #include "wx/wxchar.h"
-
 #include <string.h> // strdup
 
 // ----------------------------------------------------------------------------
@@ -28,7 +27,7 @@ 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;
     }
@@ -67,7 +66,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);
@@ -112,12 +111,12 @@ private:
 #define wxWX2MBbuf wxCharBuffer
 #define wxWC2WXbuf wxChar*
 #define wxWX2WCbuf wxChar*
-#else // ANSI
+#else
 #define wxMB2WXbuf wxChar*
 #define wxWX2MBbuf wxChar*
 #define wxWC2WXbuf wxCharBuffer
 #define wxWX2WCbuf wxWCharBuffer
-#endif // Unicode/ANSI
+#endif
 
 // ----------------------------------------------------------------------------
 // template class for any kind of data

include/wx/debug.h

@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/debug.h
+// Name:        debug.h
 // Purpose:     Misc debug functions and macros
 // Author:      Vadim Zeitlin
 // Modified by:
@@ -16,6 +16,11 @@
 
 #include  "wx/wxchar.h"
 
+#ifndef __TFILE__
+#define __XFILE__(x) _T(x)
+#define __TFILE__ __XFILE__(__FILE__)
+#endif
+
 // ----------------------------------------------------------------------------
 /** 
   @name Debugging macros 

include/wx/defs.h

@@ -115,11 +115,13 @@
 #   pragma suppress 571             // Virtual function hiding
 #endif // __SALFORDC__
 
-#if defined(__VISUALC__) && !defined(WIN32)
+#ifdef __VISUALC__
+#ifndef WIN32
 // VC1.5 does not have LPTSTR type
 #define LPTSTR LPSTR
 #define LPCTSTR LPCSTR
-#endif // VC++ 1.5
+#endif
+#endif
 
 // Digital Unix C++ compiler only defines this symbol for .cxx and .hxx files,
 // so define it ourselves
@@ -188,9 +190,8 @@
 // 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__) && \
+#elif !defined(__WXMOTIF__) && !defined(__WXMSW__) && !defined(__WXGTK__) && !defined(__WXPM__) && \
-      !defined(__WXPM__) && !defined(__WXMAC__) && !defined(__X__) && \
+      !defined(__WXMAC__) && !defined(__X__) && !defined(__WXQT__) && !defined(__WXSTUBS__)
-      !defined(__WXQT__) && !defined(__WXSTUBS__) && wxUSE_GUI
     #error "No Target! Use -D[__WXMOTIF__|__WXGTK__|__WXMSW__|__WXMAC__|__WXQT__|__WXPM__|__WXSTUBS__]"
 #endif
 
@@ -214,17 +215,6 @@
 
 #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
 // ============================================================================
@@ -233,14 +223,21 @@
 // check for native bool type and TRUE/FALSE constants
 // ----------------------------------------------------------------------------
 
-// define boolean constants if not done yet
+#if defined(__WXMOTIF__) || defined(__WXGTK__) || defined(__WXQT__) || defined(__WXPM__) || defined(__WXSTUBS__)
+    // Bool is now obsolete, use bool instead
+    // typedef int Bool;
+
     #ifndef TRUE
         #define TRUE  1
+        #define FALSE 0
+        #define Bool_DEFINED
     #endif
-
+#elif defined(__WXMSW__)
-#ifndef FALSE
+    #ifndef TRUE
+        #define TRUE  1
         #define FALSE 0
     #endif
+#endif // TRUE/FALSE
 
 // Add more tests here for Windows compilers that already define bool
 // (under Unix, configure tests for this)

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 IsDialing() const = 0;
+    virtual bool IsDialling() 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"),
+    SetConnectCommand(const wxString& commandDial = _T("/usr/bin/pon"),
-                      const wxString& commandHangup = T("/usr/bin/poff")) = 0;
+                      const wxString& commandHangup = _T("/usr/bin/poff")) = 0;
 };
 
 // ----------------------------------------------------------------------------

include/wx/dynarray.h

@@ -151,11 +151,6 @@ 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)
@@ -175,7 +170,7 @@ public:                                                             \
     size_t type = sizeof(T);                                        \
     size_t sizelong = sizeof(long);                                 \
     if ( type > sizelong )                                          \
-      { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
+      { wxFAIL_MSG( _T("illegal use of DEFINE_ARRAY") ); }          \
   }                                                                 \
                                                                     \
   name& operator=(const name& src)                                  \
@@ -202,7 +197,7 @@ public:                                                             \
   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
-         _WX_ERROR_REMOVE);                                         \
+        _T("removing inexisting element in wxArray::Remove") );     \
       wxBaseArray::Remove((size_t)iIndex); }                        \
                                                                     \
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
@@ -237,7 +232,7 @@ public:                                                             \
   { size_t type = sizeof(T);                                        \
     size_t sizelong = sizeof(long);                                 \
     if ( type > sizelong )                                          \
-      { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
+      { wxFAIL_MSG( _T("illegal use of DEFINE_ARRAY") ); }          \
     m_fnCompare = fn;                                               \
   }                                                                 \
                                                                     \
@@ -264,7 +259,7 @@ public:                                                             \
   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
-        _WX_ERROR_REMOVE );                                         \
+        _T("removing inexisting element in wxArray::Remove") );     \
       wxBaseArray::Remove((size_t)iIndex); }                        \
                                                                     \
 private:                                                            \

include/wx/event.h

@@ -18,31 +18,16 @@
 
 #include "wx/defs.h"
 #include "wx/object.h"
-
-#if wxUSE_GUI
 #include "wx/gdicmn.h"
-#endif
 
 #if wxUSE_THREADS
     #include "wx/thread.h"
 #endif
 
-// ----------------------------------------------------------------------------
+/*
-// forward declarations
+ * Event types
-// ----------------------------------------------------------------------------
+ *
-
+ */
-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;
 
@@ -351,8 +336,6 @@ public:
     bool              m_isCommandEvent;
 };
 
-#if wxUSE_GUI
-
 // Item or menu event class
 /*
  wxEVT_COMMAND_BUTTON_CLICKED
@@ -371,6 +354,8 @@ public:
  wxEVT_COMMAND_COMBOBOX_SELECTED
 */
 
+class WXDLLEXPORT wxClientData;
+
 class WXDLLEXPORT wxCommandEvent : public wxEvent
 {
     DECLARE_DYNAMIC_CLASS(wxCommandEvent)
@@ -538,6 +523,7 @@ public:
  wxEVT_NC_RIGHT_DCLICK,
 */
 
+class WXDLLEXPORT wxDC;
 class WXDLLEXPORT wxMouseEvent : public wxEvent
 {
     DECLARE_DYNAMIC_CLASS(wxMouseEvent)
@@ -778,6 +764,7 @@ public:
  wxEVT_ERASE_BACKGROUND
  */
 
+class WXDLLEXPORT wxDC;
 class WXDLLEXPORT wxEraseEvent : public wxEvent
 {
     DECLARE_DYNAMIC_CLASS(wxEraseEvent)
@@ -897,7 +884,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;
     }
@@ -1082,11 +1069,36 @@ 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)
@@ -1244,30 +1256,6 @@ 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,
@@ -1279,6 +1267,11 @@ protected:
  wxEVT_COMPARE_ITEM
 */
 
+class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxControl;
+
+// struct WXDLLEXPORT wxEventTableEntry;
+
 typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
 
 struct WXDLLEXPORT wxEventTableEntry
@@ -1319,7 +1312,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
@@ -1380,7 +1373,6 @@ protected:
 };
 
 typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
-#if wxUSE_GUI
 typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
 typedef void (wxEvtHandler::*wxScrollEventFunction)(wxScrollEvent&);
 typedef void (wxEvtHandler::*wxScrollWinEventFunction)(wxScrollWinEvent&);
@@ -1406,7 +1398,6 @@ 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...
@@ -1612,17 +1603,13 @@ 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__

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; }

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& vendorName = _T(""),
-               const wxString& localFilename = T(""),
+               const wxString& localFilename = _T(""),
-               const wxString& globalFilename = T(""),
+               const wxString& globalFilename = _T(""),
                long style = wxCONFIG_USE_LOCAL_FILE);
 
     // dtor will save unsaved data

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_EXT        _T('.')
-#define wxFILE_SEP_DSK        T(':')
+#define wxFILE_SEP_DSK        _T(':')
-#define wxFILE_SEP_PATH_DOS   T('\\')
+#define wxFILE_SEP_PATH_DOS   _T('\\')
-#define wxFILE_SEP_PATH_UNIX  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_DOS        _T(";")
-#define wxPATH_SEP_UNIX       T(":")
+#define wxPATH_SEP_UNIX       _T(":")
 
 // platform independent versions
 #ifdef  __UNIX__

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

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();

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

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;

include/wx/gtk/mdi.h

@@ -121,12 +121,8 @@ class wxMDIChildFrame: public wxFrame
     
 #if wxUSE_STATUSBAR
     // no status bars
-  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number) = 1,
+  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number)=1, long WXUNUSED(style)=1, 
-                                        long WXUNUSED(style) = 1, 
+    wxWindowID WXUNUSED(id)=1, const wxString& WXUNUSED(name)=WXSTRINGCAST NULL ) {return (wxStatusBar*)NULL; }
-                                        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)[] ) {}

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;

include/wx/gtk1/mdi.h

@@ -121,12 +121,8 @@ class wxMDIChildFrame: public wxFrame
     
 #if wxUSE_STATUSBAR
     // no status bars
-  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number) = 1,
+  virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number)=1, long WXUNUSED(style)=1, 
-                                        long WXUNUSED(style) = 1, 
+    wxWindowID WXUNUSED(id)=1, const wxString& WXUNUSED(name)=WXSTRINGCAST NULL ) {return (wxStatusBar*)NULL; }
-                                        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)[] ) {}

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
 
 // ----------------------------------------------------------------------------

include/wx/ipcbase.h

@@ -53,8 +53,8 @@ class WXDLLEXPORT wxConnectionBase: public wxObject
   inline ~wxConnectionBase(void) {}
 
   // Calls that CLIENT can make
-  virtual bool Execute(const wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT ) = 0;
+  virtual bool Execute(wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT ) = 0;
-  virtual bool Execute(const wxString& str) { return Execute(str, -1, wxIPC_TEXT); }
+  virtual bool Execute(const wxString& str) { return Execute(WXSTRINGCAST 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;

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)
 
-#if wxUSE_GUI
+#ifndef wxUSE_NOGUI
 
 // 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_GUI
+#endif // wxUSE_NOGUI
 
 // ----------------------------------------------------------------------------
 // /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) Tx)
+    #define __XFILE__(x) _T(x)
     #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))

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 */

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; }

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)

include/wx/msw/dde.h

@@ -54,8 +54,8 @@ public:
   ~wxDDEConnection(void);
 
   // Calls that CLIENT can make
-  virtual bool Execute(const wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT);
+  virtual bool Execute(wxChar *data, int size = -1, wxIPCFormat format = wxIPC_TEXT);
-  virtual bool Execute(const wxString& str) { return Execute(str, -1, wxIPC_TEXT); }
+  virtual bool Execute(const wxString& str) { return Execute(WXSTRINGCAST 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);

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)
 
 /*

include/wx/msw/setup0.h

@@ -12,12 +12,13 @@
 #ifndef _WX_SETUP_H_
 #define _WX_SETUP_H_
 
-// ----------------------------------------------------------------------------
+/*
-// global settings
+ * General features
-// ----------------------------------------------------------------------------
+ *
+ */
 
-// define this to 0 when building wxBase library
+#define wxUSE_CONFIG           1
-#define wxUSE_GUI            1
+                                // Use wxConfig, with CreateConfig in wxApp
 
 #define WXWIN_COMPATIBILITY  0
                                 // Compatibility with 1.68 API.
@@ -26,13 +27,6 @@
                                 // 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

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), \
+ wxClassInfo name::sm_class##name((wxChar *) _T(#name), (wxChar *) _T(#basename1), \
-         (wxChar *) T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL);
+         (wxChar *) _T(#basename2), (int) sizeof(name), (wxObjectConstructorFn) NULL);
 
 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2

include/wx/os2/dc.h

@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dc.h
 // Purpose:     wxDC class
-// Author:      David Webster
+// Author:      AUTHOR
 // Modified by:
-// Created:     08/26/99
+// Created:     ??/??/98
 // RCS-ID:      $Id$
-// Copyright:   (c) David Webster
+// Copyright:   (c) AUTHOR
 // Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

include/wx/os2/dcclient.h

@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dcclient.h
 // Purpose:     wxClientDC class
-// Author:      David Webster
+// Author:      Julian Smart
 // Modified by:
-// Created:     09/12/99
+// Created:     01/02/97
 // RCS-ID:      $Id$
-// Copyright:   (c) David Webster
+// Copyright:   (c) Julian Smart and Markus Holzem
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
@@ -16,6 +16,10 @@
 // headers
 // ----------------------------------------------------------------------------
 
+#ifdef __GNUG__
+    #pragma interface "dcclient.h"
+#endif
+
 #include "wx/dc.h"
 #include "wx/dynarray.h"
 

include/wx/os2/dcmemory.h

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

include/wx/os2/dcprint.h

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

include/wx/os2/dialog.h

@@ -74,34 +74,31 @@ public:
 // ---------------------------------------------------------------------------
 
     virtual bool Destroy();
-    virtual void DoSetClientSize(int width, int height);
+    virtual bool IsIconized() const;
-    virtual void GetPosition(int *x, int *y) 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);
-    bool IsShown() const;
     void     Iconize(bool iconize);
 
-    virtual bool IsIconized() const;
     void     Fit();
 
     void     SetTitle(const wxString& title);
     wxString GetTitle() const ;
 
-    void OnSize(wxSizeEvent& event);
-    bool OnClose();
     void     OnCharHook(wxKeyEvent& event);
-    void OnPaint(wxPaintEvent& event);
     void     OnCloseWindow(wxCloseEvent& event);
 
     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);
     void     OnApply(wxCommandEvent& event);
@@ -110,32 +107,6 @@ 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()
 };
 

include/wx/os2/filedlg.h

@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        filedlg.h
 // Purpose:     wxFileDialog class
-// Author:      David Webster
+// Author:      AUTHOR
 // Modified by:
-// Created:     10/05/99
+// Created:     ??/??/98
 // RCS-ID:      $Id$
-// Copyright:   (c) David Webster
+// Copyright:   (c) AUTHOR
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -28,6 +28,15 @@ 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,
@@ -50,16 +59,6 @@ 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
@@ -69,42 +68,22 @@ protected:
 #define wxFILE_MUST_EXIST   0x0010
 
 // File selector - backward compatibility
-WXDLLEXPORT wxString wxFileSelector( const char *message = wxFileSelectorPromptStr
+WXDLLEXPORT wxString wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
-                                    ,const char *default_path = NULL
+                     const char *default_filename = NULL, const char *default_extension = NULL,
-                                    ,const char *default_filename = NULL
+                     const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
-                                    ,const char *default_extension = NULL
+                     wxWindow *parent = NULL, int x = -1, int y = -1);
-                                    ,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
+WXDLLEXPORT wxString wxFileSelectorEx(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
-                                      ,const char *default_path = NULL
+                     const char *default_filename = NULL, int *indexDefaultExtension = NULL,
-                                      ,const char *default_filename = NULL
+                     const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
-                                      ,int *indexDefaultExtension = NULL
+                     wxWindow *parent = NULL, int x = -1, int y = -1);
-                                      ,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
+WXDLLEXPORT wxString wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
-                                        ,const char *extension
-                                        ,const char *default_name = NULL
-                                        ,wxWindow *parent = NULL
-                                       );
 
 // Generic file save dialog
-WXDLLEXPORT wxString wxSaveFileSelector( const char *what
+WXDLLEXPORT wxString wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
-                                        ,const char *extension
-                                        ,const char *default_name = NULL
-                                        ,wxWindow *parent = NULL
-                                       );
 
 #endif
     // _WX_FILEDLG_H_

include/wx/os2/setup.h

@@ -1,34 +1,21 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        setup.h
 // Purpose:     Configuration for the library
-// Author:      David Webster
+// Author:      Julian Smart
 // Modified by:
-// Created:     04/02/99
+// Created:     01/02/97
 // RCS-ID:      $Id$
-// Copyright:   (c) David Webster
+// Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_SETUP_H_
 #define _WX_SETUP_H_
 
-// ----------------------------------------------------------------------------
+/*
-// global settings
+ * General features
-// ----------------------------------------------------------------------------
+ *
-
+ */
-// 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

include/wx/os2/setup0.h

@@ -12,23 +12,10 @@
 #ifndef _WX_SETUP_H_
 #define _WX_SETUP_H_
 
-// ----------------------------------------------------------------------------
+/*
-// global settings
+ * General features
-// ----------------------------------------------------------------------------
+ *
-
+ */
-// 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

include/wx/os2/window.h

@@ -272,9 +272,6 @@ 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

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);

include/wx/sckipc.h

@@ -73,7 +73,7 @@ public:
   virtual ~wxTCPConnection();
 
   // Calls that CLIENT can make
-  bool Execute(const wxChar *data, int size = -1,
+  bool Execute(wxChar *data, int size = -1,
                wxIPCFormat format = wxIPC_TEXT);
   char *Request(const wxString& item, int *size = NULL,
                 wxIPCFormat format = wxIPC_TEXT);

include/wx/strconv.h

@@ -24,13 +24,14 @@
 
 #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;
@@ -38,25 +39,24 @@ public:
   // 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 // ANSI
+#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 // Unicode/ANSI
+#endif
 };
 
 WXDLLEXPORT_DATA(extern wxMBConv) wxConvLibc;
 
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 // wxMBConvFile (for conversion to filenames)
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 
 class WXDLLEXPORT wxMBConvFile: public wxMBConv 
 {
@@ -67,9 +67,9 @@ public:
 
 WXDLLEXPORT_DATA(extern wxMBConvFile) wxConvFile;
 
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 // wxMBConvUTF7 (for conversion using UTF7 encoding)
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 
 class WXDLLEXPORT wxMBConvUTF7: public wxMBConv 
 {
@@ -80,9 +80,9 @@ public:
 
 WXDLLEXPORT_DATA(extern wxMBConvUTF7) wxConvUTF7;
 
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 // wxMBConvUTF8 (for conversion using UTF8 encoding)
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 
 class WXDLLEXPORT wxMBConvUTF8: public wxMBConv 
 {
@@ -94,10 +94,9 @@ public:
 WXDLLEXPORT_DATA(extern wxMBConvUTF8) wxConvUTF8;
 
 #ifdef __WXGTK12__
-
+//---------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
 // wxMBConvUTF8 (for conversion using GDK's internal converions)
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 
 class WXDLLEXPORT wxMBConvGdk: public wxMBConv
 {
@@ -107,40 +106,39 @@ public:
 };
 
 WXDLLEXPORT_DATA(extern wxMBConvGdk) wxConvGdk;
+#endif
 
-#endif // wxGTK 1.2
+//---------------------------------------------------------------------------
+// wxCSConv (for conversion based on laodable char sets)
+//---------------------------------------------------------------------------
 
-// ----------------------------------------------------------------------------
+class wxCharacterSet;
-// wxCSConv (for conversion based on loadable char sets)
-// ----------------------------------------------------------------------------
-
-class WXDLLEXPORT wxCharacterSet;
 
 class WXDLLEXPORT wxCSConv: public wxMBConv
 {
-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;
-
 private:
-    void SetName(const wxChar *charset);
-
   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;
 };
 
 WXDLLEXPORT_DATA(extern wxCSConv) wxConvLocal;
-WXDLLEXPORT_DATA(extern wxMBConv *) wxConvCurrent;
+#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__)
@@ -151,18 +149,18 @@ WXDLLEXPORT_DATA(extern wxMBConv *) wxConvCurrent;
 
 #if wxMBFILES
 #define wxFNCONV(name) wxConvFile.cWX2MB(name)
-    #define wxFNSTRINGCAST wxMBSTRINGCAST
+#define FNSTRINGCAST MBSTRINGCAST
 #else
 #define wxFNCONV(name) name
-    #define wxFNSTRINGCAST WXSTRINGCAST
+#define FNSTRINGCAST WXSTRINGCAST
 #endif
 
 #else
   // !wxUSE_WCHAR_T
 
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 // stand-ins in absence of wchar_t
-// ----------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 
 class WXDLLEXPORT wxMBConv 
 {
@@ -170,29 +168,15 @@ public:
   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 wxFNSTRINGCAST WXSTRINGCAST
+#define FNSTRINGCAST WXSTRINGCAST
 
 #endif
   // wxUSE_WCHAR_T
 
-// ----------------------------------------------------------------------------
-// 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__
 

include/wx/string.h

@@ -9,12 +9,6 @@
 // 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__
 
@@ -22,22 +16,6 @@
 #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
@@ -56,53 +34,57 @@
     #include <strings.h>    // for strcasecmp()
 #endif // AIX
 
-#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
+  #include "wx/defs.h"
+
   #ifdef    WXSTRING_IS_WXOBJECT
-    #include "wx/object.h" // base class
+    #include "wx/object.h"
   #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   WXCSTRINGCAST (wxChar *)(const wxChar *)
-#define   wxMBSTRINGCAST (char *)(const char *)
+#define   MBSTRINGCAST (char *)(const char *)
-#define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
+#define   WCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only
 #define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )
 
-// ----------------------------------------------------------------------------
+// include conversion classes
-// constants
+#include "wx/strconv.h"
-// ----------------------------------------------------------------------------
-
-// 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); }
@@ -156,15 +138,23 @@ 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 *)&wxEmptyString; }
+inline const wxString& wxGetEmptyString() { return *(wxString *)&g_szNul; }
 
 // ---------------------------------------------------------------------------
 // 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
@@ -235,7 +225,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 *)wxEmptyString; }
+  void Init() { m_pchData = (wxChar *)g_szNul; }
     // 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
@@ -288,7 +278,6 @@ 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
@@ -297,24 +286,21 @@ public:
     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz)
     { InitWith(psz, 0, wxSTRING_MAXLEN); }
-#else // ANSI
+#else
     // 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 // !wxUSE_WCHAR_T
+#endif
-
     // from wxCharBuffer
   wxString(const wxCharBuffer& psz)
     { InitWith(psz, 0, wxSTRING_MAXLEN); }
-#endif // Unicode/ANSI
+#endif
-
     // dtor is not virtual, this class must not be inherited from!
  ~wxString() { GetStringData()->Unlock(); }
 
@@ -392,36 +378,25 @@ 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 // !wxMBFILES
+#else
     const wxChar* fn_str() const { return m_pchData; }
-#endif // wxMBFILES/!wxMBFILES
+#endif
-#else // ANSI
+#else
-#if wxUSE_MULTIBYTE
+    const wxChar* mb_str(wxMBConv& WXUNUSED(conv) = wxConvLibc ) const { return m_pchData; }
-    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 // wxUSE_WCHAR_T
+#endif
     const wxChar* fn_str() const { return m_pchData; }
-#endif // Unicode/ANSI
+#endif
+    // for convenience
+    const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
   // overloaded assignment
     // from another wxString
@@ -433,7 +408,7 @@ public:
 #if wxUSE_UNICODE
     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); }
-#else // ANSI
+#else
     // from another kind of C string
   wxString& operator=(const unsigned char* psz);
 #if wxUSE_WCHAR_T
@@ -442,7 +417,7 @@ public:
 #endif
     // from wxCharBuffer
   wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); }
-#endif // Unicode/ANSI
+#endif
 
   // string concatenation
     // in place concatenation
@@ -573,7 +548,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);
 
@@ -685,7 +660,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
@@ -860,7 +835,6 @@ 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:
@@ -1019,9 +993,6 @@ inline wxString WXDLLEXPORT operator+(const wxCharBuffer& buf, const wxString& s
 // 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"

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();
+WXDLLEXPORT void wxBell(void) ;
 
 // Get OS version
 WXDLLEXPORT int wxGetOsVersion(int *majorVsn= (int *) NULL,int *minorVsn= (int *) NULL) ;
@@ -82,7 +82,6 @@ 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.
@@ -107,8 +106,6 @@ WXDLLEXPORT void wxRegisterId(long id);
 // Return the current ID
 WXDLLEXPORT long wxGetCurrentId();
 
-#endif // wxUSE_GUI
-
 // ----------------------------------------------------------------------------
 // Various conversions
 // ----------------------------------------------------------------------------
@@ -218,8 +215,6 @@ 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
 // ----------------------------------------------------------------------------
@@ -393,7 +388,5 @@ extern wxNativeFont wxLoadQueryNearestFont(int pointSize,
 
 #endif // X || GTK
 
-#endif // wxUSE_GUI
-
 #endif
     // _WX_UTILSH__

include/wx/variant.h

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

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);

include/wx/wx.h

@@ -12,20 +12,10 @@
 #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"
@@ -36,6 +26,8 @@
 #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"
@@ -44,6 +36,7 @@
 #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"
@@ -74,6 +67,10 @@
 #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
@@ -83,7 +80,5 @@
     #include "wx/serbase.h"
 #endif // wxUSE_SERIAL
 
-#endif // wxUSE_GUI
-
 #endif
     // _WX_WXH__

include/wx/wxchar.h

@@ -47,9 +47,6 @@
 #  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;
@@ -233,7 +230,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
@@ -303,9 +300,9 @@ typedef unsigned __WCHAR_TYPE__ wxUChar;
 #    endif
 
 #    ifdef __FreeBSD__
-#     undef T
+#      undef _T
 #    endif
-#   define T(x)           x
+#    define _T(x)           x
 
      // ctype.h functions
 #    define  wxIsalnum   isalnum
@@ -329,11 +326,7 @@ typedef unsigned __WCHAR_TYPE__ wxUChar;
      // #define  wxStricmp   strcasecmp
      // wxStricmp is defined below!!
 
-    #ifdef HAVE_STRTOK_R
+     // #define  wxStrtok    strtok_r // this needs a configure check
-        #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
@@ -564,12 +557,6 @@ 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_
 

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)

samples/dnd/dnd.cpp

@@ -295,11 +295,11 @@ void DnDFrame::OnClipboardHasText(wxCommandEvent& WXUNUSED(event))
 
     if ( !wxTheClipboard->IsSupported( wxDF_TEXT ) )
     {
-        wxLogMessage( _T("No text on the clipboard") );
+        wxLogMessage( _T("No text is on the clipboard") );
     }
     else
     {
-        wxLogMessage( _T("There is text on the clipboard") );
+        wxLogMessage( _T("There is text is on the clipboard") );
     }
 
     wxTheClipboard->Close();
@@ -316,11 +316,11 @@ void DnDFrame::OnClipboardHasBitmap(wxCommandEvent& WXUNUSED(event))
 
     if ( !wxTheClipboard->IsSupported( wxDF_BITMAP ) )
     {
-        wxLogMessage( _T("No bitmap on the clipboard") );
+        wxLogMessage( _T("No bitmap is on the clipboard") );
     }
     else
     {
-        wxLogMessage( _T("There is a bitmap on the clipboard") );
+        wxLogMessage( _T("A bitmap is on the clipboard") );
     }
 
     wxTheClipboard->Close();
@@ -435,12 +435,7 @@ 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)
     { 
@@ -461,13 +456,7 @@ void DnDFrame::OnCopyBitmap(wxCommandEvent& WXUNUSED(event))
     }
     
     wxImage image;
-    image.LoadFile( dialog.GetPath(), 
+    image.LoadFile( dialog.GetPath(), wxBITMAP_TYPE_PNG );
-#ifdef __WXMSW__
-                    wxBITMAP_TYPE_BMP
-#else
-                    wxBITMAP_TYPE_PNG
-#endif
-                  );
     if (!image.Ok())
     {
         wxLogMessage( _T("Invalid image file...") );

samples/nettest/nettest.cpp

@@ -35,7 +35,7 @@
     #include "wx/wx.h"
 #endif
 
-#include "wx/dialup.h"
+#include "wx/net.h"
 
 // ----------------------------------------------------------------------------
 // private classes
@@ -208,6 +208,9 @@ 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;
 

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++ )
     {

setup.h.in

@@ -131,11 +131,11 @@
 /*
  * Use GUI
  */
-#define wxUSE_GUI 0
+#define wxUSE_GUI 1
 /*
- * Don't use GUI (defined to 1 when compiling/using base only)
+ * Defined if !wxUSE_GUI
  */
-#define wxUSE_NOGUI 0
+#undef wxUSE_NOGUI
 
 /*
  * Use constraints mechanism
@@ -367,20 +367,10 @@
 #define wxUSE_POSTSCRIPT 0
 
 /*
- * Compile wxString with some Unicode support?
+ * Compile wxString with wide character (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.
  *
@@ -654,9 +644,6 @@
 /* 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
 

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);
 }

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_FINDRESFAILURE: msg = _T("CDERR_FINDRESFAILURE"); break;
-        case CDERR_INITIALIZATION: msg = T("CDERR_INITIALIZATION"); break;
+        case CDERR_INITIALIZATION: msg = _T("CDERR_INITIALIZATION"); break;
-        case CDERR_LOADRESFAILURE: msg = T("CDERR_LOADRESFAILURE"); break;
+        case CDERR_LOADRESFAILURE: msg = _T("CDERR_LOADRESFAILURE"); break;
-        case CDERR_LOADSTRFAILURE: msg = T("CDERR_LOADSTRFAILURE"); break;
+        case CDERR_LOADSTRFAILURE: msg = _T("CDERR_LOADSTRFAILURE"); break;
-        case CDERR_LOCKRESFAILURE: msg = T("CDERR_LOCKRESFAILURE"); break;
+        case CDERR_LOCKRESFAILURE: msg = _T("CDERR_LOCKRESFAILURE"); break;
-        case CDERR_MEMALLOCFAILURE: msg = T("CDERR_MEMALLOCFAILURE"); break;
+        case CDERR_MEMALLOCFAILURE: msg = _T("CDERR_MEMALLOCFAILURE"); break;
-        case CDERR_MEMLOCKFAILURE: msg = T("CDERR_MEMLOCKFAILURE"); break;
+        case CDERR_MEMLOCKFAILURE: msg = _T("CDERR_MEMLOCKFAILURE"); break;
-        case CDERR_NOHINSTANCE: msg = T("CDERR_NOHINSTANCE"); break;
+        case CDERR_NOHINSTANCE: msg = _T("CDERR_NOHINSTANCE"); break;
-        case CDERR_NOHOOK: msg = T("CDERR_NOHOOK"); break;
+        case CDERR_NOHOOK: msg = _T("CDERR_NOHOOK"); break;
-        case CDERR_NOTEMPLATE: msg = T("CDERR_NOTEMPLATE"); break;
+        case CDERR_NOTEMPLATE: msg = _T("CDERR_NOTEMPLATE"); break;
-        case CDERR_STRUCTSIZE: msg = T("CDERR_STRUCTSIZE"); break;
+        case CDERR_STRUCTSIZE: msg = _T("CDERR_STRUCTSIZE"); break;
-        case  PDERR_RETDEFFAILURE: msg = T("PDERR_RETDEFFAILURE"); break;
+        case  PDERR_RETDEFFAILURE: msg = _T("PDERR_RETDEFFAILURE"); break;
-        case  PDERR_PRINTERNOTFOUND: msg = T("PDERR_PRINTERNOTFOUND"); break;
+        case  PDERR_PRINTERNOTFOUND: msg = _T("PDERR_PRINTERNOTFOUND"); break;
-        case  PDERR_PARSEFAILURE: msg = T("PDERR_PARSEFAILURE"); break;
+        case  PDERR_PARSEFAILURE: msg = _T("PDERR_PARSEFAILURE"); break;
-        case  PDERR_NODEVICES: msg = T("PDERR_NODEVICES"); break;
+        case  PDERR_NODEVICES: msg = _T("PDERR_NODEVICES"); break;
-        case  PDERR_NODEFAULTPRN: msg = T("PDERR_NODEFAULTPRN"); break;
+        case  PDERR_NODEFAULTPRN: msg = _T("PDERR_NODEFAULTPRN"); break;
-        case  PDERR_LOADDRVFAILURE: msg = T("PDERR_LOADDRVFAILURE"); break;
+        case  PDERR_LOADDRVFAILURE: msg = _T("PDERR_LOADDRVFAILURE"); break;
-        case  PDERR_INITFAILURE: msg = T("PDERR_INITFAILURE"); break;
+        case  PDERR_INITFAILURE: msg = _T("PDERR_INITFAILURE"); break;
-        case  PDERR_GETDEVMODEFAIL: msg = T("PDERR_GETDEVMODEFAIL"); break;
+        case  PDERR_GETDEVMODEFAIL: msg = _T("PDERR_GETDEVMODEFAIL"); break;
-        case  PDERR_DNDMMISMATCH: msg = T("PDERR_DNDMMISMATCH"); break;
+        case  PDERR_DNDMMISMATCH: msg = _T("PDERR_DNDMMISMATCH"); break;
-        case  PDERR_DEFAULTDIFFERENT: msg = T("PDERR_DEFAULTDIFFERENT("); break;
+        case  PDERR_DEFAULTDIFFERENT: msg = _T("PDERR_DEFAULTDIFFERENT"); break;
-        case  PDERR_CREATEICFAILURE: msg = T("PDERR_CREATEICFAILURE"); 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());

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 ( *pc == _T('\0') || *pc == wxCONFIG_PATH_SEPARATOR ) {
-      if ( strCurrent == T(".") ) {
+      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

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;

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("Sunday"), _T("Monday"), _T("Tuesday"), _T("Wednesday"),
-    T("Thursday"), T("Friday"), T("Saturday")
+    _T("Thursday"), _T("Friday"), _T("Saturday")
 };
 
 static const wxChar *mname[] = {
-    T("January"), T("February"), T("March"), T("April"), T("May"), T("June"),
+    _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("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, dat);
+        wxStrcpy(buf, WXSTRINGCAST 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));
+        day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
-        year  = 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, dat);
+        wxStrcpy(buf, WXSTRINGCAST 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));
+        day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
-        year  = 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(" "));
+            wxStrcat( buf, _T(" "));
-            wxSprintf( buf+wxStrlen(buf), T("%d, %d"), day, abs(year) );
+            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 )

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)
 		{

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
 	    {

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);
 }
 

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(""));
+    wxString path2(_T(""));
-    if (path != 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] = (wxChar *)templates[i]->m_description.c_str();
+            strings[n] = WXSTRINGCAST templates[i]->m_description;
             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] = (wxChar *)templates[i]->m_viewTypeName.c_str();
+            strings[n] = WXSTRINGCAST templates[i]->m_viewTypeName;
             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(title)
+             : wxPrintout(WXSTRINGCAST 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]));
     }
 }

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);
 }

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());

src/common/event.cpp

@@ -22,28 +22,18 @@
 
 #ifndef WX_PRECOMP
     #include "wx/defs.h"
-    #include "wx/app.h"
-    #include "wx/list.h"
-
-    #if wxUSE_GUI
     #include "wx/control.h"
     #include "wx/utils.h"
+    #include "wx/app.h"
     #include "wx/dc.h"
-    #endif // wxUSE_GUI
 #endif
 
 #include "wx/event.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(wxIdleEvent, wxEvent)
-
-    #if wxUSE_GUI
     IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
@@ -65,13 +55,13 @@
     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)
-    #endif // wxUSE_GUI
 
     const wxEventTable *wxEvtHandler::GetEventTable() const
         { return &wxEvtHandler::sm_eventTable; }
@@ -124,8 +114,6 @@ void wxEvent::CopyObject(wxObject& object_dest) const
     obj->m_isCommandEvent = m_isCommandEvent;
 }
 
-#if wxUSE_GUI
-
 /*
  * Command events
  *
@@ -243,7 +231,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;
@@ -264,7 +252,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;
@@ -284,7 +272,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;
@@ -303,7 +291,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;
@@ -321,7 +309,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;
@@ -452,6 +440,14 @@ void wxDropFilesEvent::CopyObject(wxObject& obj_d) const
     // 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;
+}
+
 void wxUpdateUIEvent::CopyObject(wxObject &obj_d) const
 {
     wxUpdateUIEvent *obj = (wxUpdateUIEvent *)&obj_d;
@@ -493,16 +489,6 @@ 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
  */
@@ -606,10 +592,8 @@ 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() )
@@ -628,7 +612,7 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
 
         const wxEventTable *table = GetEventTable();
 
-#if wxUSE_GUI && wxUSE_VALIDATORS
+#if 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.
@@ -670,7 +654,6 @@ 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
@@ -681,7 +664,6 @@ 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) )
@@ -753,7 +735,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();
 
@@ -797,8 +779,6 @@ 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)
@@ -822,4 +802,3 @@ wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
     return focusWin;
 }
 
-#endif // wxUSE_GUI

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( str, FALSE, _T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, T("can't read from closed file") );
+    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( pBuf, FALSE, _T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, T("can't read from closed file") );
+    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( pBuf, FALSE, _T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, T("can't write to closed file") );
+    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:

src/common/file.cpp

@@ -169,7 +169,7 @@ bool wxFile::Exists(const wxChar *name)
     wxCharBuffer fname = wxConvFile.cWC2MB(name);
 
     return !access(fname, 0) &&
-           !stat(wxMBSTRINGCAST fname, &st) &&
+           !stat(MBSTRINGCAST 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,29 +481,28 @@ 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;
-    // can use the cast because length doesn't change
+    mktemp(MBSTRINGCAST m_strTemp.mb_str()); // will do 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
 

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 )
+    if ( wxStrchr(szFile, _T('.')) == NULL )
-      str << T(".ini");
+      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(']') ) {
+      while ( *++pEnd != _T(']') ) {
-        if ( *pEnd == T('\n') || *pEnd == T('\0') )
+        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(' '):
-          case T('\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) ) {
+      while ( *pEnd != _T('=') && !wxIsspace(*pEnd) ) {
-        if ( *pEnd == T('\\') ) {
+        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'):
+        case _T('n'):
-          strResult += T('\n');
+          strResult += _T('\n');
           break;
 
-        case T('r'):
+        case _T('r'):
-          strResult += T('\r');
+          strResult += _T('\r');
           break;
 
-        case T('t'):
+        case _T('t'):
-          strResult += T('\t');
+          strResult += _T('\t');
           break;
 
-        case T('\\'):
+        case _T('\\'):
-          strResult += T('\\');
+          strResult += _T('\\');
           break;
 
-        case T('"'):
+        case _T('"'):
-          strResult += 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'):
+      case _T('\n'):
-        c = T('n');
+        c = _T('n');
         break;
 
-      case T('\r'):
+      case _T('\r'):
-        c = T('r');
+        c = _T('r');
         break;
 
-      case T('\t'):
+      case _T('\t'):
-        c = T('t');
+        c = _T('t');
         break;
 
-      case T('\\'):
+      case _T('\\'):
-        c = 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) )
+    if ( !wxIsalnum(c) && !wxStrchr(_T("@_/-!.*%"), c) && ((c & 0x80) == 0) )
-      strResult += T('\\');
+      strResult += _T('\\');
 
     strResult += c;
   }

src/common/filefn.cpp

@@ -9,14 +9,6 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
 #ifdef __GNUG__
     #pragma implementation "filefn.h"
 #endif
@@ -108,12 +100,9 @@
     #include "windows.h"
 #endif
 
-// ----------------------------------------------------------------------------
-// constants
-// ----------------------------------------------------------------------------
-
 #define _MAXPATHLEN 500
 
+extern wxChar *wxBuffer;
 #ifdef __WXMAC__
     extern wxChar gwxMacFileName[] ;
     extern wxChar gwxMacFileName2[] ;
@@ -124,16 +113,6 @@
     IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
 #endif
 
-// ----------------------------------------------------------------------------
-// private globals
-// ----------------------------------------------------------------------------
-
-static wxChar wxFileFunctionsBuffer[4*_MAXPATHLEN];
-
-// ============================================================================
-// implementation
-// ============================================================================
-
 void wxPathList::Add (const wxString& path)
 {
     wxStringList::Add (WXSTRINGCAST path);
@@ -144,9 +123,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);
@@ -202,11 +181,11 @@ bool wxPathList::Member (const wxString& path)
 
 wxString wxPathList::FindValidPath (const wxString& file)
 {
-  if (wxFileExists (wxExpandPath(wxFileFunctionsBuffer, file)))
+  if (wxFileExists (wxExpandPath(wxBuffer, file)))
-    return wxString(wxFileFunctionsBuffer);
+    return wxString(wxBuffer);
 
   wxChar buf[_MAXPATHLEN];
-  wxStrcpy(buf, wxFileFunctionsBuffer);
+  wxStrcpy(buf, wxBuffer);
 
   wxChar *filename = (wxChar*) NULL; /* shut up buggy egcs warning */
   filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (wxChar *)buf;
@@ -214,21 +193,21 @@ wxString wxPathList::FindValidPath (const wxString& file)
   for (wxNode * node = First (); node; node = node->Next ())
     {
       wxChar *path = (wxChar *) node->Data ();
-      wxStrcpy (wxFileFunctionsBuffer, path);
+      wxStrcpy (wxBuffer, path);
-      wxChar ch = wxFileFunctionsBuffer[wxStrlen(wxFileFunctionsBuffer)-1];
+      wxChar ch = wxBuffer[wxStrlen(wxBuffer)-1];
-      if (ch != T('\\') && ch != T('/'))
+      if (ch != _T('\\') && ch != _T('/'))
-        wxStrcat (wxFileFunctionsBuffer, T("/"));
+        wxStrcat (wxBuffer, _T("/"));
-      wxStrcat (wxFileFunctionsBuffer, filename);
+      wxStrcat (wxBuffer, filename);
 #ifdef __WINDOWS__
-      Unix2DosFilename (wxFileFunctionsBuffer);
+      Unix2DosFilename (wxBuffer);
 #endif
-      if (wxFileExists (wxFileFunctionsBuffer))
+      if (wxFileExists (wxBuffer))
       {
-        return wxString(wxFileFunctionsBuffer);        // Found!
+        return wxString(wxBuffer);        // Found!
       }
     }                                // for()
 
-  return wxString(T(""));                    // Not found
+  return wxString(_T(""));                    // Not found
 }
 
 wxString wxPathList::FindAbsoluteValidPath (const wxString& file)
@@ -236,17 +215,26 @@ wxString wxPathList::FindAbsoluteValidPath (const wxString& file)
   wxString f = FindValidPath(file);
   if (wxIsAbsolutePath(f))
     return f;
-
+  else
-    wxString buf;
-    wxGetWorkingDirectory(buf.GetWriteBuf(_MAXPATHLEN), _MAXPATHLEN - 1);
-    buf.UngetWriteBuf();
-    if ( !wxEndsWithPathSeparator(buf) )
   {
-        buf += wxFILE_SEP_PATH;
+    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('\\'))
+    {
+#ifdef __WINDOWS__
+      wxStrcat(buf, _T("\\"));
+#else
+      wxStrcat(buf, _T("/"));
+#endif
+    }
+    wxStrcat(buf, (const wxChar *)f);
+    wxStrcpy(wxBuffer, buf);
+    return wxString(wxBuffer);
   }
-    buf += f;
-
-    return buf;
 }
 
 bool
@@ -272,7 +260,7 @@ wxFileExists (const wxString& filename)
   struct stat stbuf;
 #endif
 
-  if ((filename != T("")) && stat (wxFNSTRINGCAST filename.fn_str(), &stbuf) == 0)
+  if ((filename != _T("")) && stat (FNSTRINGCAST filename.fn_str(), &stbuf) == 0)
     return TRUE;
   return FALSE;
 #endif
@@ -293,15 +281,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;
@@ -321,7 +309,7 @@ void wxStripExtension(wxChar *buffer)
   int i = len-1;
   while (i > 0)
   {
-    if (buffer[i] == T('.'))
+    if (buffer[i] == _T('.'))
     {
       buffer[i] = 0;
       break;
@@ -336,7 +324,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;
@@ -349,15 +337,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];
@@ -365,31 +353,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);
           }
       }
@@ -400,25 +388,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(wxFileFunctionsBuffer, filename))) {
+  if (! IsAbsolutePath(wxExpandPath(wxBuffer, 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('/'))
+    if (ch != _T('\\') && ch != _T('/'))
-        wxStrcat(buf, T("\\"));
+        wxStrcat(buf, _T("\\"));
 #else
-    if (ch != T('/'))
+    if (ch != _T('/'))
-        wxStrcat(buf, T("/"));
+        wxStrcat(buf, _T("/"));
 #endif
-    wxStrcat(buf, wxFileFunctionsBuffer);
+    wxStrcat(buf, wxBuffer);
     return copystring( wxRealPath(buf) );
   }
-  return copystring( wxFileFunctionsBuffer );
+  return copystring( wxBuffer );
 }
 
 /*-
@@ -451,21 +439,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[0] = _T('\n');
-    trimchars[1] = T(' ');
+    trimchars[1] = _T(' ');
-    trimchars[2] = T('\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');
+    buf[0] = _T('\0');
-    if (name == NULL || *name == T('\0'))
+    if (name == NULL || *name == _T('\0'))
         return buf;
     nm = copystring(name); // Make a scratch copy
     wxChar *nm_tmp = nm;
@@ -476,14 +464,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 */
@@ -491,7 +479,7 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
     while (*d)
     {
       *d++ = *s;
-      if(*s == T('\\'))
+      if(*s == _T('\\'))
       {
         *(d - 1) = *++s;
         if (*d)
@@ -506,7 +494,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;
@@ -516,13 +504,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
@@ -531,7 +519,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++;
@@ -553,14 +541,14 @@ wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
 
     /* Expand ~ and ~user */
     nm = lnm;
-    s = T("");
+    s = _T("");
-    if (nm[0] == T('~') && !q)
+    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++;
             }
@@ -577,7 +565,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;
@@ -588,7 +576,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)
@@ -620,7 +608,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);
@@ -634,12 +622,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 (wxFileFunctionsBuffer, tcp + wxStrlen (val));
+        wxStrcpy (wxBuffer, tcp + wxStrlen (val));
-        *tcp++ = T('$');
+        *tcp++ = _T('$');
-        *tcp++ = T('{');
+        *tcp++ = _T('{');
         wxStrcpy (tcp, WXSTRINGCAST envname);
-        wxStrcat (tcp, T("}"));
+        wxStrcat (tcp, _T("}"));
-        wxStrcat (tcp, wxFileFunctionsBuffer);
+        wxStrcat (tcp, wxBuffer);
     }
 
   // Handle User's home (ignore root homes!)
@@ -648,16 +636,16 @@ wxContractPath (const wxString& filename, const wxString& envname, const wxStrin
       (len = wxStrlen(val)) > 2 &&
       wxStrncmp(dest, val, len) == 0)
     {
-      wxStrcpy(wxFileFunctionsBuffer, T("~"));
+      wxStrcpy(wxBuffer, _T("~"));
-      if (user != T(""))
+      if (user != _T(""))
-             wxStrcat(wxFileFunctionsBuffer, (const wxChar*) user);
+             wxStrcat(wxBuffer, (const wxChar*) user);
 #ifdef __WXMSW__
-//      strcat(wxFileFunctionsBuffer, "\\");
+//      strcat(wxBuffer, "\\");
 #else
-//      strcat(wxFileFunctionsBuffer, "/");
+//      strcat(wxBuffer, "/");
 #endif
-      wxStrcat(wxFileFunctionsBuffer, dest + len);
+      wxStrcat(wxBuffer, dest + len);
-      wxStrcpy (dest, wxFileFunctionsBuffer);
+      wxStrcpy (dest, wxBuffer);
     }
 
   return dest;
@@ -674,16 +662,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
     }
@@ -692,7 +680,7 @@ wxChar *wxFileNameFromPath (wxChar *path)
 
 wxString wxFileNameFromPath (const wxString& path1)
 {
-  if (path1 != T(""))
+  if (path1 != _T(""))
   {
 
       wxChar *path = WXSTRINGCAST path1 ;
@@ -701,16 +689,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
     }
@@ -739,7 +727,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__
@@ -755,11 +743,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[2] = _T('.');
-          buf[3] = T('\0');
+          buf[3] = _T('\0');
           return buf;
         }
 #endif
@@ -771,7 +759,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];
 
@@ -787,7 +775,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__
@@ -803,17 +791,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[2] = _T('.');
-          buf[3] = T('\0');
+          buf[3] = _T('\0');
           return wxString(buf);
         }
 #endif
     }
 
-  return wxString(T(""));
+  return wxString(_T(""));
 }
 
 // Utility for converting delimiters in DOS filenames to UNIX style
@@ -827,15 +815,15 @@ wxMac2UnixFilename (wxChar *s)
         if (s)
         {
                 memmove( s+1 , s ,(strlen( s ) + 1)*sizeof(wxChar)) ;
-                if ( *s == T(':') )
+                if ( *s == _T(':') )
-                        *s = T('.') ;
+                        *s = _T('.') ;
                 else
-                        *s = T('/') ;
+                        *s = _T('/') ;
 
                 while (*s)
                 {
-                        if (*s == T(':'))
+                        if (*s == _T(':'))
-                          *s = T('/');
+                          *s = _T('/');
                         else
                           *s = wxTolower(*s);        // Case INDEPENDENT
                         s++;
@@ -848,24 +836,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('\\'))
+                        if (*s == _T('/') || *s == _T('\\'))
-                                  *s = T(':');
+                                  *s = _T(':');
 
                         s++ ;
                 }
@@ -878,8 +866,8 @@ wxDos2UnixFilename (wxChar *s)
   if (s)
     while (*s)
       {
-        if (*s == T('\\'))
+        if (*s == _T('\\'))
-          *s = T('/');
+          *s = _T('/');
 #if defined(__WXMSW__) || defined(__WXPM__)
         else
           *s = wxTolower(*s);        // Case INDEPENDENT
@@ -900,8 +888,8 @@ wxUnix2DosFilename (wxChar *WXUNUSED(s))
   if (s)
     while (*s)
       {
-        if (*s == T('/'))
+        if (*s == _T('/'))
-          *s = T('\\');
+          *s = _T('\\');
         s++;
       }
 #endif
@@ -929,8 +917,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 (wxFNSTRINGCAST file1.fn_str(), "rb")) == NULL ||
+  if ((fp1 = fopen (FNSTRINGCAST file1.fn_str(), "rb")) == NULL ||
-      (fp2 = fopen (wxFNSTRINGCAST file2.fn_str(), "rb")) == NULL ||
+      (fp2 = fopen (FNSTRINGCAST file2.fn_str(), "rb")) == NULL ||
       (fp3 = fopen (wxFNCONV(outfile), "wb")) == NULL)
 #endif
     {
@@ -976,9 +964,9 @@ wxCopyFile (const wxString& file1, const wxString& file2)
     return FALSE;
   if ((fd2 = fopen (gwxMacFileName2, "wb")) == NULL)
 #else
-  if ((fd1 = fopen (wxFNSTRINGCAST file1.fn_str(), "rb")) == NULL)
+  if ((fd1 = fopen (FNSTRINGCAST file1.fn_str(), "rb")) == NULL)
     return FALSE;
-  if ((fd2 = fopen (wxFNSTRINGCAST file2.fn_str(), "wb")) == NULL)
+  if ((fd2 = fopen (FNSTRINGCAST file2.fn_str(), "wb")) == NULL)
 #endif
     {
       fclose (fd1);
@@ -1006,7 +994,7 @@ wxRenameFile (const wxString& file1, const wxString& file2)
     return TRUE;
 #else
   // Normal system call
-  if (0 == rename (wxFNSTRINGCAST file1.fn_str(), wxFNSTRINGCAST file2.fn_str()))
+  if (0 == rename (FNSTRINGCAST file1.fn_str(), FNSTRINGCAST file2.fn_str()))
     return TRUE;
 #endif
   // Try to copy
@@ -1021,13 +1009,13 @@ wxRenameFile (const wxString& file1, const wxString& file2)
 bool wxRemoveFile(const wxString& file)
 {
 #if defined(__VISUALC__) || defined(__BORLANDC__) || defined(__WATCOMC__)
-  int flag = remove(wxFNSTRINGCAST file.fn_str());
+  int flag = remove(FNSTRINGCAST file.fn_str());
 #elif defined( __WXMAC__ )
         wxStrcpy( gwxMacFileName , file ) ;
         wxUnix2MacFilename( gwxMacFileName ) ;
   int flag = unlink(gwxMacFileName);
 #else
-  int flag = unlink(wxFNSTRINGCAST file.fn_str());
+  int flag = unlink(FNSTRINGCAST file.fn_str());
 #endif
   return (flag == 0) ;
 }
@@ -1047,7 +1035,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(wxFNSTRINGCAST wxFNCONV(dirname)) != 0 )
+    if ( mkdir(FNSTRINGCAST wxFNCONV(dirname)) != 0 )
 #endif // !MSW/MSW
     {
         wxLogSysError(_("Directory '%s' couldn't be created"), dirname);
@@ -1071,7 +1059,7 @@ bool wxRmdir(const wxString& dir, int WXUNUSED(flags))
 #ifdef __SALFORDC__
   return FALSE; // What to do?
 #else
-  return (rmdir(wxFNSTRINGCAST dir.fn_str()) == 0);
+  return (rmdir(FNSTRINGCAST dir.fn_str()) == 0);
 #endif
 
 #endif
@@ -1129,8 +1117,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') )
+  if ( wxEndsWithPathSeparator(pszPathName) && pszPathName[1] != _T('\0') )
-    strPath.Last() = T('\0');
+    strPath.Last() = _T('\0');
 
 #ifdef __SALFORDC__
   struct _stat st;
@@ -1138,7 +1126,7 @@ bool wxPathExists(const wxChar *pszPathName)
   struct stat st;
 #endif
 
-  return stat(wxFNSTRINGCAST strPath.fn_str(), &st) == 0 && (st.st_mode & S_IFDIR);
+  return stat(FNSTRINGCAST strPath.fn_str(), &st) == 0 && (st.st_mode & S_IFDIR);
 }
 
 // Get a temporary filename, opening and closing the file.
@@ -1166,7 +1154,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)
@@ -1217,11 +1205,11 @@ wxString wxFindFirstFile(const wxChar *spec, int flags)
     wxString path(wxPathOnly(gs_strFileSpec));
 
     // special case: path is really "/"
-    if ( !path && gs_strFileSpec[0u] == T('/') )
+    if ( !path && gs_strFileSpec[0u] == _T('/') )
-        path = T('/');
+        path = _T('/');
     // path is empty => Local directory
     if ( !path )
-        path = T('.');
+        path = _T('.');
 
     gs_dirStream = opendir(path.fn_str());
     if ( !gs_dirStream )
@@ -1243,7 +1231,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
@@ -1251,8 +1239,8 @@ wxString wxFindNextFile()
     wxString name(wxFileNameFromPath(gs_strFileSpec));
 
     /* MATTHEW: special case: path is really "/" */
-    if ( !path && gs_strFileSpec[0u] == T('/'))
+    if ( !path && gs_strFileSpec[0u] == _T('/'))
-        path = T('/');
+        path = _T('/');
 
     // Do the reading
     struct dirent *nextDir;
@@ -1266,8 +1254,8 @@ wxString wxFindNextFile()
             if ( !path.IsEmpty() )
             {
                 result = path;
-                if ( path != T('/') )
+                if ( path != _T('/') )
-                    result += T('/');
+                    result += _T('/');
             }
 
             result += nextDir->d_name;
@@ -1330,7 +1318,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 )
@@ -1423,7 +1411,7 @@ try_again:
             goto try_again;
 
         if ( !path.IsEmpty() )
-            result << path << T('\\');
+            result << path << _T('\\');
         result << gs_findDataStruct.cFileName;
     }
 
@@ -1489,8 +1477,8 @@ wxChar *wxGetWorkingDirectory(wxChar *buf, int sz)
   if (getcwd(buf, sz) == NULL) {
 #endif
 #endif
-    buf[0] = T('.');
+    buf[0] = _T('.');
-    buf[1] = T('\0');
+    buf[1] = _T('\0');
   }
 #if wxUSE_UNICODE
   else {
@@ -1515,7 +1503,7 @@ wxString wxGetCwd()
 bool wxSetWorkingDirectory(const wxString& d)
 {
 #if defined( __UNIX__ ) || defined( __WXMAC__ ) || defined(__WXPM__)
-  return (chdir(wxFNSTRINGCAST d.fn_str()) == 0);
+  return (chdir(FNSTRINGCAST d.fn_str()) == 0);
 #elif defined(__WINDOWS__)
 
 #ifdef __WIN32__
@@ -1613,7 +1601,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);
 
@@ -1673,9 +1661,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;
         }
@@ -1709,57 +1697,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)
+    while ((*pattern != _T('\0')) && (!done)
-    && (((*str==T('\0'))&&((*pattern==OB)||(*pattern==T('*'))))||(*str!=T('\0')))) {
+    && (((*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;
                     }
@@ -1773,51 +1761,51 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
                 goto repeat;
             }
             pattern++;
-            while ((*pattern != T(']')) && (*pattern != T('\0'))) {
+            while ((*pattern != _T(']')) && (*pattern != _T('\0'))) {
-                if ((*pattern == T('\\')) && (*(pattern + 1) != 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'))
+                while (ok && (*cp != _T('\0')) && (*pattern != _T('\0'))
-                &&  (*pattern != T(',')) && (*pattern != CB)) {
+                &&  (*pattern != _T(',')) && (*pattern != CB)) {
-                    if (*pattern == T('\\'))
+                    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'))) {
+                    while ((*pattern != CB) && (*pattern != _T('\0'))) {
-                        if (*++pattern == T('\\')) {
+                        if (*++pattern == _T('\\')) {
                             if (*++pattern == CB)
                                 pattern++;
                         }
                     }
                 } else {
-                    while (*pattern!=CB && *pattern!=T(',') && *pattern!=T('\0')) {
+                    while (*pattern!=CB && *pattern!=_T(',') && *pattern!=_T('\0')) {
-                        if (*++pattern == T('\\')) {
+                        if (*++pattern == _T('\\')) {
-                            if (*++pattern == CB || *pattern == T(','))
+                            if (*++pattern == CB || *pattern == _T(','))
                                 pattern++;
                         }
                     }
                 }
-                if (*pattern != T('\0'))
+                if (*pattern != _T('\0'))
                     pattern++;
             }
             break;
@@ -1829,9 +1817,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

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('#')) l2 = i + 1;
-        if (c == T('.')) {ext = loc.Right(l2-i-1); break;}
+        if (c == _T('.')) {ext = loc.Right(l2-i-1); break;}
-        if ((c == T('/')) || (c == T('\\')) || (c == T(':'))) {return wxEmptyString;}
+        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--) {
+    for (i = l-1; (i >= 0) && ((location[i] != _T('#')) || (!fnd)); i--) {
-        if ((location[i] == T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
+        if ((location[i] == _T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
     }
-    if (!fnd) return T("file");
+    if (!fnd) return _T("file");
-    for (++i; (i < l) && (location[i] != T(':')); i++) s << location[i];
+    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;
+        if ((location[i] == _T(':')) && (i != 1 /*win: C:\path*/)) fnd = TRUE;
-        else if (fnd && (location[i] == T('#'))) return location.Left(i);
+        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);
+        if (c == _T('#')) return location.Right(l-i-1);
-        else if ((c == T('.')) || (c == T('/')) || (c == T('\\')) || (c == T(':'))) return wxEmptyString;
+        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('/'))
+            if (m_Path[m_Path.Length()-1] != _T('/'))
-	        m_Path << 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)

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 wxDECORATIVE:   return _T("wxDECORATIVE");
-        case wxROMAN:        return T("wxROMAN");
+        case wxROMAN:        return _T("wxROMAN");
-        case wxSCRIPT:       return T("wxSCRIPT(");
+        case wxSCRIPT:       return _T("wxSCRIPT");
-        case wxSWISS:        return T("wxSWISS");
+        case wxSWISS:        return _T("wxSWISS");
-        case wxMODERN:       return T("wxMODERN");
+        case wxMODERN:       return _T("wxMODERN");
-        case wxTELETYPE:     return T("wxTELETYPE");
+        case wxTELETYPE:     return _T("wxTELETYPE");
-        default:             return T("wxDEFAULT(");
+        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 wxNORMAL:   return _T("wxNORMAL");
-        case wxSLANT:    return T("wxSLANT(");
+        case wxSLANT:    return _T("wxSLANT");
-        case wxITALIC:   return T("wxITALIC");
+        case wxITALIC:   return _T("wxITALIC");
-        default:         return T("wxDEFAULT(");
+        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 wxNORMAL:   return _T("wxNORMAL");
-        case wxBOLD:     return T("wxBOLD");
+        case wxBOLD:     return _T("wxBOLD");
-        case wxLIGHT:    return T("wxLIGHT(");
+        case wxLIGHT:    return _T("wxLIGHT");
-        default:         return T("wxDEFAULT(");
+        default:         return _T("wxDEFAULT");
     }
 }
 

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);
 

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(wxMBSTRINGCAST tmp_buf, strlen(tmp_buf)).Error()) {
+  if (Write(MBSTRINGCAST 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);
+  beg = m_lastResult.Find(_T('\"'),FALSE);
-  end = m_lastResult.Find(T('\"'),TRUE);
+  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;

src/common/gdicmn.cpp

@@ -144,84 +144,84 @@ void wxColourDatabase::Initialize ()
   static cdef table[]={
 
 // #ifdef __WXMSW__
-   {T("AQUAMARINE"),112, 219, 147},
+   {_T("AQUAMARINE"),112, 219, 147},
-   {T("BLACK"),0, 0, 0},
+   {_T("BLACK"),0, 0, 0},
-   {T("BLUE"), 0, 0, 255},
+   {_T("BLUE"), 0, 0, 255},
-   {T("BLUE VIOLET("), 159, 95, 159},
+   {_T("BLUE VIOLET"), 159, 95, 159},
-   {T("BROWN"), 165, 42, 42},
+   {_T("BROWN"), 165, 42, 42},
-   {T("CADET BLUE"), 95, 159, 159},
+   {_T("CADET BLUE"), 95, 159, 159},
-   {T("CORAL"), 255, 127, 0},
+   {_T("CORAL"), 255, 127, 0},
-   {T("CORNFLOWER BLUE"), 66, 66, 111},
+   {_T("CORNFLOWER BLUE"), 66, 66, 111},
-   {T("CYAN"), 0, 255, 255},
+   {_T("CYAN"), 0, 255, 255},
-   {T("DARK GREY"), 47, 47, 47},   // ?
+   {_T("DARK GREY"), 47, 47, 47},   // ?
 
-   {T("DARK GREEN"), 47, 79, 47},
+   {_T("DARK GREEN"), 47, 79, 47},
-   {T("DARK OLIVE GREEN"), 79, 79, 47},
+   {_T("DARK OLIVE GREEN"), 79, 79, 47},
-   {T("DARK ORCHID"), 153, 50, 204},
+   {_T("DARK ORCHID"), 153, 50, 204},
-   {T("DARK SLATE BLUE"), 107, 35, 142},
+   {_T("DARK SLATE BLUE"), 107, 35, 142},
-   {T("DARK SLATE GREY"), 47, 79, 79},
+   {_T("DARK SLATE GREY"), 47, 79, 79},
-   {T("DARK TURQUOISE"), 112, 147, 219},
+   {_T("DARK TURQUOISE"), 112, 147, 219},
-   {T("DIM GREY"), 84, 84, 84},
+   {_T("DIM GREY"), 84, 84, 84},
-   {T("FIREBRICK"), 142, 35, 35},
+   {_T("FIREBRICK"), 142, 35, 35},
-   {T("FOREST GREEN"), 35, 142, 35},
+   {_T("FOREST GREEN"), 35, 142, 35},
-   {T("GOLD"), 204, 127, 50},
+   {_T("GOLD"), 204, 127, 50},
-   {T("GOLDENROD"), 219, 219, 112},
+   {_T("GOLDENROD"), 219, 219, 112},
-   {T("GREY"), 128, 128, 128},
+   {_T("GREY"), 128, 128, 128},
-   {T("GREEN"), 0, 255, 0},
+   {_T("GREEN"), 0, 255, 0},
-   {T("GREEN YELLOW"), 147, 219, 112},
+   {_T("GREEN YELLOW"), 147, 219, 112},
-   {T("INDIAN RED"), 79, 47, 47},
+   {_T("INDIAN RED"), 79, 47, 47},
-   {T("KHAKI"), 159, 159, 95},
+   {_T("KHAKI"), 159, 159, 95},
-   {T("LIGHT BLUE"), 191, 216, 216},
+   {_T("LIGHT BLUE"), 191, 216, 216},
-   {T("LIGHT GREY"), 192, 192, 192},
+   {_T("LIGHT GREY"), 192, 192, 192},
-   {T("LIGHT STEEL BLUE"), 143, 143, 188},
+   {_T("LIGHT STEEL BLUE"), 143, 143, 188},
-   {T("LIME GREEN"), 50, 204, 50},
+   {_T("LIME GREEN"), 50, 204, 50},
-   {T("LIGHT MAGENTA"), 255, 0, 255},
+   {_T("LIGHT MAGENTA"), 255, 0, 255},
-   {T("MAGENTA"), 255, 0, 255},
+   {_T("MAGENTA"), 255, 0, 255},
-   {T("MAROON"), 142, 35, 107},
+   {_T("MAROON"), 142, 35, 107},
-   {T("MEDIUM AQUAMARINE"), 50, 204, 153},
+   {_T("MEDIUM AQUAMARINE"), 50, 204, 153},
-   {T("MEDIUM GREY"), 100, 100, 100},
+   {_T("MEDIUM GREY"), 100, 100, 100},
-   {T("MEDIUM BLUE"), 50, 50, 204},
+   {_T("MEDIUM BLUE"), 50, 50, 204},
-   {T("MEDIUM FOREST GREEN"), 107, 142, 35},
+   {_T("MEDIUM FOREST GREEN"), 107, 142, 35},
-   {T("MEDIUM GOLDENROD"), 234, 234, 173},
+   {_T("MEDIUM GOLDENROD"), 234, 234, 173},
-   {T("MEDIUM ORCHID"), 147, 112, 219},
+   {_T("MEDIUM ORCHID"), 147, 112, 219},
-   {T("MEDIUM SEA GREEN"), 66, 111, 66},
+   {_T("MEDIUM SEA GREEN"), 66, 111, 66},
-   {T("MEDIUM SLATE BLUE"), 127, 0, 255},
+   {_T("MEDIUM SLATE BLUE"), 127, 0, 255},
-   {T("MEDIUM SPRING GREEN"), 127, 255, 0},
+   {_T("MEDIUM SPRING GREEN"), 127, 255, 0},
-   {T("MEDIUM TURQUOISE"), 112, 219, 219},
+   {_T("MEDIUM TURQUOISE"), 112, 219, 219},
-   {T("MEDIUM VIOLET RED"), 219, 112, 147},
+   {_T("MEDIUM VIOLET RED"), 219, 112, 147},
-   {T("MIDNIGHT BLUE"), 47, 47, 79},
+   {_T("MIDNIGHT BLUE"), 47, 47, 79},
-   {T("NAVY"), 35, 35, 142},
+   {_T("NAVY"), 35, 35, 142},
-   {T("ORANGE"), 204, 50, 50},
+   {_T("ORANGE"), 204, 50, 50},
-   {T("ORANGE RED"), 255, 0, 127},
+   {_T("ORANGE RED"), 255, 0, 127},
-   {T("ORCHID"), 219, 112, 219},
+   {_T("ORCHID"), 219, 112, 219},
-   {T("PALE GREEN"), 143, 188, 143},
+   {_T("PALE GREEN"), 143, 188, 143},
-   {T("PINK"), 188, 143, 234},
+   {_T("PINK"), 188, 143, 234},
-   {T("PLUM"), 234, 173, 234},
+   {_T("PLUM"), 234, 173, 234},
-   {T("PURPLE"), 176, 0, 255},
+   {_T("PURPLE"), 176, 0, 255},
-   {T("RED"), 255, 0, 0},
+   {_T("RED"), 255, 0, 0},
-   {T("SALMON"), 111, 66, 66},
+   {_T("SALMON"), 111, 66, 66},
-   {T("SEA GREEN"), 35, 142, 107},
+   {_T("SEA GREEN"), 35, 142, 107},
-   {T("SIENNA"), 142, 107, 35},
+   {_T("SIENNA"), 142, 107, 35},
-   {T("SKY BLUE"), 50, 153, 204},
+   {_T("SKY BLUE"), 50, 153, 204},
-   {T("SLATE BLUE"), 0, 127, 255},
+   {_T("SLATE BLUE"), 0, 127, 255},
-   {T("SPRING GREEN"), 0, 255, 127},
+   {_T("SPRING GREEN"), 0, 255, 127},
-   {T("STEEL BLUE"), 35, 107, 142},
+   {_T("STEEL BLUE"), 35, 107, 142},
-   {T("TAN"), 219, 147, 112},
+   {_T("TAN"), 219, 147, 112},
-   {T("THISTLE"), 216, 191, 216},
+   {_T("THISTLE"), 216, 191, 216},
-   {T("TURQUOISE"), 173, 234, 234},
+   {_T("TURQUOISE"), 173, 234, 234},
-   {T("VIOLET("), 79, 47, 79},
+   {_T("VIOLET"), 79, 47, 79},
-   {T("VIOLET RED"), 204, 50, 153},
+   {_T("VIOLET RED"), 204, 50, 153},
-   {T("WHEAT("), 216, 216, 191},
+   {_T("WHEAT"), 216, 216, 191},
-   {T("WHITE"), 255, 255, 255},
+   {_T("WHITE"), 255, 255, 255},
-   {T("YELLOW"), 255, 255, 0},
+   {_T("YELLOW"), 255, 255, 0},
-   {T("YELLOW GREEN"), 153, 204, 50},
+   {_T("YELLOW GREEN"), 153, 204, 50},
 // #endif
 
 #if defined(__WXGTK__) || defined(__X__)
-   {T("MEDIUM GOLDENROD"), 234, 234, 173},
+   {_T("MEDIUM GOLDENROD"), 234, 234, 173},
-   {T("MEDIUM FOREST GREEN"), 107, 142, 35},
+   {_T("MEDIUM FOREST GREEN"), 107, 142, 35},
-   {T("LIGHT MAGENTA"), 255, 0, 255},
+   {_T("LIGHT MAGENTA"), 255, 0, 255},
-   {T("MEDIUM GREY"), 100, 100, 100},
+   {_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;
     }

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())
+  if (GetHeader(_T("User-Agent")).IsNull())
-    SetHeader(T("User-Agent"), T("wxWindows 2.x")); 
+    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(wxMBSTRINGCAST pathbuf));
+  Write(pathbuf, strlen(MBSTRINGCAST 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-Length"), _T("-1"));
-    SetHeader(T("Content-Type"), T("none/none"));
+    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())
+  if (!GetHeader(_T("Content-Length")).IsEmpty())
-    inp_stream->m_httpsize = wxAtoi(WXSTRINGCAST GetHeader(T("Content-Length")));
+    inp_stream->m_httpsize = wxAtoi(WXSTRINGCAST GetHeader(_T("Content-Length")));
   else
     inp_stream->m_httpsize = (size_t)-1;
 

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;

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;
 

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_FORMATO: wxLogError(_T("wxGIFHandler: error in image format")); break;
-                case E_MEMORIA: wxLogError(T("wxGIFHandler: couldn't allocate memory")); break;
+                case E_MEMORIA: wxLogError(_T("wxGIFHandler: couldn't allocate memory")); break;
-                default:        wxLogError(T("wxGIFHandler: unknown error !!!"));
+                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;
 }

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_FORMATO: wxLogError(_T("wxPCXHandler: image format unsupported")); break;
-                case E_MEMORIA: wxLogError(T("wxPCXHandler: couldn't allocate memory")); break;
+                case E_MEMORIA: wxLogError(_T("wxPCXHandler: couldn't allocate memory")); break;
-                case E_VERSION: wxLogError(T("wxPCXHandler: version number too low")); break;
+                case E_VERSION: wxLogError(_T("wxPCXHandler: version number too low")); break;
-                default:        wxLogError(T("wxPCXHandler: unknown error !!!"));
+                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;
 }

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'):
+      case _T('2'):
-	wxLogError(T("Loading Grey Ascii PNM image is not yet implemented."));
+	wxLogError(_T("Loading Grey Ascii PNM image is not yet implemented."));
 	return FALSE;
-      case T('5'):
+      case _T('5'):
-	wxLogError(T("Loading Grey Raw PNM image is not yet implemented."));
+	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;
 	}

src/common/init.cpp

@@ -1,80 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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;
-    }
-}

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/share/locale"), lang) << wxPATH_SEP
-        << GetAllMsgCatalogSubdirs(T("/usr/lib/locale"), lang) << wxPATH_SEP
+        << GetAllMsgCatalogSubdirs(_T("/usr/lib/locale"), lang) << wxPATH_SEP
-        << GetAllMsgCatalogSubdirs(T("/usr/local/share/locale"), lang);
+        << 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,7 +340,9 @@ bool wxMsgCatalog::Load(const wxChar *szDirPrefix, const wxChar *szName0)
   // (we're using an object because we have several return paths)
 
   NoTransErr noTransErr;
-  wxLogVerbose(T("looking for catalog '%s' in path '%s'."),
+//  Then why do you translate at all? Just use _T() and not _(). RR.
+
+  wxLogVerbose(_("looking for catalog '%s' in path '%s'."),
                szName.c_str(), searchPath.c_str());
 
   wxString strFullName;
@@ -496,7 +498,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;
 }
@@ -534,11 +536,7 @@ const wxMB2WXbuf wxLocale::GetString(const wxChar *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 ) {
@@ -585,16 +583,7 @@ 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

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

src/common/log.cpp

@@ -30,15 +30,15 @@
 
 // wxWindows
 #ifndef WX_PRECOMP
-    #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/event.h"
+  #include  "wx/app.h"
+  #include  "wx/string.h"
+  #include  "wx/intl.h"
+  #ifndef wxUSE_NOGUI
     #include "wx/msgdlg.h"
   #endif  
 #endif //WX_PRECOMP
@@ -249,11 +249,15 @@ 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;
 
@@ -295,7 +299,7 @@ void wxLog::TimeStamp(wxString *str)
         wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
 
         str->Empty();
-        *str << buf << T(": ");
+        *str << buf << _T(": ");
     }
 }
 
@@ -339,7 +343,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()
@@ -363,7 +367,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);
@@ -371,7 +375,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
 }
 
@@ -390,7 +394,7 @@ wxLogStream::wxLogStream(ostream *ostr)
 
 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 {
-    (*m_ostr) << wxConvertWX2MB(szString) << endl;
+    (*m_ostr) << wxConvCurrent->cWX2MB(szString) << endl << flush;
 }
 #endif // wxUSE_STD_IOSTREAM
 
@@ -406,7 +410,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;
@@ -487,7 +491,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
@@ -495,8 +499,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') )
+        if ( s_szBuf[len - 2] == _T('\r') )
-            s_szBuf[len - 2] = T('\0');
+            s_szBuf[len - 2] = _T('\0');
     }
 
     return s_szBuf;
@@ -562,28 +566,30 @@ 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_GUI
+#if wxUSE_NOGUI
+        Trap();
+#else // 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."));
 
@@ -599,9 +605,7 @@ void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
 
                 //case wxNO: nothing to do
         }
-#else // !GUI
+#endif // !GUI/GUI
-        Trap();
-#endif // GUI/!GUI
     }
 
     s_bInAssert = FALSE;

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.Printf(_T("%s(%d): "), m_fileName, (int)m_lineNum);
-    msg += T("non-object data");
+    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");
+    wxChar* appName = _T("application");
-    wxString appNameStr(T(""));
+    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 object items: %ld"), noObjectNodes);
-  wxLogDebug(T("Number of non-object items: %ld"), noNonObjectNodes);
+  wxLogDebug(_T("Number of non-object items: %ld"), noNonObjectNodes);
-  wxLogDebug(T("Total allocated size: %ld"), totalSize);
+  wxLogDebug(_T("Total allocated size: %ld"), totalSize);
-  wxLogDebug(T(""));
+  wxLogDebug(_T(""));
-  wxLogDebug(T(""));
+  wxLogDebug(_T(""));
 
   return TRUE;
 #else
@@ -822,13 +822,13 @@ bool wxDebugContext::PrintClasses(void)
 
 //  if (TRUE)
   {
-    wxChar* appName = T("application");
+    wxChar* appName = _T("application");
-    wxString appNameStr(T(""));
+    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(""));
-  wxLogDebug(T("There are %d classes derived from wxObject."), n);
+  wxLogDebug(_T("There are %d classes derived from wxObject."), n);
-  wxLogDebug(T(""));
+  wxLogDebug(_T(""));
-  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;

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++ ) {
+    for ( const wxChar *pc = command.c_str(); *pc != _T('\0'); pc++ ) {
-        if ( *pc == T('%') ) {
+        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('n'):
-                case T('F'):
+                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,
+    wxASSERT_MSG( mimeType.Find(_T('*')) == wxNOT_FOUND,
-                  T("first MIME type can't contain wildcards") );
+                  _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("*") ||
+        if ( strSubtype == _T("*") ||
-             strSubtype.IsSameAs(mimeType.AfterFirst(T('/')), FALSE) )
+             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('%') &&
+                if ( command[n] == _T('%') &&
-                     (n + 1 < len) && command[n + 1] == T('1') ) {
+                     (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);
+    wxRegKey key(wxRegKey::HKCR, /*m_strFileType*/ _T(".") + m_ext);
-    if ( key.Open() && key.QueryValue(T("Content Type"), *mimeType) ) {
+    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(',')),
+            wxString strFullPath = strIcon.BeforeLast(_T(',')),
-            strIndex = strIcon.AfterLast(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('.') ) {
+    if ( ext[0u] != _T('.') ) {
-        str = 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("/etc"),
-        T("/usr/etc"),
+        _T("/usr/etc"),
-        T("/usr/local/etc"),
+        _T("/usr/local/etc"),
-        T("/etc/mail"),
+        _T("/etc/mail"),
-        T("/usr/public/lib")
+        _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(' '));
+            wxString field = extensions.BeforeFirst(_T(' '));
-            extensions = extensions.AfterFirst(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 ) &&
+            if ( (m_aTypes[n].BeforeFirst(_T('/')) == strCategory ) &&
-                 m_aTypes[n].AfterFirst(T('/')) == T("*") ) {
+                 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('=')),
+                                    wxString lhs = curField.BeforeFirst(_T('=')),
-                                             rhs = curField.AfterFirst(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('"') &&
+                                        if ( rhs[0u] == _T('"') &&
-                                             rhs.Last() == 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") ||
+                                    else if ( lhs == _T("compose") ||
-                                              lhs == T("composetyped") ||
+                                              lhs == _T("composetyped") ||
-                                              lhs == T("notes") ||
+                                              lhs == _T("notes") ||
-                                              lhs == T("edit") )
+                                              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 {

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

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;
   }
 

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;

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_LIST", wxLC_LIST },
-  { "wxLC_REPORT(", wxLC_REPORT },
+  { "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},
+  { "wxSRC_INVERT", wxSRC_INVERT},
-  { "wxOR_INVERT(", wxOR_INVERT},
+  { "wxOR_INVERT", wxOR_INVERT},
   { "wxNAND", wxNAND},
   { "wxOR", wxOR},
-  { "wxSET(", wxSET},
+  { "wxSET", wxSET},
 
   { "wxFLOOD_SURFACE", wxFLOOD_SURFACE},
   { "wxFLOOD_BORDER", wxFLOOD_BORDER},