This commit was manufactured by cvs2svn to create tag

'BEFORE_ON_PAINT_CHANGE'.

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

.cvsignore

@@ -21,23 +21,10 @@ linux-gnu.system.cache
 *.d
 *.swp
 *.swo
-*.swq
 Release
 Debug
-ReleaseDll
+ReleaseDLL
-DebugDll
+DebugDLL
-ReleaseUnicode
-DebugUnicode
-ReleaseUnicodeDll
-DebugUnicodeDll
-BaseRelease
-BaseDebug
-BaseReleaseDll
-BaseDebugDll
-BaseReleaseUnicode
-BaseDebugUnicode
-BaseReleaseUnicodeDll
-BaseDebugUnicodeDll
 robert
 stamp-h.in
 Makefile
@@ -50,6 +37,7 @@ base
 gtk
 motif
 win32
+univ
 base-release
 gtk-release
 motif-release

BuildCVS.txt

@@ -115,20 +115,6 @@ ftp server at ftp://sourceware.cygnus.com/pub/cygwin/.
 Of course, you can also build the library using plain makefiles (see
 section I).
 
-IV) wxBase
-----------------------------------------
-
-wxBase is the non GUI part of wxWindows. Currently it can be only built using
-configure (i.e. under Unix and probably under Win32 with cygwin) and with
-Visual C++.
-
-To build it using configure, just add "--disable-gui" argument to it.
-
-To build wxBase with VC++, use the project files wxBase.dsp and wxBaseDll.dsp
-included in the CVS. See http://www.wxwindows.org/vadim/wxDocs/buildmsw.html
-for the instructions on how to generate the project files for the programs
-using wxBase.
-
 V) MacOS
 ----------------------------------------
 

Makefile.in

@@ -32,6 +32,7 @@ include ./src/make.env
 srcdir = @srcdir@
 
 VP1 = @top_srcdir@/src/common
+VP1_5 = @top_srcdir@/src/univ@PATH_IFS@@top_srcdir@/src/univ/themes
 VP2 = @top_srcdir@/src/@TOOLKIT_DIR@
 VP3 = @top_srcdir@/src/motif/xmcombo
 VP4 = @top_srcdir@/src/generic
@@ -46,7 +47,7 @@ VP11 = @top_srcdir@/src/iodbc
 # the comment at the end of the next line is needed because otherwise autoconf
 # would remove this line completely - it contains a built-in hack to remove
 # any VPATH assignment not containing ':'
-VPATH = $(VP1)@PATH_IFS@$(VP2)@PATH_IFS@$(VP3)@PATH_IFS@$(VP4)@PATH_IFS@$(VP5)@PATH_IFS@$(VP6)@PATH_IFS@$(VP7)@PATH_IFS@$(VP8)@PATH_IFS@$(VP9)@PATH_IFS@$(VP10)@PATH_IFS@$(VP11) # ':' for autoconf
+VPATH = $(VP1)@PATH_IFS@$(VP1_5)@PATH_IFS@$(VP2)@PATH_IFS@$(VP3)@PATH_IFS@$(VP4)@PATH_IFS@$(VP5)@PATH_IFS@$(VP6)@PATH_IFS@$(VP7)@PATH_IFS@$(VP8)@PATH_IFS@$(VP9)@PATH_IFS@$(VP10)@PATH_IFS@$(VP11) # ':' for autoconf
 
 top_srcdir = @top_srcdir@
 prefix = @prefix@
@@ -532,13 +533,10 @@ ALL_DIST: distclean
 # but is not used when building wxBase distribution
 ALL_GUI_DIST: ALL_DIST
 	cp $(WXDIR)/wx$(TOOLKIT).spec $(DISTDIR)
-	cp $(WXDIR)/wxBase.spec $(DISTDIR)
 	cp $(DOCDIR)/$(TOOLKITDIR)/install.txt $(DISTDIR)/INSTALL.txt
 	cp $(DOCDIR)/$(TOOLKITDIR)/changes.txt $(DISTDIR)/CHANGES.txt
 	cp $(DOCDIR)/$(TOOLKITDIR)/readme.txt $(DISTDIR)/README.txt
 	cp $(DOCDIR)/$(TOOLKITDIR)/todo.txt $(DISTDIR)/TODO.txt
-	cp $(DOCDIR)/base/todo.txt $(DISTDIR)/wxBASE.todo
-	cp $(DOCDIR)/base/install.txt $(DISTDIR)/wxBASE.install
 	mkdir $(DISTDIR)/include
 	mkdir $(DISTDIR)/include/wx
 	mkdir $(DISTDIR)/include/wx/$(TOOLKITDIR)
@@ -564,7 +562,7 @@ ALL_GUI_DIST: ALL_DIST
 	mkdir $(DISTDIR)/src/tiff
 	mkdir $(DISTDIR)/src/iodbc
 	mkdir $(DISTDIR)/src/unix
-	cp $(WXDIR)/@PORT_FILES@ $(DISTDIR)/@PORT_FILES@
+	cp $(WXDIR)/@PORT_FILES@ $(DISTDIR)
 	cp $(SRCDIR)/*.in $(DISTDIR)/src
 	cp $(COMMDIR)/*.cpp $(DISTDIR)/src/common
 	cp $(COMMDIR)/*.c $(DISTDIR)/src/common
@@ -604,18 +602,16 @@ BASE_DIST: ALL_DIST
 	mkdir $(DISTDIR)/include/wx/unix
 	mkdir $(DISTDIR)/src/common
 	mkdir $(DISTDIR)/src/unix
-	cp $(WXDIR)/@PORT_FILES@ $(DISTDIR)/@PORT_FILES@
+	cp $(WXDIR)/@PORT_FILES@ $(DISTDIR)
 	cp $(WXDIR)/@RPM_FILES@ $(DISTDIR)/@RPM_FILES@
 	cp $(WXDIR)/@RPM_SPEC@ $(DISTDIR)/@RPM_SPEC@
-	cp $(WXDIR)/wxBase*.ds[pw] $(DISTDIR)
+	cp $(WXDIR)/wxBase.dsp $(DISTDIR)
-	cp $(DOCDIR)/base/install.txt $(DISTDIR)/INSTALL.txt
+	cp $(DOCDIR)/install.txt $(DISTDIR)/INSTALL.txt
 	cp $(DOCDIR)/changes.txt $(DISTDIR)/CHANGES.txt
 	cp $(DOCDIR)/readme.txt $(DISTDIR)/README.txt
-	cp $(DOCDIR)/base/todo.txt $(DISTDIR)/TODO.txt
+	cp $(DOCDIR)/todo.txt $(DISTDIR)/TODO.txt
 	cp $(SRCDIR)/*.in $(DISTDIR)/src
-	cp $(WXDIR)/src/common/*.inc $(DISTDIR)/src/common
+	cp $(WXDIR)/src/common/unzip.h $(DISTDIR)/src/common/unzip.h
-	cp $(WXDIR)/src/common/base.rc $(DISTDIR)/src/common
-	cp $(WXDIR)/src/common/unzip.h $(DISTDIR)/src/common
 	list='$(HEADERS)'; for p in $$list; do \
 	  cp $(WXDIR)/include/wx/$$p $(DISTDIR)/include/wx/$$p; \
 	done
@@ -623,18 +619,8 @@ BASE_DIST: ALL_DIST
 	  cp $(WXDIR)/src/$$p $(DISTDIR)/src/$$p; \
 	done
 
-	mkdir $(DISTDIR)/samples
-	cp $(SAMPDIR)/Makefile.in $(DISTDIR)/samples
-	cp $(SAMPDIR)/configure $(DISTDIR)/samples
-	cp $(SAMPDIR)/configure.in $(DISTDIR)/samples
-
-	mkdir $(DISTDIR)/samples/console
-	cp $(SAMPDIR)/console/Makefile.in $(DISTDIR)/samples/console
-	cp $(SAMPDIR)/console/makefile.unx $(DISTDIR)/samples/console
-	cp $(SAMPDIR)/console/console.cpp $(DISTDIR)/samples/console
-	cp $(SAMPDIR)/console/testdata.fc $(DISTDIR)/samples/console
-
 GTK_DIST: ALL_GUI_DIST
+	cp $(WXDIR)/wxGTK.spec $(DISTDIR)
 	cp $(INCDIR)/wx/gtk/*.h $(DISTDIR)/include/wx/gtk
 	cp $(INCDIR)/wx/gtk/*.xpm $(DISTDIR)/include/wx/gtk
 	cp $(GTKDIR)/*.cpp $(DISTDIR)/src/gtk
@@ -1216,6 +1202,7 @@ PYTHON_DIST:
 	mkdir $(DISTDIR)/wxPython/demo
 	mkdir $(DISTDIR)/wxPython/demo/bitmaps
 	mkdir $(DISTDIR)/wxPython/demo/data
+	mkdir $(DISTDIR)/wxPython/distrib
 	mkdir $(DISTDIR)/wxPython/src
 	mkdir $(DISTDIR)/wxPython/src/gtk
 	mkdir $(DISTDIR)/wxPython/wxPython
@@ -1224,9 +1211,7 @@ PYTHON_DIST:
 	mkdir $(DISTDIR)/wxPython/wxPython/lib/sizers
 
 	cp $(WXDIR)/wxPython/*.txt $(DISTDIR)/wxPython
-	cp $(WXDIR)/wxPython/*.py $(DISTDIR)/wxPython
+	cp $(WXDIR)/wxPython/contrib/buildall.py $(DISTDIR)/wxPython/contrib
-	cp $(WXDIR)/wxPython/setup.cfg $(DISTDIR)/wxPython
-	cp $(WXDIR)/wxPython/MANIFEST.in $(DISTDIR)/wxPython
 	-cp $(WXDIR)/wxPython/contrib/glcanvas/* $(DISTDIR)/wxPython/contrib/glcanvas
 	cp $(WXDIR)/wxPython/contrib/glcanvas/gtk/glcanvas.* $(DISTDIR)/wxPython/contrib/glcanvas/gtk
 	-cp $(WXDIR)/wxPython/contrib/ogl/* $(DISTDIR)/wxPython/contrib/ogl
@@ -1234,11 +1219,13 @@ PYTHON_DIST:
 	-cp $(WXDIR)/wxPython/demo/* $(DISTDIR)/wxPython/demo
 	-cp $(WXDIR)/wxPython/demo/bitmaps/* $(DISTDIR)/wxPython/demo/bitmaps
 	-cp $(WXDIR)/wxPython/demo/data/* $(DISTDIR)/wxPython/demo/data
+	cp $(WXDIR)/wxPython/distrib/build.py $(DISTDIR)/wxPython/distrib
 	-cp $(WXDIR)/wxPython/src/* $(DISTDIR)/wxPython/src
 	cp $(WXDIR)/wxPython/src/gtk/*.py $(DISTDIR)/wxPython/src/gtk
 	cp $(WXDIR)/wxPython/src/gtk/*.cpp $(DISTDIR)/wxPython/src/gtk
 	cp $(WXDIR)/wxPython/wxPython/lib/*.py $(DISTDIR)/wxPython/wxPython/lib
 	cp $(WXDIR)/wxPython/wxPython/lib/editor/*.py $(DISTDIR)/wxPython/wxPython/lib/editor
+	cp $(WXDIR)/wxPython/wxPython/lib/sizers/*.py $(DISTDIR)/wxPython/wxPython/lib/sizers
 
 distclean:
 	$(RM) -r _dist_dir

TODO

@@ -0,0 +1,10 @@
+All
+
+* problem with horz scrolling: the focus rect isn't drawn entirely...
+* write sample testing all listbox styles/events
+
+MSW
+
+GTK
+
+* check/radio box remains pressed

aclocal.m4

@@ -0,0 +1,194 @@
+# Configure paths for GTK+
+# Owen Taylor     97-11-3
+
+dnl AM_PATH_GTK_2_0([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, MODULES]]]])
+dnl Test for GTK, and define GTK_CFLAGS and GTK_LIBS
+dnl
+AC_DEFUN(AM_PATH_GTK_2_0,
+[dnl 
+dnl Get the cflags and libraries from the gtk-config-2.0 script
+dnl
+AC_ARG_WITH(gtk-prefix,[  --with-gtk-prefix=PFX   Prefix where GTK is installed (optional)],
+            gtk_config_prefix="$withval", gtk_config_prefix="")
+AC_ARG_WITH(gtk-exec-prefix,[  --with-gtk-exec-prefix=PFX Exec prefix where GTK is installed (optional)],
+            gtk_config_exec_prefix="$withval", gtk_config_exec_prefix="")
+AC_ARG_ENABLE(gtktest, [  --disable-gtktest       Do not try to compile and run a test GTK program],
+		    , enable_gtktest=yes)
+
+  for module in . $4
+  do
+      case "$module" in
+         gthread) 
+             gtk_config_args="$gtk_config_args gthread"
+         ;;
+      esac
+  done
+
+  if test x$gtk_config_exec_prefix != x ; then
+     gtk_config_args="$gtk_config_args --exec-prefix=$gtk_config_exec_prefix"
+     if test x${GTK_CONFIG_2_0+set} != xset ; then
+        GTK_CONFIG_2_0=$gtk_config_exec_prefix/bin/gtk-config-2.0
+     fi
+  fi
+  if test x$gtk_config_prefix != x ; then
+     gtk_config_args="$gtk_config_args --prefix=$gtk_config_prefix"
+     if test x${GTK_CONFIG_2_0+set} != xset ; then
+        GTK_CONFIG_2_0=$gtk_config_prefix/bin/gtk-config-2.0
+     fi
+  fi
+
+  AC_PATH_PROG(GTK_CONFIG_2_0, gtk-config-2.0, no)
+  min_gtk_version=ifelse([$1], ,1.3.1,$1)
+  AC_MSG_CHECKING(for GTK - version >= $min_gtk_version)
+  no_gtk=""
+  if test "$GTK_CONFIG_2_0" = "no" ; then
+    no_gtk=yes
+  else
+    GTK_CFLAGS=`$GTK_CONFIG_2_0 $gtk_config_args --cflags`
+    GTK_LIBS=`$GTK_CONFIG_2_0 $gtk_config_args --libs`
+    gtk_config_major_version=`$GTK_CONFIG_2_0 $gtk_config_args --version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
+    gtk_config_minor_version=`$GTK_CONFIG_2_0 $gtk_config_args --version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
+    gtk_config_micro_version=`$GTK_CONFIG_2_0 $gtk_config_args --version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
+    if test "x$enable_gtktest" = "xyes" ; then
+      ac_save_CFLAGS="$CFLAGS"
+      ac_save_LIBS="$LIBS"
+      CFLAGS="$CFLAGS $GTK_CFLAGS"
+      LIBS="$GTK_LIBS $LIBS"
+dnl
+dnl Now check if the installed GTK is sufficiently new. (Also sanity
+dnl checks the results of gtk-config-2.0 to some extent
+dnl
+      rm -f conf.gtktest
+      AC_TRY_RUN([
+#include <gtk/gtk.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int 
+main ()
+{
+  int major, minor, micro;
+  char *tmp_version;
+
+  system ("touch conf.gtktest");
+
+  /* HP/UX 9 (%@#!) writes to sscanf strings */
+  tmp_version = g_strdup("$min_gtk_version");
+  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+     printf("%s, bad version string\n", "$min_gtk_version");
+     exit(1);
+   }
+
+  if ((gtk_major_version != $gtk_config_major_version) ||
+      (gtk_minor_version != $gtk_config_minor_version) ||
+      (gtk_micro_version != $gtk_config_micro_version))
+    {
+      printf("\n*** 'gtk-config-2.0 --version' returned %d.%d.%d, but GTK+ (%d.%d.%d)\n", 
+             $gtk_config_major_version, $gtk_config_minor_version, $gtk_config_micro_version,
+             gtk_major_version, gtk_minor_version, gtk_micro_version);
+      printf ("*** was found! If gtk-config-2.0 was correct, then it is best\n");
+      printf ("*** to remove the old version of GTK+. You may also be able to fix the error\n");
+      printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n");
+      printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n");
+      printf("*** required on your system.\n");
+      printf("*** If gtk-config-2.0 was wrong, set the environment variable GTK_CONFIG_2_0\n");
+      printf("*** to point to the correct copy of gtk-config-2.0, and remove the file config.cache\n");
+      printf("*** before re-running configure\n");
+    } 
+#if defined (GTK_MAJOR_VERSION) && defined (GTK_MINOR_VERSION) && defined (GTK_MICRO_VERSION)
+  else if ((gtk_major_version != GTK_MAJOR_VERSION) ||
+	   (gtk_minor_version != GTK_MINOR_VERSION) ||
+           (gtk_micro_version != GTK_MICRO_VERSION))
+    {
+      printf("*** GTK+ header files (version %d.%d.%d) do not match\n",
+	     GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
+      printf("*** library (version %d.%d.%d)\n",
+	     gtk_major_version, gtk_minor_version, gtk_micro_version);
+    }
+#endif /* defined (GTK_MAJOR_VERSION) ... */
+  else
+    {
+      if ((gtk_major_version > major) ||
+        ((gtk_major_version == major) && (gtk_minor_version > minor)) ||
+        ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro)))
+      {
+        return 0;
+       }
+     else
+      {
+        printf("\n*** An old version of GTK+ (%d.%d.%d) was found.\n",
+               gtk_major_version, gtk_minor_version, gtk_micro_version);
+        printf("*** You need a version of GTK+ newer than %d.%d.%d. The latest version of\n",
+	       major, minor, micro);
+        printf("*** GTK+ is always available from ftp://ftp.gtk.org.\n");
+        printf("***\n");
+        printf("*** If you have already installed a sufficiently new version, this error\n");
+        printf("*** probably means that the wrong copy of the gtk-config-2.0 shell script is\n");
+        printf("*** being found. The easiest way to fix this is to remove the old version\n");
+        printf("*** of GTK+, but you can also set the GTK_CONFIG_2_0 environment to point to the\n");
+        printf("*** correct copy of gtk-config-2.0. (In this case, you will have to\n");
+        printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n");
+        printf("*** so that the correct libraries are found at run-time))\n");
+      }
+    }
+  return 1;
+}
+],, no_gtk=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+     fi
+  fi
+  if test "x$no_gtk" = x ; then
+     AC_MSG_RESULT(yes (version $gtk_config_major_version.$gtk_config_minor_version.$gtk_config_micro_version))
+     ifelse([$2], , :, [$2])     
+  else
+     AC_MSG_RESULT(no)
+     if test "$GTK_CONFIG_2_0" = "no" ; then
+       echo "*** The gtk-config-2.0 script installed by GTK could not be found"
+       echo "*** If GTK was installed in PREFIX, make sure PREFIX/bin is in"
+       echo "*** your path, or set the GTK_CONFIG_2_0 environment variable to the"
+       echo "*** full path to gtk-config-2.0."
+     else
+       if test -f conf.gtktest ; then
+        :
+       else
+          echo "*** Could not run GTK test program, checking why..."
+          CFLAGS="$CFLAGS $GTK_CFLAGS"
+          LIBS="$LIBS $GTK_LIBS"
+          AC_TRY_LINK([
+#include <gtk/gtk.h>
+#include <stdio.h>
+],      [ return ((gtk_major_version) || (gtk_minor_version) || (gtk_micro_version)); ],
+        [ echo "*** The test program compiled, but did not run. This usually means"
+          echo "*** that the run-time linker is not finding GTK or finding the wrong"
+          echo "*** version of GTK. If it is not finding GTK, you'll need to set your"
+          echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
+          echo "*** to the installed location  Also, make sure you have run ldconfig if that"
+          echo "*** is required on your system"
+	  echo "***"
+          echo "*** If you have an old version installed, it is best to remove it, although"
+          echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"
+          echo "***"
+          echo "*** If you have a RedHat 5.0 system, you should remove the GTK package that"
+          echo "*** came with the system with the command"
+          echo "***"
+          echo "***    rpm --erase --nodeps gtk gtk-devel" ],
+        [ echo "*** The test program failed to compile or link. See the file config.log for the"
+          echo "*** exact error that occured. This usually means GTK was incorrectly installed"
+          echo "*** or that you have moved GTK since it was installed. In the latter case, you"
+          echo "*** may want to edit the gtk-config-2.0 script: $GTK_CONFIG_2_0" ])
+          CFLAGS="$ac_save_CFLAGS"
+          LIBS="$ac_save_LIBS"
+       fi
+     fi
+     GTK_CFLAGS=""
+     GTK_LIBS=""
+     ifelse([$3], , :, [$3])
+  fi
+  AC_SUBST(GTK_CFLAGS)
+  AC_SUBST(GTK_LIBS)
+  rm -f conf.gtktest
+])

contrib/Makefile.in

@@ -8,6 +8,8 @@ all:
 clean:
 	cd src; make clean
 	cd samples; make clean
+	cd utils; make clean
+    
 
 samples:
 	cd samples; make

contrib/configure

@@ -817,12 +817,16 @@ trap 'rm -fr `echo "
             src/ogl/Makefile
             src/mmedia/Makefile
             src/stc/Makefile
+            src/xml/Makefile
             samples/Makefile
             samples/mmedia/Makefile
             samples/ogl/Makefile
             samples/ogl/ogledit/Makefile
             samples/ogl/studio/Makefile
             samples/stc/Makefile
+            utils/Makefile
+            utils/wxrc/Makefile
+            utils/wxrcedit/Makefile
          " | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
 EOF
 cat >> $CONFIG_STATUS <<EOF
@@ -906,12 +910,16 @@ CONFIG_FILES=\${CONFIG_FILES-"Makefile
             src/ogl/Makefile
             src/mmedia/Makefile
             src/stc/Makefile
+            src/xml/Makefile
             samples/Makefile
             samples/mmedia/Makefile
             samples/ogl/Makefile
             samples/ogl/ogledit/Makefile
             samples/ogl/studio/Makefile
             samples/stc/Makefile
+            utils/Makefile
+            utils/wxrc/Makefile
+            utils/wxrcedit/Makefile
          "}
 EOF
 cat >> $CONFIG_STATUS <<\EOF

contrib/configure.in

@@ -42,10 +42,14 @@ AC_OUTPUT([
             src/ogl/Makefile
             src/mmedia/Makefile
             src/stc/Makefile
+            src/xml/Makefile
             samples/Makefile
             samples/mmedia/Makefile
             samples/ogl/Makefile
             samples/ogl/ogledit/Makefile
             samples/ogl/studio/Makefile
             samples/stc/Makefile
+            utils/Makefile
+            utils/wxrc/Makefile
+            utils/wxrcedit/Makefile
          ])

contrib/docs/.cvsignore

@@ -1,5 +0,0 @@
-html
-htmlhelp
-pdf
-winhelp
-htb

contrib/docs/latex/mmedia/sndfile.tex

@@ -214,15 +214,30 @@ been set. In all other cases, you must return FALSE.
 \membersection{wxSoundFileStream::RepositionStream}\label{wxsoundfilestreamrepositionstream}
 \func{bool}{RepositionStream}{\param{wxUint32 }{position}}
 
+This is called by wxSoundFileStream::SetPosition to seek the input stream
+to the right position. This must be overidden by the file codec class.
+The position is relative to the beginning of the samples.
+If it is impossible (as for a piped input stream), you must return FALSE.
 
 \membersection{wxSoundFileStream::FinishPreparation}\label{wxsoundfilestreamfinishpreparation}
 \func{void}{FinishPreparation}{\param{wxUint32 }{len}}
 
+This is an internal function but it must called by the file codec class when
+the "playing" preparation is finished and you know the size of the stream.
+If it is an {\it infinite} stream, you should set this to wxSOUND\_INFINITE\_TIME.
 
 \membersection{wxSoundFileStream::GetData}\label{wxsoundfilestreamgetdata}
 \func{wxUint32}{GetData}{\param{void* }{buffer}, \param{wxUint32 }{len}}
 
+This is called by wxSoundFileStream when it needs to get new sound data to
+send to the device driver (or to a conversion codec). This must be eventually
+overidden by the file codec class. The default behaviour is simply to read from
+the input stream.
 
 \membersection{wxSoundFileStream::PutData}\label{wxsoundfilestreamputdata}
 \func{wxUint32}{PutData}{\param{const void* }{buffer}, \param{wxUint32 }{len}}
 
+This is called by wxSoundFileStream when it needs to put new sound data received
+from the device driver (or from a conversion codec). This must be eventually
+overidden by the file codec class. The default behaviour is simply to write to
+the input stream.

contrib/docs/latex/mmedia/sndrter.tex

@@ -6,8 +6,8 @@
 
 \section{\class{wxSoundRouterStream}}\label{wxsoundrouterstream}
 
-
+This is the router "codec" class. It should do codec routing when the device
-Codec router class
+driver does not deal with a format.
 
 \wxheading{Derived from}
 
@@ -17,43 +17,21 @@ Codec router class
 
 \latexignore{\rtfignore{\wxheading{Members}}}
 
-
 \membersection{wxSoundRouterStream::wxSoundRouterStream}\label{wxsoundrouterstreamwxsoundrouterstream}
-
 \func{}{wxSoundRouterStream}{\param{wxSoundStream\& }{sndio}}
 
+\helpref{wxSoundCodec}{wxsoundcodec}
+
 
 \membersection{wxSoundRouterStream::\destruct{wxSoundRouterStream}}\label{wxsoundrouterstreamdtor}
-
 \func{}{\destruct{wxSoundRouterStream}}{\void}
 
-
+Destructor.
-\membersection{wxSoundRouterStream::Read}\label{wxsoundrouterstreamread}
-
-\func{wxSoundStream\&}{Read}{\param{void* }{buffer}, \param{wxUint32 }{len}}
-
-
-\membersection{wxSoundRouterStream::Write}\label{wxsoundrouterstreamwrite}
-
-\func{wxSoundStream\&}{Write}{\param{const void* }{buffer}, \param{wxUint32 }{len}}
-
 
 \membersection{wxSoundRouterStream::SetSoundFormat}\label{wxsoundrouterstreamsetsoundformat}
-
 \func{bool}{SetSoundFormat}{\param{const wxSoundFormatBase\& }{format}}
 
-
+SetSoundFormat will first try to setup the device driver with the specified
-\membersection{wxSoundRouterStream::StartProduction}\label{wxsoundrouterstreamstartproduction}
+format. If this fails, it will try to find a codec which will convert the
-
+input format to a valid format for the device driver. It uses an internal
-\func{bool}{StartProduction}{\param{int }{evt}}
+codec database.
-
-
-\membersection{wxSoundRouterStream::StopProduction}\label{wxsoundrouterstreamstopproduction}
-
-\func{bool}{StopProduction}{\void}
-
-
-\membersection{wxSoundRouterStream::GetBestSize}\label{wxsoundrouterstreamgetbestsize}
-
-\constfunc{wxUint32}{GetBestSize}{\void}
-

contrib/include/wx/mmedia/cdbase.h

@@ -27,7 +27,7 @@ class WXDLLEXPORT wxCDAudio : public wxObject {
 public:
   typedef enum { PLAYING, PAUSED, STOPPED } CDstatus;
   // Table of contents manager
-  class CDtoc {
+  class WXDLLEXPORT CDtoc {
   protected:
     wxCDtime *tracks_time, *tracks_pos;
     wxCDtime total_time;

contrib/include/wx/mmedia/sndaiff.h

@@ -22,7 +22,7 @@
 // AIFF codec
 //
 
-class wxSoundAiff: public wxSoundFileStream {
+class WXDLLEXPORT wxSoundAiff: public wxSoundFileStream {
 public:
     wxSoundAiff(wxInputStream& stream, wxSoundStream& io_sound);
     wxSoundAiff(wxOutputStream& stream, wxSoundStream& io_sound);

contrib/include/wx/mmedia/sndbase.h

@@ -112,7 +112,7 @@ class WXDLLEXPORT wxSoundFormatBase {
 // Base class for sound streams
 //
 
-class wxSoundStream {
+class WXDLLEXPORT wxSoundStream {
  public:
   wxSoundStream();
   virtual ~wxSoundStream();

contrib/include/wx/mmedia/sndcodec.h

@@ -15,7 +15,7 @@
 #include "wx/defs.h"
 #include "wx/mmedia/sndbase.h"
 
-class wxSoundStreamCodec: public wxSoundStream {
+class WXDLLEXPORT wxSoundStreamCodec: public wxSoundStream {
  public:
   wxSoundStreamCodec(wxSoundStream& snd_io);
   ~wxSoundStreamCodec();

contrib/include/wx/mmedia/sndcpcm.h

@@ -20,7 +20,7 @@
 // PCM converter class
 //
 
-class wxSoundStreamPcm: public wxSoundStreamCodec {
+class WXDLLEXPORT wxSoundStreamPcm: public wxSoundStreamCodec {
 public:
     typedef void (*ConverterType)(const void *buf_in, void *buf_out,
                                   wxUint32 len);

contrib/include/wx/mmedia/sndmsad.h

@@ -5,8 +5,8 @@
 // Author: Guilhem Lavaux <lavaux@easynet.fr> (C) 2000
 // CVSID: $Id$
 // --------------------------------------------------------------------------
-#ifndef _WX_SNDULAW_H
+#ifndef _WX_SNDMSAD_H
-#define _WX_SNDULAW_H
+#define _WX_SNDMSAD_H
 
 #ifdef __GNUG__
 #pragma interface "sndmsad.h"
@@ -17,46 +17,52 @@
 #include "wx/mmedia/sndcodec.h"
 #include "wx/mmedia/sndbase.h"
 
-WX_DEFINE_EXPORTED_ARRAY(wxUint16, wxMSAdpcmCoeffs);
+WX_DEFINE_EXPORTED_ARRAY(wxInt16, wxMSAdpcmCoeffs);
 
 //
 // MSADPCM format
 //
 class WXDLLEXPORT wxSoundFormatMSAdpcm: public wxSoundFormatBase {
- public:
+public:
-  wxSoundFormatMSAdpcm();
+    wxSoundFormatMSAdpcm();
-  ~wxSoundFormatMSAdpcm();
+    ~wxSoundFormatMSAdpcm();
     
-  void SetSampleRate(wxUint32 srate);
+    void SetSampleRate(wxUint32 srate);
-  wxUint32 GetSampleRate() const;
+    wxUint32 GetSampleRate() const;
     
-  void SetSamplesBlock(wxUint16 sampblock);
+    void SetCoefs(wxInt16 **coefs, wxUint16 ncoefs, wxUint16 coefs_len);
-  wxUint16 GetSamplesBlock() const;
+    void GetCoefs(wxInt16 **&coefs, wxUint16& ncoefs,
+                  wxUint16& coefs_len) const;
 
-  void SetCoefs(wxMSAdpcmCoefs& coefs);
+    void SetBlockSize(wxUint16 block_size);
-  wxMSAdpcmCoefs& GetCoefs() const;
+    wxUint16 GetBlockSize() const;
     
-  wxSoundFormatType GetType() const { return wxSOUND_ULAW; }
+    void SetChannels(wxUint16 channels);
-  wxSoundFormatBase *Clone() const;
+    wxUint16 GetChannels() const;
     
-  wxUint32 GetTimeFromBytes(wxUint32 bytes) const;
+    wxSoundFormatType GetType() const { return wxSOUND_MSADPCM; }
-  wxUint32 GetBytesFromTime(wxUint32 time) const;
+    wxSoundFormatBase *Clone() const;
     
-  bool operator !=(const wxSoundFormatBase& frmt2) const;
+    wxUint32 GetTimeFromBytes(wxUint32 bytes) const;
+    wxUint32 GetBytesFromTime(wxUint32 time) const;
     
- protected:
+    bool operator !=(const wxSoundFormatBase& frmt2) const;
-  wxUint32 m_srate;
+
-  wxMSAdpcmCoefs *m_coefs;
+protected:
+    wxUint32 m_srate, m_nchannels;
+    wxInt16 **m_coefs;
+    wxUint16 m_ncoefs, m_coefs_len;
+    wxUint16 m_block_size;
 };
 
 //
 // MS ADPCM converter class
 //
 class WXDLLEXPORT wxSoundRouterStream;
-class WXDLLEXPORT wxSoundStreamAdpcm: public wxSoundStreamCodec {
+class WXDLLEXPORT wxSoundStreamMSAdpcm: public wxSoundStreamCodec {
 public:
-    wxSoundStreamAdpcm(wxSoundStream& sndio);
+    wxSoundStreamMSAdpcm(wxSoundStream& sndio);
-    ~wxSoundStreamAdpcm();
+    ~wxSoundStreamMSAdpcm();
     
     wxSoundStream& Read(void *buffer, wxUint32 len);
     wxSoundStream& Write(const void *buffer, wxUint32 len);
@@ -67,6 +73,32 @@ public:
 
 protected:
     wxSoundRouterStream *m_router;
+
+    typedef struct {
+        wxInt32 predictor;
+        wxInt16 samp1;
+        wxInt16 samp2;
+        wxInt16 coeff[2];
+        wxInt32 iDelta;
+    } AdpcmState;
+
+    AdpcmState m_state[1];
+    
+    bool     m_got_header;
+    bool     m_stereo;
+    wxInt16  **m_coefs;
+    wxUint16 m_block_size;
+    wxUint16 m_ncoefs;
+    wxUint16 m_next_block;
+    
+protected:
+    wxUint32 DecodeMonoADPCM(const void *in_buffer, void *out_buffer,
+                             wxUint32 in_len);
+    wxUint32 DecodeStereoADPCM(const void *in_buffer, void *out_buffer,
+                               wxUint32 in_len);
+    void Nibble(wxInt8 nyb,
+                AdpcmState *state,
+                wxInt16 **out_buffer);
 };
 
 #endif

contrib/include/wx/mmedia/sndoss.h

@@ -21,7 +21,7 @@
 // OSS output class
 //
 
-class wxSoundStreamOSS : public wxSoundStream {
+class WXDLLEXPORT wxSoundStreamOSS : public wxSoundStream {
  public:
   wxSoundStreamOSS(const wxString& dev_name = wxT("/dev/dsp"));
   ~wxSoundStreamOSS();

contrib/include/wx/mmedia/sndwav.h

@@ -42,12 +42,18 @@ protected:
     wxUint32 GetData(void *buffer, wxUint32 len);
     wxUint32 PutData(const void *buffer, wxUint32 len);
     
-    bool HandleOutputPCM(wxDataInputStream& data, wxUint16 channels,
+    bool HandleOutputPCM(wxDataInputStream& data, wxUint32 len,
-                         wxUint32 sample_fq, wxUint32 byte_p_sec,
+                         wxUint16 channels, wxUint32 sample_fq,
-                         wxUint16 byte_p_spl, wxUint16 bits_p_spl);
+                         wxUint32 byte_p_sec, wxUint16 byte_p_spl,
-    bool HandleOutputG721(wxDataInputStream& data, wxUint16 channels,
+                         wxUint16 bits_p_spl);
-                          wxUint32 sample_fq, wxUint32 byte_p_sec,
+    bool HandleOutputMSADPCM(wxDataInputStream& data, wxUint32 len,
-                          wxUint16 byte_p_spl, wxUint16 bits_p_spl);
+                             wxUint16 channels, wxUint32 sample_fq,
+                             wxUint32 byte_p_sec, wxUint16 byte_p_spl,
+                             wxUint16 bits_p_spl);
+    bool HandleOutputG721(wxDataInputStream& data, wxUint32 len,
+                          wxUint16 channels, wxUint32 sample_fq,
+                          wxUint32 byte_p_sec, wxUint16 byte_p_spl,
+                          wxUint16 bits_p_spl);
     wxSoundFormatBase *HandleInputPCM(wxDataOutputStream& data);
     wxSoundFormatBase *HandleInputG72X(wxDataOutputStream& data);
 

contrib/include/wx/stc/SciLexer.h

@@ -0,0 +1,181 @@
+// Scintilla source code edit control
+// SciLexer - interface to the added lexer functions in the SciLexer version of the edit control
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SCILEXER_H
+#define SCILEXER_H
+
+// SciLexer features - not in standard Scintilla
+
+#define SCLEX_CONTAINER 0
+#define SCLEX_NULL 1
+#define SCLEX_PYTHON 2
+#define SCLEX_CPP 3
+#define SCLEX_HTML 4
+#define SCLEX_XML 5
+#define SCLEX_PERL 6
+#define SCLEX_SQL 7
+#define SCLEX_VB 8
+#define SCLEX_PROPERTIES 9
+#define SCLEX_ERRORLIST 10
+#define SCLEX_MAKEFILE 11
+#define SCLEX_BATCH 12
+#define SCLEX_XCODE 13
+#define SCLEX_LATEX 14
+
+// Lexical states for SCLEX_PYTHON
+#define SCE_P_DEFAULT 0
+#define SCE_P_COMMENTLINE 1
+#define SCE_P_NUMBER 2
+#define SCE_P_STRING 3
+#define SCE_P_CHARACTER 4
+#define SCE_P_WORD 5
+#define SCE_P_TRIPLE 6
+#define SCE_P_TRIPLEDOUBLE 7
+#define SCE_P_CLASSNAME 8
+#define SCE_P_DEFNAME 9
+#define SCE_P_OPERATOR 10
+#define SCE_P_IDENTIFIER 11
+#define SCE_P_COMMENTBLOCK 12
+#define SCE_P_STRINGEOL 13
+
+// Lexical states for SCLEX_CPP, SCLEX_VB
+#define SCE_C_DEFAULT 0
+#define SCE_C_COMMENT 1
+#define SCE_C_COMMENTLINE 2
+#define SCE_C_COMMENTDOC 3
+#define SCE_C_NUMBER 4
+#define SCE_C_WORD 5
+#define SCE_C_STRING 6
+#define SCE_C_CHARACTER 7
+#define SCE_C_UUID 8
+#define SCE_C_PREPROCESSOR 9
+#define SCE_C_OPERATOR 10
+#define SCE_C_IDENTIFIER 11
+#define SCE_C_STRINGEOL 12
+
+// Lexical states for SCLEX_HTML, SCLEX_xML
+#define SCE_H_DEFAULT 0
+#define SCE_H_TAG 1
+#define SCE_H_TAGUNKNOWN 2
+#define SCE_H_ATTRIBUTE 3
+#define SCE_H_ATTRIBUTEUNKNOWN 4
+#define SCE_H_NUMBER 5
+#define SCE_H_DOUBLESTRING 6
+#define SCE_H_SINGLESTRING 7
+#define SCE_H_OTHER 8
+#define SCE_H_COMMENT 9
+#define SCE_H_ENTITY 10
+// XML and ASP
+#define SCE_H_TAGEND 11
+#define SCE_H_XMLSTART 12
+#define SCE_H_XMLEND 13
+#define SCE_H_SCRIPT 14
+#define SCE_H_ASP 15
+#define SCE_H_ASPAT 16
+// Embedded Javascript
+#define SCE_HJ_START 40
+#define SCE_HJ_DEFAULT 41
+#define SCE_HJ_COMMENT 42
+#define SCE_HJ_COMMENTLINE 43
+#define SCE_HJ_COMMENTDOC 44
+#define SCE_HJ_NUMBER 45
+#define SCE_HJ_WORD 46
+#define SCE_HJ_KEYWORD 47
+#define SCE_HJ_DOUBLESTRING 48
+#define SCE_HJ_SINGLESTRING 49
+#define SCE_HJ_SYMBOLS 50
+#define SCE_HJ_STRINGEOL 51
+// ASP Javascript
+#define SCE_HJA_START 55
+#define SCE_HJA_DEFAULT 56
+#define SCE_HJA_COMMENT 57
+#define SCE_HJA_COMMENTLINE 58
+#define SCE_HJA_COMMENTDOC 59
+#define SCE_HJA_NUMBER 60
+#define SCE_HJA_WORD 61
+#define SCE_HJA_KEYWORD 62
+#define SCE_HJA_DOUBLESTRING 63
+#define SCE_HJA_SINGLESTRING 64
+#define SCE_HJA_SYMBOLS 65
+#define SCE_HJA_STRINGEOL 66
+// Embedded VBScript
+#define SCE_HB_START 70
+#define SCE_HB_DEFAULT 71
+#define SCE_HB_COMMENTLINE 72
+#define SCE_HB_NUMBER 73
+#define SCE_HB_WORD 74
+#define SCE_HB_STRING 75
+#define SCE_HB_IDENTIFIER 76
+#define SCE_HB_STRINGEOL 77
+// ASP VBScript
+#define SCE_HBA_START 80
+#define SCE_HBA_DEFAULT 81
+#define SCE_HBA_COMMENTLINE 82
+#define SCE_HBA_NUMBER 83
+#define SCE_HBA_WORD 84
+#define SCE_HBA_STRING 85
+#define SCE_HBA_IDENTIFIER 86
+#define SCE_HBA_STRINGEOL 87
+// Embedded Python
+#define SCE_HP_START 90
+#define SCE_HP_DEFAULT 91
+#define SCE_HP_COMMENTLINE 92
+#define SCE_HP_NUMBER 93
+#define SCE_HP_STRING 94
+#define SCE_HP_CHARACTER 95
+#define SCE_HP_WORD 96
+#define SCE_HP_TRIPLE 97
+#define SCE_HP_TRIPLEDOUBLE 98
+#define SCE_HP_CLASSNAME 99
+#define SCE_HP_DEFNAME 100
+#define SCE_HP_OPERATOR 101
+#define SCE_HP_IDENTIFIER 102
+// ASP Python
+#define SCE_HPA_START 105
+#define SCE_HPA_DEFAULT 106
+#define SCE_HPA_COMMENTLINE 107
+#define SCE_HPA_NUMBER 108
+#define SCE_HPA_STRING 109
+#define SCE_HPA_CHARACTER 110
+#define SCE_HPA_WORD 111
+#define SCE_HPA_TRIPLE 112
+#define SCE_HPA_TRIPLEDOUBLE 113
+#define SCE_HPA_CLASSNAME 114
+#define SCE_HPA_DEFNAME 115
+#define SCE_HPA_OPERATOR 116
+#define SCE_HPA_IDENTIFIER 117
+
+// Lexical states for SCLEX_PERL
+#define SCE_PL_DEFAULT 0
+#define SCE_PL_HERE 1
+#define SCE_PL_COMMENTLINE 2
+#define SCE_PL_POD 3
+#define SCE_PL_NUMBER 4
+#define SCE_PL_WORD 5
+#define SCE_PL_STRING 6
+#define SCE_PL_CHARACTER 7
+#define SCE_PL_PUNCTUATION 8
+#define SCE_PL_PREPROCESSOR 9
+#define SCE_PL_OPERATOR 10
+#define SCE_PL_IDENTIFIER 11
+#define SCE_PL_SCALAR 12
+#define SCE_PL_ARRAY 13
+#define SCE_PL_HASH 14
+#define SCE_PL_SYMBOLTABLE 15
+#define SCE_PL_REF 16
+#define SCE_PL_REGEX 17
+#define SCE_PL_REGSUBST 18
+#define SCE_PL_LONGQUOTE 19
+#define SCE_PL_BACKTICKS 20
+#define SCE_PL_DATASECTION 21
+    
+// Lexical states for SCLEX_LATEX
+#define SCE_L_DEFAULT 0
+#define SCE_L_COMMAND 1
+#define SCE_L_TAG 2
+#define SCE_L_MATH 3
+#define SCE_L_COMMENT 4
+
+#endif

contrib/include/wx/xml/xh_all.h

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_all.h
+// Purpose:     includes all xh_*.h files
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_ALL_H_
+#define _WX_XH_ALL_H_
+
+
+// Existing handlers:
+
+#include "wx/xml/xh_menu.h"
+#include "wx/xml/xh_panel.h"
+#include "wx/xml/xh_dlg.h"
+#include "wx/xml/xh_bttn.h"
+#include "wx/xml/xh_chckb.h"
+#include "wx/xml/xh_gauge.h"
+#include "wx/xml/xh_html.h"
+#include "wx/xml/xh_spin.h"
+#include "wx/xml/xh_sttxt.h"
+#include "wx/xml/xh_slidr.h"
+#include "wx/xml/xh_radbt.h"
+#include "wx/xml/xh_radbx.h"
+#include "wx/xml/xh_combo.h"
+#include "wx/xml/xh_chckl.h"
+#include "wx/xml/xh_choic.h"
+#include "wx/xml/xh_sizer.h"
+#include "wx/xml/xh_stbmp.h"
+#include "wx/xml/xh_notbk.h"
+#include "wx/xml/xh_text.h"
+#include "wx/xml/xh_listb.h"
+
+#endif // _WX_XMLRES_H_

contrib/include/wx/xml/xh_bttn.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_bttn.h
+// Purpose:     XML resource handler for buttons
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BTTN_H_
+#define _WX_XH_BTTN_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_bttn.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+class WXDLLEXPORT wxButtonXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxButtonXmlHandler() : wxXmlResourceHandler() {}
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_BTTN_H_

contrib/include/wx/xml/xh_chckb.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_chckb.h
+// Purpose:     XML resource handler for wxCheckBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHCKB_H_
+#define _WX_XH_CHCKB_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_chckb.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_CHECKBOX
+
+class WXDLLEXPORT wxCheckBoxXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxCheckBoxXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+
+#endif // _WX_XH_CHECKBOX_H_
+

contrib/include/wx/xml/xh_chckl.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_chckl.h
+// Purpose:     XML resource handler for wxCheckListBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHCKL_H_
+#define _WX_XH_CHCKL_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_chckl.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+class WXDLLEXPORT wxCheckListXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxCheckListXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+    private:
+        bool m_InsideBox;
+        wxArrayString strList;
+};
+
+
+
+#endif // _WX_XH_CHECKLIST_H_

contrib/include/wx/xml/xh_choic.h

@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_choic.h
+// Purpose:     XML resource handler for wxChoice
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHOIC_H_
+#define _WX_XH_CHOIC_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_choic.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+class WXDLLEXPORT wxChoiceXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxChoiceXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+    private:
+        bool m_InsideBox;
+        wxArrayString strList;
+};
+
+
+#endif // _WX_XH_CHOIC_H_

contrib/include/wx/xml/xh_combo.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_combo.h
+// Purpose:     XML resource handler for wxComboBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_COMBO_H_
+#define _WX_XH_COMBO_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_combo.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+#if wxUSE_COMBOBOX
+
+class WXDLLEXPORT wxComboBoxXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxComboBoxXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+    private:
+        bool m_InsideBox;
+        wxArrayString strList;
+};
+
+#endif
+
+#endif // _WX_XH_COMBO_H_

contrib/include/wx/xml/xh_dlg.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_dlg.h
+// Purpose:     XML resource handler for dialogs
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_DLG_H_
+#define _WX_XH_DLG_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_dlg.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+class WXDLLEXPORT wxDialogXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxDialogXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_DLG_H_

contrib/include/wx/xml/xh_gauge.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_gauge.h
+// Purpose:     XML resource handler for wxGauge
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_GAUGE_H_
+#define _WX_XH_GAUGE_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_gauge.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_GAUGE
+
+#include "wx/xml/xmlres.h"
+
+
+class WXDLLEXPORT wxGaugeXmlHandler : public wxXmlResourceHandler
+{
+    enum 
+    {
+        wxGAUGE_DEFAULT_RANGE = 100
+    };
+
+    public:
+        wxGaugeXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_GAUGE_H_

contrib/include/wx/xml/xh_html.h

@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_html.h
+// Purpose:     XML resource handler for wxHtmlWindow
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_HTML_H_
+#define _WX_XH_HTML_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_html.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+class WXDLLEXPORT wxHtmlWindowXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxHtmlWindowXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_SLIDER_H_

contrib/include/wx/xml/xh_listb.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_listb.h
+// Purpose:     XML resource handler for wxListbox
+// Author:      Bob Mitchell & Vaclav Slavik
+// Created:     2000/07/29
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell & Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_LISTB_H_
+#define _WX_XH_LISTB_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_listb.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+#if wxUSE_LISTBOX
+
+class WXDLLEXPORT wxListBoxXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxListBoxXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+    private:
+        bool m_InsideBox;
+        wxArrayString strList;
+};
+
+#endif
+
+#endif // _WX_XH_LISTB_H_

contrib/include/wx/xml/xh_menu.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_menu.h
+// Purpose:     XML resource handler for menus/menubars
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_MENU_H_
+#define _WX_XH_MENU_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_menu.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+class WXDLLEXPORT wxMenuXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxMenuXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+        
+    private:
+        bool m_InsideMenu;
+};
+
+class WXDLLEXPORT wxMenuBarXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxMenuBarXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_MENU_H_

contrib/include/wx/xml/xh_notbk.h

@@ -0,0 +1,37 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_notbk.h
+// Purpose:     XML resource handler for wxNotebook
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_NOTBK_H_
+#define _WX_XH_NOTBK_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_notbk.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+#if wxUSE_NOTEBOOK
+
+class WXDLLEXPORT wxNotebook;
+
+class WXDLLEXPORT wxNotebookXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxNotebookXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+        
+    private:
+        bool m_IsInside;
+        wxNotebook *m_Notebook;
+};
+
+#endif
+
+#endif // _WX_XH_NOTBK_H_

contrib/include/wx/xml/xh_panel.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_panel.h
+// Purpose:     XML resource handler for panels
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_PANEL_H_
+#define _WX_XH_PANEL_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_panel.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+class WXDLLEXPORT wxPanelXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxPanelXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_PANEL_H_

contrib/include/wx/xml/xh_radbt.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_radbt.h
+// Purpose:     XML resource handler for radio buttons
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RADBT_H_
+#define _WX_XH_RADBT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_radbt.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_RADIOBOX
+
+class WXDLLEXPORT wxRadioButtonXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxRadioButtonXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_RADIOBUTTON_H_

contrib/include/wx/xml/xh_radbx.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_radbx.h
+// Purpose:     XML resource handler for radio box
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RADBX_H_
+#define _WX_XH_RADBX_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_radbx.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+#if wxUSE_RADIOBOX
+
+class WXDLLEXPORT wxRadioBoxXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxRadioBoxXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+    private:
+        bool m_InsideBox;
+        wxArrayString strList;
+};
+
+#endif
+
+#endif // _WX_XH_RADBX_H_

contrib/include/wx/xml/xh_sizer.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_sizer.h
+// Purpose:     XML resource handler for wxBoxSizer
+// Author:      Vaclav Slavik
+// Created:     2000/04/24
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SIZER_H_
+#define _WX_XH_SIZER_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_sizer.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+
+class WXDLLEXPORT wxSizer;
+
+class WXDLLEXPORT wxSizerXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxSizerXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+        
+    private:
+        bool m_IsInside;
+        wxSizer *m_ParentSizer;
+};
+
+
+#endif // _WX_XH_BOXSIZER_H_

contrib/include/wx/xml/xh_slidr.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_slidr.h
+// Purpose:     XML resource handler for wxSlider
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SLIDR_H_
+#define _WX_XH_SLIDR_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_slidr.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_SLIDER
+
+class WXDLLEXPORT wxSliderXmlHandler : public wxXmlResourceHandler
+{
+    enum 
+    {
+        wxSL_DEFAULT_VALUE = 0,
+        wxSL_DEFAULT_MIN = 0,
+        wxSL_DEFAULT_MAX = 100
+    };
+
+    public:
+        wxSliderXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_SLIDER_H_

contrib/include/wx/xml/xh_spin.h

@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_spin.h
+// Purpose:     XML resource handler for wxSpinButton
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SPIN_H_
+#define _WX_XH_SPIN_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_spin.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_SPINBTN
+class WXDLLEXPORT wxSpinButtonXmlHandler : public wxXmlResourceHandler
+{
+    enum 
+    {
+        wxSP_DEFAULT_VALUE = 0,
+        wxSP_DEFAULT_MIN = 0,
+        wxSP_DEFAULT_MAX = 100
+    };
+
+    public:
+        wxSpinButtonXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+#endif
+
+#if wxUSE_SPINCTRL
+class WXDLLEXPORT wxSpinCtrlXmlHandler : public wxXmlResourceHandler
+{
+    enum 
+    {
+        wxSP_DEFAULT_VALUE = 0,
+        wxSP_DEFAULT_MIN = 0,
+        wxSP_DEFAULT_MAX = 100
+    };
+
+    public:
+        wxSpinCtrlXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+#endif
+
+#endif // _WX_XH_SPIN_H_

contrib/include/wx/xml/xh_stbmp.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_stbmp.h
+// Purpose:     XML resource handler for wxStaticBitmap
+// Author:      Vaclav Slavik
+// Created:     2000/04/22
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STBMP_H_
+#define _WX_XH_STBMP_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_stbmp.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+
+class WXDLLEXPORT wxStaticBitmapXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxStaticBitmapXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_STBMP_H_

contrib/include/wx/xml/xh_sttxt.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_sttxt.h
+// Purpose:     XML resource handler for wxStaticBitmap
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STTXT_H_
+#define _WX_XH_STTXT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_sttxt.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+
+class WXDLLEXPORT wxStaticTextXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxStaticTextXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_STBMP_H_

contrib/include/wx/xml/xh_text.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_text.h
+// Purpose:     XML resource handler for wxTextCtrl
+// Author:      Aleksandras Gluchovas
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Aleksandras Gluchovas
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TEXT_H_
+#define _WX_XH_TEXT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_text.h"
+#endif
+
+#include "wx/xml/xmlres.h"
+
+
+class WXDLLEXPORT wxTextCtrlXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxTextCtrlXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_TEXT_H_

contrib/include/wx/xml/xml.h

@@ -0,0 +1,239 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xml.h
+// Purpose:     wxXmlDocument - XML parser & data holder class
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XML_H_
+#define _WX_XML_H_
+
+#ifdef __GNUG__
+#pragma interface "xml.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/object.h"
+#include "wx/list.h"
+
+
+class WXDLLEXPORT wxXmlNode;
+class WXDLLEXPORT wxXmlProperty;
+class WXDLLEXPORT wxXmlDocument;
+class WXDLLEXPORT wxXmlIOHandler;
+class WXDLLEXPORT wxInputStream;
+class WXDLLEXPORT wxOutputStream;
+
+
+// Represents XML node type.
+enum wxXmlNodeType
+{
+    // note: values are synchronized with xmlElementType from libxml
+    wxXML_ELEMENT_NODE       =  1,
+    wxXML_ATTRIBUTE_NODE     =  2,
+    wxXML_TEXT_NODE          =  3,
+    wxXML_CDATA_SECTION_NODE =  4,
+    wxXML_ENTITY_REF_NODE    =  5,
+    wxXML_ENTITY_NODE        =  6,
+    wxXML_PI_NODE            =  7,
+    wxXML_COMMENT_NODE       =  8,
+    wxXML_DOCUMENT_NODE      =  9,
+    wxXML_DOCUMENT_TYPE_NODE = 10,
+    wxXML_DOCUMENT_FRAG_NODE = 11,
+    wxXML_NOTATION_NODE      = 12,
+    wxXML_HTML_DOCUMENT_NODE = 13
+};
+
+
+// Types of XML files:
+
+enum wxXmlIOType
+{
+    wxXML_IO_AUTO = 0, // detect it automatically
+    wxXML_IO_LIBXML,   // use libxml2 to parse/save XML document
+    wxXML_IO_BIN,      // save in binary uncompressed proprietary format
+    wxXML_IO_BINZ      // svae in binary zlib-compressed proprietary format
+};
+
+
+// Represents node property(ies).
+// Example: in <img src="hello.gif" id="3"/> "src" is property with value
+//          "hello.gif" and "id" is prop. with value "3".
+
+class WXDLLEXPORT wxXmlProperty
+{
+    public:
+        wxXmlProperty() : m_Next(NULL) {}
+        wxXmlProperty(const wxString& name, const wxString& value, wxXmlProperty *next)
+            : m_Name(name), m_Value(value), m_Next(next) {}
+        ~wxXmlProperty() { delete m_Next; }
+    
+        wxString GetName() const { return m_Name; }
+        wxString GetValue() const { return m_Value; }
+        wxXmlProperty *GetNext() const { return m_Next; }
+        
+        void SetName(const wxString& name) { m_Name = name; }
+        void SetValue(const wxString& value) { m_Value = value; }
+        void SetNext(wxXmlProperty *next) { m_Next = next; }
+
+    private:
+        wxString m_Name;
+        wxString m_Value;
+        wxXmlProperty *m_Next;
+};
+
+
+
+// Represents node in XML document. Node has name and may have content
+// and properties. Most common node types are wxXML_TEXT_NODE (name and props
+// are irrelevant) and wxXML_ELEMENT_NODE (e.g. in <title>hi</title> there is
+// element with name="title", irrelevant content and one child (wxXML_TEXT_NODE
+// with content="hi").
+
+class WXDLLEXPORT wxXmlNode
+{
+    public:
+        wxXmlNode() : m_Properties(NULL), m_Parent(NULL), 
+                      m_Children(NULL), m_Next(NULL) {}
+        wxXmlNode(wxXmlNode *parent,wxXmlNodeType type, 
+                  const wxString& name, const wxString& content,
+                  wxXmlProperty *props, wxXmlNode *next);
+        ~wxXmlNode() { delete m_Properties; delete m_Next; delete m_Children; }
+
+        // copy ctor & operator=. Note that this does NOT copy syblings
+        // and parent pointer, i.e. m_Parent and m_Next will be NULL
+        // after using copy ctor and are never unmodified by operator=.
+        // On the other hand, it DOES copy children and properties.
+        wxXmlNode(const wxXmlNode& node);
+        wxXmlNode& operator=(const wxXmlNode& node);
+        
+        // user-friendly creation:
+        wxXmlNode(wxXmlNodeType type, const wxString& name, 
+                  const wxString& content = wxEmptyString);
+        void AddChild(wxXmlNode *child);
+        void InsertChild(wxXmlNode *child, wxXmlNode *before_node);
+        bool RemoveChild(wxXmlNode *child);
+        void AddProperty(const wxString& name, const wxString& value);
+        bool DeleteProperty(const wxString& name);
+
+        // access methods:
+        wxXmlNodeType GetType() const { return m_Type; }
+        wxString GetName() const { return m_Name; }
+        wxString GetContent() const { return m_Content; }
+        
+        wxXmlNode *GetParent() const { return m_Parent; }
+        wxXmlNode *GetNext() const { return m_Next; }
+        wxXmlNode *GetChildren() const { return m_Children; }
+
+        wxXmlProperty *GetProperties() const { return m_Properties; }
+        bool GetPropVal(const wxString& propName, wxString *value) const;
+        wxString GetPropVal(const wxString& propName, const wxString& defaultVal) const;
+        bool HasProp(const wxString& propName) const;
+        
+        void SetType(wxXmlNodeType type) { m_Type = type; }
+        void SetName(const wxString& name) { m_Name = name; }
+        void SetContent(const wxString& con) { m_Content = con; }
+        
+        void SetParent(wxXmlNode *parent) { m_Parent = parent; }
+        void SetNext(wxXmlNode *next) { m_Next = next; }
+        void SetChildren(wxXmlNode *child) { m_Children = child; }
+        
+        void SetProperties(wxXmlProperty *prop) { m_Properties = prop; }
+        void AddProperty(wxXmlProperty *prop);
+
+    private:
+        wxXmlNodeType m_Type;
+        wxString m_Name;
+        wxString m_Content;
+        wxXmlProperty *m_Properties;
+        wxXmlNode *m_Parent, *m_Children, *m_Next;
+
+        void DoCopy(const wxXmlNode& node);
+};
+
+
+
+
+
+
+
+// This class holds XML data/document as parsed by libxml. Note that 
+// internal representation is independant on libxml and you can use 
+// it without libxml (see Load/SaveBinary).
+
+class WXDLLEXPORT wxXmlDocument : public wxObject
+{
+    public:
+        wxXmlDocument() : wxObject(), m_Version(_T("1.0")), m_Root(NULL)  {}
+        wxXmlDocument(const wxString& filename, wxXmlIOType io_type = wxXML_IO_AUTO);
+        wxXmlDocument(wxInputStream& stream, wxXmlIOType io_type = wxXML_IO_AUTO);
+        ~wxXmlDocument() { delete m_Root; }
+        
+        wxXmlDocument(const wxXmlDocument& doc);
+        wxXmlDocument& operator=(const wxXmlDocument& doc);
+    
+        // Parses .xml file and loads data. Returns TRUE on success, FALSE
+        // otherwise. 
+        // NOTE: Any call to this method will result into linking against libxml
+        //       and app's binary size will grow by ca. 250kB
+        bool Load(const wxString& filename, wxXmlIOType io_type = wxXML_IO_AUTO);
+        bool Load(wxInputStream& stream, wxXmlIOType io_type = wxXML_IO_AUTO);
+        
+        // Saves document as .xml file.
+        bool Save(const wxString& filename, wxXmlIOType io_type) const;
+        bool Save(wxOutputStream& stream, wxXmlIOType io_type) const;
+        
+        // Returns root node of the document.
+        wxXmlNode *GetRoot() const { return m_Root; }
+        
+        // Returns version of document (may be empty).
+        wxString GetVersion() const { return m_Version; }
+        // Returns encoding of document (may be empty).
+        wxString GetEncoding() const { return m_Encoding; }
+        
+        // Write-access methods:
+        void SetRoot(wxXmlNode *node) { delete m_Root ; m_Root = node; }
+        void SetVersion(const wxString& version) { m_Version = version; }
+        void SetEncoding(const wxString& encoding) { m_Encoding = encoding; }
+
+        static void AddHandler(wxXmlIOHandler *handler);
+        static void CleanUpHandlers();
+        static void InitStandardHandlers();
+
+    protected:
+        static wxList *sm_Handlers;
+
+    private:
+        wxString m_Version, m_Encoding;
+        wxXmlNode *m_Root;
+        
+        void DoCopy(const wxXmlDocument& doc);
+};
+
+
+
+// wxXmlIOHandler takes care of loading and/or saving XML data.
+// see xmlio.h for available handlers
+
+class WXDLLEXPORT wxXmlIOHandler : public wxObject
+{
+    public:
+        wxXmlIOHandler() {}
+        
+        virtual wxXmlIOType GetType() = 0;
+        virtual bool CanLoad(wxInputStream& stream) = 0;
+        virtual bool CanSave() = 0;
+        
+        virtual bool Load(wxInputStream& stream, wxXmlDocument& doc) = 0;
+        virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc) = 0;
+};
+
+
+
+
+
+#endif // _WX_XML_H_

contrib/include/wx/xml/xmlio.h

@@ -0,0 +1,72 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xmlio.h
+// Purpose:     wxXmlIOHandler - XML I/O classes
+// Author:      Vaclav Slavik
+// Created:     2000/07/24
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XMLIO_H_
+#define _WX_XMLIO_H_
+
+#ifdef __GNUG__
+#pragma interface "xmlio.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/xml/xml.h"
+
+
+class WXDLLEXPORT wxXmlIOHandlerBin : public wxXmlIOHandler
+{
+    public:
+        wxXmlIOHandlerBin() {}
+
+        virtual wxXmlIOType GetType() { return wxXML_IO_BIN; }
+        virtual bool CanLoad(wxInputStream& stream);
+        virtual bool CanSave() { return TRUE; }
+
+        virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
+        virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
+        
+    protected: 
+        wxString ReadHeader(wxInputStream& stream);
+        void WriteHeader(wxOutputStream& stream, const wxString& header);
+};
+
+
+
+#if wxUSE_ZLIB
+
+class WXDLLEXPORT wxXmlIOHandlerBinZ : public wxXmlIOHandlerBin
+{
+    public:
+        wxXmlIOHandlerBinZ() {}
+
+        virtual wxXmlIOType GetType() { return wxXML_IO_BINZ; }
+        virtual bool CanLoad(wxInputStream& stream);
+
+        virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
+        virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
+};
+
+#endif
+
+
+
+class WXDLLEXPORT wxXmlIOHandlerLibxml : public wxXmlIOHandler
+{
+    public:
+        virtual wxXmlIOType GetType() { return wxXML_IO_LIBXML; }
+        virtual bool CanLoad(wxInputStream& stream);
+        virtual bool CanSave();
+
+        virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
+        virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
+};
+
+
+#endif // _WX_XMLIO_H_

contrib/include/wx/xml/xmlres.h

@@ -0,0 +1,256 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xmlres.h
+// Purpose:     XML resources
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XMLRES_H_
+#define _WX_XMLRES_H_
+
+#ifdef __GNUG__
+#pragma interface "xmlres.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/dynarray.h"
+#include "wx/datetime.h"
+#include "wx/list.h"
+#include "wx/gdicmn.h"
+
+class WXDLLEXPORT wxMenu;
+class WXDLLEXPORT wxMenuBar;
+class WXDLLEXPORT wxDialog;
+class WXDLLEXPORT wxPanel;
+class WXDLLEXPORT wxWindow;
+
+class WXDLLEXPORT wxXmlResourceHandler;
+
+#include "wx/xml/xml.h"
+
+
+class WXDLLEXPORT wxXmlResourceDataRecord
+{
+    public:
+        wxXmlResourceDataRecord() : Doc(NULL), Time(wxDateTime::Now()) {}
+        ~wxXmlResourceDataRecord() {delete Doc;}
+    
+        wxString File;
+        wxXmlDocument *Doc;
+        wxDateTime Time;
+};
+
+WX_DECLARE_EXPORTED_OBJARRAY(wxXmlResourceDataRecord, wxXmlResourceDataRecords);
+
+// This class holds XML resources from one or more .xml files 
+// (or derived forms, either binary or zipped -- see manual for
+// details). 
+
+class WXDLLEXPORT wxXmlResource : public wxObject
+{
+    public:
+        wxXmlResource();
+        wxXmlResource(const wxString& filemask);
+        ~wxXmlResource();
+
+        // Loads resources from XML files that match given filemask.
+        // This method understands VFS (see filesys.h).
+        bool Load(const wxString& filemask);
+        
+        // Initialize handlers for all supported controls/windows. This will
+        // make the executable quite big because it forces linking against
+        // most of wxWin library
+        void InitAllHandlers();
+        
+        // Initialize only specific handler (or custom handler). Convention says
+        // that handler name is equal to control's name plus 'XmlHandler', e.g.
+        // wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. XML resource compiler
+        // (xmlres) can create include file that contains initialization code for 
+        // all controls used within the resource.
+        void AddHandler(wxXmlResourceHandler *handler);
+        
+        // Removes all handlers
+        void ClearHandlers();
+        
+        // Loads menu from resource. Returns NULL on failure.
+        wxMenu *LoadMenu(const wxString& name);
+
+        // Loads menubar from resource. Returns NULL on failure.
+        wxMenuBar *LoadMenuBar(const wxString& name);
+
+        // Loads dialog. dlg points to parent window (if any). Second form
+        // is used to finish creation of already existing instance (main reason
+        // for this is that you may want to use derived class with new event table)
+        // Example (typical usage):
+        //      MyDialog dlg;
+        //      wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
+        //      dlg->ShowModal();
+        wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
+        bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
+
+        // Loads panel. panel points to parent window (if any). Second form
+        // is used to finish creation of already existing instance.
+        wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
+        bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
+
+        // Returns numeric ID that is equivalent to string id used in XML
+        // resource. To be used in event tables
+        // Macro XMLID is provided for convenience
+        static int GetXMLID(const char *str_id);
+
+    protected:
+        // Scans resources list for unloaded files and loads them. Also reloads
+        // files that have been modified since last loading.
+        void UpdateResources();
+        
+        // Finds resource (calls UpdateResources) and returns node containing it
+        wxXmlNode *FindResource(const wxString& name, const wxString& type);
+        
+        // Creates resource from info in given node:
+        wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = NULL);
+
+        // Remove nodes with property "platform" that does not
+        // match current platform
+        void ProcessPlatformProperty(wxXmlNode *node);
+
+    private:
+        wxList m_Handlers;
+        wxXmlResourceDataRecords m_Data;
+        
+    friend class wxXmlResourceHandler;
+};
+
+
+// Global instance of resource class. For your convenience.
+extern wxXmlResource *wxTheXmlResource;
+
+// This macro translates string identifier (as used in XML resource,
+// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
+// wxWindows event tables.
+// Example:
+//    BEGIN_EVENT_TABLE(MyFrame, wxFrame)
+//       EVT_MENU(XMLID("quit"), MyFrame::OnQuit)
+//       EVT_MENU(XMLID("about"), MyFrame::OnAbout)
+//       EVT_MENU(XMLID("new"), MyFrame::OnNew)
+//       EVT_MENU(XMLID("open"), MyFrame::OnOpen)
+//    END_EVENT_TABLE()    
+
+#define XMLID(str_id) \
+    wxXmlResource::GetXMLID(_T(str_id))
+
+
+
+// This macro returns pointer to particular control in dialog
+// created using XML resources. You can use it to set/get values from
+// controls.
+// Example:
+//    wxDialog dlg;
+//    wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
+//    XMLCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(_T("default value"));
+
+#define XMLCTRL(window, id, type) \
+    ((type*)((window).FindWindow(XMLID(id))))
+
+
+
+class WXDLLEXPORT wxXmlResourceHandler : public wxObject
+{
+    public:
+        wxXmlResourceHandler();
+        virtual ~wxXmlResourceHandler() {}
+
+        // Creates object (menu, dialog, control, ...) from XML node.
+        // Should check for validity.
+        // parent is higher-level object (usually window, dialog or panel)
+        // that is often neccessary to create resource
+        // if instance != NULL it should not create new instance via 'new' but
+        // rather use this one and call its Create method
+        wxObject *CreateResource(wxXmlNode *node, wxObject *parent, wxObject *instance);
+
+        // This one is called from CreateResource after variables
+        // were filled
+        virtual wxObject *DoCreateResource() = 0;
+        
+        // Returns TRUE if it understands this node and can create
+        // resource from it, FALSE otherwise.
+        virtual bool CanHandle(wxXmlNode *node) = 0;
+
+        void SetParentResource(wxXmlResource *res) { m_Resource = res; }
+
+
+    protected:
+
+        wxXmlResource *m_Resource;
+        wxArrayString m_StyleNames;
+        wxArrayInt m_StyleValues;
+
+        // Variables (filled by CreateResource)
+        wxXmlNode *m_Node;
+        wxObject *m_Parent, *m_Instance;
+        wxWindow *m_ParentAsWindow, *m_InstanceAsWindow;
+        
+        // --- Handy methods:
+
+        // Gets node content from wxXML_ENTITY_NODE
+        // (the problem is, <tag>content<tag> is represented as
+        // wxXML_ENTITY_NODE name="tag", content=""
+        //    |-- wxXML_TEXT_NODE or 
+        //        wxXML_CDATA_SECTION_NODE name="" content="content"
+        wxString GetNodeContent(wxXmlNode *node);
+
+        // Check to see if a param exists
+        bool HasParam(const wxString& param);      
+
+        // Finds the node or returns NULL
+        wxXmlNode *GetParamNode(const wxString& param);
+        wxString GetParamValue(const wxString& param);
+            
+        // Add style flag (e.g. wxMB_DOCKABLE) to list of flags
+        // understood by this handler
+        void AddStyle(const wxString& name, int value);
+        
+        // Gets style flags from text in form "flag | flag2| flag3 |..."
+        // Only understads flags added with AddStyle
+        int GetStyle(const wxString& param = _T("style"), int defaults = 0);
+        
+        // Gets text from param and does some convertions:
+        // - replaces \n, \r, \t by respective chars (according to C syntax)
+        // - replaces $ by & and $$ by $ (needed for $File => &File because of XML)
+        // - converts encodings if neccessary
+        wxString GetText(const wxString& param);
+
+        // Return XMLID
+        int GetID();
+        wxString GetName();
+
+        // Get bool flag (1,t,yes,on,true are TRUE, everything else is FALSE)
+        bool GetBool(const wxString& param, bool defaultv = FALSE);
+
+        // Get integer value from param
+        long GetLong( const wxString& param, long defaultv = 0 );
+        
+        // Get colour in HTML syntax (#RRGGBB)
+        wxColour GetColour(const wxString& param);
+        
+        wxSize GetSize(const wxString& param = _T("size"));
+        wxPoint GetPosition(const wxString& param = _T("pos"));
+        
+        // Sets common window options:
+        void SetupWindow(wxWindow *wnd);
+    
+        void CreateChildren(wxObject *parent, bool only_this_handler = FALSE,
+                          wxXmlNode *children_node = NULL /*stands for
+                             GetParamNode("children")*/);
+        wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = NULL)
+            { return m_Resource->CreateResFromNode(node, parent, instance); }
+};
+
+#define ADD_STYLE(style) AddStyle(_T(#style), style)
+
+
+
+#endif // _WX_XMLRES_H_

contrib/samples/mmedia/mmbman.cpp

@@ -41,6 +41,7 @@
 #include "wx/mmedia/sndaiff.h"
 #include "wx/mmedia/sndpcm.h"
 #include "wx/mmedia/sndulaw.h"
+#include "wx/mmedia/sndmsad.h"
 
 #ifdef __UNIX__
 #include "wx/mmedia/sndoss.h"
@@ -310,6 +311,16 @@ wxString MMBoardSoundFile::GetStringInformation()
 	
 	break;
     }
+    case wxSOUND_MSADPCM: {
+        wxSoundFormatMSAdpcm *adpcm_format = (wxSoundFormatMSAdpcm *)format;
+
+        info += wxString::Format(wxT("Microsoft ADPCM\n"));
+        info += wxString::Format(wxT("Sampling Rate: %d\n")
+                                 wxT("Number of channels: %d\n"),
+                                 adpcm_format->GetSampleRate(),
+                                 adpcm_format->GetChannels());
+        break;
+    }
     case wxSOUND_ULAW: {
         wxSoundFormatUlaw *ulaw_format = (wxSoundFormatUlaw *)format;
 	info += wxT("ULAW\n");

contrib/samples/mmedia/mmboard.cpp

@@ -207,12 +207,20 @@ wxUint8 MMBoardApp::TestMultimediaCaps()
     delete dev;
     
     // We test the OSS (Open Sound System) support.
-    // WARNING: There is a conflict between ESD and ALSA
+    // WARNING: There is a conflict between ESD and ALSA. We may be interrested
+    // in disabling the auto detection of OSS is ESD has been detected.
+#if 1
+    if (!(caps & MM_SOUND_ESD)) {
+#endif
 
     dev = new wxSoundStreamOSS();
     if (dev->GetError() == wxSOUND_NOERROR)
         caps |= MM_SOUND_OSS;
     delete dev;
+#if 1
+    }
+#endif
+
 #endif
     
 #ifdef __WIN32__

contrib/src/Makefile.in

@@ -1,6 +1,6 @@
 # $Id$
 
-CONTRIB_SUBDIRS=ogl mmedia stc
+CONTRIB_SUBDIRS=ogl mmedia stc xml
 
 all:
 	@for d in $(CONTRIB_SUBDIRS); do (cd $$d && $(MAKE)); done

contrib/src/mmedia/sndbase.cpp

@@ -10,6 +10,13 @@
 #endif
 
 #include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/log.h"
+#endif
+
 #include "wx/mmedia/sndbase.h"
 
 
@@ -27,12 +34,14 @@ wxSoundFormatBase::~wxSoundFormatBase()
 
 wxSoundFormatBase *wxSoundFormatBase::Clone() const
 {
-  return NULL;
+    wxLogFatalError(wxT("In wxSoundFormatBase::Clone() but I should"
+                        " not be there"));
+    return NULL;
 }
 
 bool wxSoundFormatBase::operator!=(const wxSoundFormatBase& frmt2) const
 {
-  return (GetType() != frmt2.GetType());
+    return (GetType() != frmt2.GetType());
 }
 
 // ---------------------------------------------------------------------------
@@ -41,21 +50,21 @@ bool wxSoundFormatBase::operator!=(const wxSoundFormatBase& frmt2) const
 
 wxSoundStream::wxSoundStream()
 {
-  int i;
+    int i;
     
-  // Reset all variables to their neutral value.
+    // Reset all variables to their neutral value.
-  m_sndformat = NULL;
+    m_sndformat = NULL;
-  m_handler = NULL;
+    m_handler = NULL;
-  m_snderror = wxSOUND_NOERROR;
+    m_snderror = wxSOUND_NOERROR;
-  m_lastcount = 0;
+    m_lastcount = 0;
-  for (i=0;i<2;i++)
+    for (i=0;i<2;i++)
-    m_callback[i] = NULL;
+        m_callback[i] = NULL;
 }
 
 wxSoundStream::~wxSoundStream()
 {
   if (m_sndformat)
-    delete m_sndformat;
+      delete m_sndformat;
 }
 
 // --------------------------------------------------------------------------
@@ -69,13 +78,13 @@ wxSoundStream::~wxSoundStream()
 // --------------------------------------------------------------------------
 bool wxSoundStream::SetSoundFormat(const wxSoundFormatBase& format)
 {
-  // delete the previous prepared format
+    // delete the previous prepared format
-  if (m_sndformat)
+    if (m_sndformat)
-    delete m_sndformat;
+      delete m_sndformat;
     
-  // create a new one by cloning the format passed in parameter
+    // create a new one by cloning the format passed in parameter
-  m_sndformat = format.Clone();
+    m_sndformat = format.Clone();
-  return TRUE;
+    return TRUE;
 }
 
 

contrib/src/mmedia/sndcpcm.cpp

@@ -379,11 +379,15 @@ bool wxSoundStreamPcm::SetSoundFormat(const wxSoundFormatBase& format)
     // We try to minimize the need of dynamic memory allocation by preallocating a buffer. But
     // to be sure it will be efficient we minimize the best size.
     if (m_multiplier_in < m_multiplier_out) {
-        m_prebuffer_size = (wxUint32)(m_sndio->GetBestSize() * m_multiplier_out);
+        m_prebuffer_size = (wxUint32)(m_sndio->GetBestSize() *
-        m_best_size = (wxUint32)(m_sndio->GetBestSize() * m_multiplier_in);
+                                      m_multiplier_out);
+        m_best_size = (wxUint32)(m_sndio->GetBestSize() *
+                                 m_multiplier_in);
     } else {
-        m_prebuffer_size = (wxUint32)(m_sndio->GetBestSize() * m_multiplier_in);
+        m_prebuffer_size = (wxUint32)(m_sndio->GetBestSize() *
-        m_best_size = (wxUint32)(m_sndio->GetBestSize() * m_multiplier_out);
+                                      m_multiplier_in);
+        m_best_size = (wxUint32)(m_sndio->GetBestSize() *
+                                 m_multiplier_out);
     }
     
     m_prebuffer = new char[m_prebuffer_size];

contrib/src/mmedia/sndfile.cpp

@@ -18,6 +18,7 @@
 #include "wx/mmedia/sndcpcm.h"
 #include "wx/mmedia/sndulaw.h"
 #include "wx/mmedia/sndg72x.h"
+#include "wx/mmedia/sndmsad.h"
 
 // --------------------------------------------------------------------------
 // Sound codec router
@@ -106,6 +107,10 @@ bool wxSoundRouterStream::SetSoundFormat(const wxSoundFormatBase& format)
             m_router = new wxSoundStreamG72X(*m_sndio);
             m_router->SetSoundFormat(format);
             break;
+        case wxSOUND_MSADPCM:
+            m_router = new  wxSoundStreamMSAdpcm(*m_sndio);
+            m_router->SetSoundFormat(format);
+            break;
         default:
             return FALSE;
         

contrib/src/mmedia/sndmsad.cpp

@@ -6,10 +6,17 @@
 // CVSID: $Id$
 // --------------------------------------------------------------------------
 #ifdef __GNUG__
-#pragma implementation "sndulaw.cpp"
+#pragma implementation "sndmsad.cpp"
 #endif
 
 #include <wx/wxprec.h>
+
+#ifndef WX_PRECOMP
+  #include "wx/defs.h"
+  #include "wx/memory.h"
+  #include "wx/log.h"
+#endif
+
 #include "wx/mmedia/sndbase.h"
 #include "wx/mmedia/sndfile.h"
 #include "wx/mmedia/sndpcm.h"
@@ -22,12 +29,21 @@
 wxSoundFormatMSAdpcm::wxSoundFormatMSAdpcm()
         : m_srate(22050)
 {
-    m_coefs = new wxMSAdpcmCoefs();
+    m_ncoefs    = 0;
+    m_coefs_len = 0;
+    m_coefs     = NULL;
 }
 
 wxSoundFormatMSAdpcm::~wxSoundFormatMSAdpcm()
 {
-    delete m_coefs;
+    if (m_ncoefs) {
+        wxUint16 i;
+
+        for (i=0;i<m_ncoefs;i++)
+            delete[] m_coefs[i];
+        delete[] m_coefs;
+    }
+    
 }
 
 void wxSoundFormatMSAdpcm::SetSampleRate(wxUint32 srate)
@@ -40,34 +56,83 @@ wxUint32 wxSoundFormatMSAdpcm::GetSampleRate() const
     return m_srate;
 }
 
+void wxSoundFormatMSAdpcm::SetChannels(wxUint16 nchannels)
+{
+    m_nchannels = nchannels;
+}
+
+wxUint16 wxSoundFormatMSAdpcm::GetChannels() const
+{
+    return m_nchannels; 
+}
+
+void wxSoundFormatMSAdpcm::SetCoefs(wxInt16 **coefs, wxUint16 ncoefs,
+                                    wxUint16 coefs_len)
+{
+    wxUint16 i;
+
+    if (m_ncoefs) {
+        for (i=0;i<m_ncoefs;i++)
+           delete[] (m_coefs[i]);
+        delete[] m_coefs;
+    }
+    // TODO: Add some memory checking here
+    m_coefs = new (wxInt16 *)[ncoefs];
+
+    for (i=0;i<ncoefs;i++)
+       m_coefs[i] = new wxInt16[coefs_len];
+
+    m_ncoefs = ncoefs;
+    m_coefs_len = coefs_len;
+}
+
+void wxSoundFormatMSAdpcm::GetCoefs(wxInt16 **& coefs, wxUint16& ncoefs,
+                                    wxUint16& coefs_len) const
+{
+    coefs     = m_coefs;
+    ncoefs    = m_ncoefs;
+    coefs_len = m_coefs_len;
+}
+
+void wxSoundFormatMSAdpcm::SetBlockSize(wxUint16 block_size)
+{
+    m_block_size = block_size;
+}
+
+wxUint16 wxSoundFormatMSAdpcm::GetBlockSize() const
+{
+    return m_block_size;
+}
+
 wxSoundFormatBase *wxSoundFormatMSAdpcm::Clone() const
 {
     wxSoundFormatMSAdpcm *adpcm = new wxSoundFormatMSAdpcm();
     
-    adpcm->m_srate = m_srate;
+    adpcm->m_srate       = m_srate;
-    adpcm->m_coefs = new wxMSAdpcmCoefs();
+    adpcm->SetCoefs(m_coefs, m_ncoefs, m_coefs_len);
-    *(adpcm->m_coefs) = *m_coefs;
+    adpcm->m_nchannels   = m_nchannels;
+    adpcm->m_block_size  = m_block_size;
     return adpcm;
 }
 
 wxUint32 wxSoundFormatMSAdpcm::GetTimeFromBytes(wxUint32 bytes) const
 {
-    return 0;
+    return 2 * bytes / (m_nchannels * m_srate);
 }
 
 wxUint32 wxSoundFormatMSAdpcm::GetBytesFromTime(wxUint32 time) const
 {
-    return 0;
+    return time * m_nchannels * m_srate / 2;
 }
 
 bool wxSoundFormatMSAdpcm::operator !=(const wxSoundFormatBase& frmt2) const
 {
-    wxSoundFormatUlaw *adpcm = (wxSoundFormatMSAdpcm *)&frmt2;
+    const wxSoundFormatMSAdpcm *adpcm = (const wxSoundFormatMSAdpcm *)&frmt2;
     
     if (frmt2.GetType() != wxSOUND_MSADPCM)
         return TRUE;
     
-    return (adpcm->m_srate != m_srate) && 0;
+    return (adpcm->m_srate != m_srate) && (adpcm->m_nchannels != m_nchannels);
 }
 
 // --------------------------------------------------------------------------
@@ -79,6 +144,7 @@ wxSoundStreamMSAdpcm::wxSoundStreamMSAdpcm(wxSoundStream& sndio)
     // PCM converter
     m_router     = new wxSoundRouterStream(sndio);
     m_got_header = FALSE;
+    m_stereo = FALSE;
 }
 
 wxSoundStreamMSAdpcm::~wxSoundStreamMSAdpcm()
@@ -94,44 +160,187 @@ wxSoundStream& wxSoundStreamMSAdpcm::Read(void *buffer, wxUint32 len)
 }
 
 static wxInt16 gl_ADPCMcoeff_delta[] = {
-    230, 230, 230, 230, 307, 409, 512, 614, 768, 614, 512, 409, 307, 230, 230, 230
+    230, 230, 230, 230, 307, 409, 512, 614, 768, 614, 512, 409, 307,
+    230, 230, 230
 };
 
-static wxInt16 gl_ADPCMcoeff_1[] = {
+wxUint32 wxSoundStreamMSAdpcm::DecodeMonoADPCM(const void *in_buffer,
-    256, 512, 0, 192, 240, 460, 392
+                                               void *out_buffer,
-};
+                                               wxUint32 in_len)
+{
+    wxUint8  *ADPCMdata;
+    wxInt16  *PCMdata;
+    AdpcmState *state;
+    wxUint32 out_len;
     
-static wxInt16 gl_ADPCMcoeff_2[] = {
+    ADPCMdata = (wxUint8 *)in_buffer;
-    0, -256, 0, 64, 0, -208, -232
+    PCMdata   = (wxInt16 *)out_buffer;
-};
+    state     = &m_state[0];
+    
+#define GET_DATA_16(i) i = *ADPCMdata++, i |= ((wxUint32)(*ADPCMdata++) << 8)
+#define GET_DATA_8(i) i = (*ADPCMdata++)
+
+    out_len = 0;
+    while (in_len != 0) {
+        if (m_next_block == 0) {
+            GET_DATA_8(state->predictor);
+            GET_DATA_16(state->iDelta);
+            
+            GET_DATA_16(state->samp1);
+            GET_DATA_16(state->samp2);
+            
+            state->coeff[0] = state->coeff[1] = m_coefs[0][ state->predictor ];
+            
+            *PCMdata++ = state->samp2;
+            *PCMdata++ = state->samp1;
+            in_len     -= 7;
+            out_len    += 4;
+            m_next_block = m_block_size;
+            continue;
+        }
+    
+        while (in_len != 0 && m_next_block != 0) {
+            wxUint8 nib[2];
+            
+            GET_DATA_8(nib[0]);
+            nib[1] = (nib[0] >> 4) & 0x0f;
+            nib[0] &= 0x0f;
+        
+            Nibble(nib[0], state, &PCMdata);
+            Nibble(nib[1], state, &PCMdata);
+        
+            in_len       -= 4;
+            out_len      += 4;
+            m_next_block -= 4;
+        }
+    }
+
+    return out_len;
+
+#undef GET_DATA_16
+#undef GET_DATA_8
+}
+
+wxUint32 wxSoundStreamMSAdpcm::DecodeStereoADPCM(const void *in_buffer,
+                                                 void *out_buffer,
+                                                 wxUint32 in_len)
+{            
+    wxUint8  *ADPCMdata;
+    wxInt16  *PCMdata;
+    AdpcmState *state0, *state1;
+    wxUint32 out_len;
+    
+    ADPCMdata = (wxUint8 *)in_buffer;
+    PCMdata   = (wxInt16 *)out_buffer;
+    
+    state0 = &m_state[0];
+    state1 = &m_state[1];
+    
+#define GET_DATA_16(i) i = *ADPCMdata++, i |= ((wxUint32)(*ADPCMdata++) << 8)
+#define GET_DATA_8(i) i = (*ADPCMdata++)
+
+    out_len = 0;
+    while (in_len != 0) {
+        if (!m_next_block) {
+            GET_DATA_8(state0->predictor);
+            GET_DATA_8(state1->predictor);
+            
+            GET_DATA_16(state0->iDelta);
+            GET_DATA_16(state1->iDelta);
+        
+            GET_DATA_16(state0->samp1);
+            GET_DATA_16(state1->samp1);
+            GET_DATA_16(state0->samp2);
+            GET_DATA_16(state1->samp2);
+        
+            *PCMdata++ = state0->samp2;
+            *PCMdata++ = state1->samp2;
+            *PCMdata++ = state0->samp1;
+            *PCMdata++ = state1->samp1;
+
+            in_len     -= 14;
+            out_len    += 8;
+            m_next_block = m_block_size;
+            continue;
+        }
+    
+        while (in_len != 0 && m_next_block > 0) {
+            wxUint8 nib[2];
+            
+            GET_DATA_8(nib[0]);
+            nib[1] = (nib[0] >> 4) & 0x0f;
+            nib[0] &= 0x0f;
+            
+            Nibble(nib[0], state0, &PCMdata);
+            Nibble(nib[1], state1, &PCMdata);
+            
+            in_len       -= 4;
+            out_len      += 4;
+            m_next_block -= 4;
+        }
+    }
+
+    return out_len;
+
+#undef GET_DATA_16
+#undef GET_DATA_8
+}
+
+void wxSoundStreamMSAdpcm::Nibble(wxInt8 nyb,
+                                  AdpcmState *state,
+                                  wxInt16 **out_buffer)
+{
+    wxUint32 new_delta;
+    wxInt32  new_sample;
+
+    // First: compute the next delta value
+    new_delta  = (state->iDelta * gl_ADPCMcoeff_delta[nyb]) >> 8;
+    // If null, minor it by 16
+    if (!new_delta)
+        new_delta = 16;
+
+    // Barycentre
+    new_sample = (state->samp1 * state->coeff[0] +
+                  state->samp2 * state->coeff[1]) / 256;
+
+    // Regenerate the sign
+    if (nyb & 0x08)
+        nyb -= 0x10;
+    
+    new_sample += state->iDelta * nyb;
+
+    // Samples must be in [-32767, 32768]
+    if (new_sample < -32768)
+        new_sample = -32768;
+    else if (new_sample > 32767)
+        new_sample = 32767;
+    
+    state->iDelta = new_delta;
+    state->samp2  = state->samp1;
+    state->samp1  = new_sample;
+
+    *(*out_buffer)++ = new_sample;
+}
 
 wxSoundStream& wxSoundStreamMSAdpcm::Write(const void *buffer, wxUint32 len)
 {
-    wxInt16 delta;
+    wxUint8 *out_buf;
-    wxUint8 ADPCMdata;
+    wxUint32 new_len;
-    wxUint16 *PCMdata;
-    wxInt16 coeff1, coeff2;
     
-#define GET_DATA_16 (*ADPCMdata++ | ((wxUint32)(*ADPCMdata++) << 8);
+    // TODO: prealloc the output buffer
-#define GET_DATA_8 (*ADPCMdata++)
+    out_buf = new wxUint8[len*2];
 
-    if (!m_got_header) {
+    if (!m_stereo)
-        i_predict = GET_DATA_8;
+        new_len = DecodeMonoADPCM(buffer, out_buf, len);
-        delta     = GET_DATA_16;
+    else
-        samp1     = GET_DATA_16;
+        new_len = DecodeStereoADPCM(buffer, out_buf, len);
-        PCMdata   = GET_DATA_16;
-        len -= 3*2 + 1;
-        m_got_header = TRUE;
     
-        coeff1 = gl_ADPCMcoeff_1[i_predict];
+    m_router->Write(out_buf, new_len);
-        coeff2 = gl_ADPCMcoeff_2[i_predict];
-    }
 
-    while (len > 0) {
+    m_lastcount = len;
-        nyb1 = GET_DATA_8;
+    m_snderror  = wxSOUND_NOERROR;
-        nyb0 = (nyb1 & 0xf0) >> 4;
-        nyb1 &= 0x0f;
     
+    delete[] out_buf;
     
     return *this;
 }
@@ -143,17 +352,26 @@ wxUint32 wxSoundStreamMSAdpcm::GetBestSize() const
 
 bool wxSoundStreamMSAdpcm::SetSoundFormat(const wxSoundFormatBase& format)
 {
-    if (format.GetType() != wxSOUND_ULAW) {
+    if (format.GetType() != wxSOUND_MSADPCM) {
         m_snderror = wxSOUND_INVFRMT;
         return FALSE;
     }
     
     wxSoundFormatPcm pcm;
-    wxSoundFormatUlaw *ulaw;
+    wxSoundFormatMSAdpcm *adpcm;
+    wxUint16 ncoefs, coefs_len;
     
     wxSoundStreamCodec::SetSoundFormat(format);
     
-    ulaw = (wxSoundFormatMSAdpcm *)m_sndformat;
+    adpcm = (wxSoundFormatMSAdpcm *)m_sndformat;
+
+    adpcm->GetCoefs(m_coefs, ncoefs, coefs_len);
+
+    if (!ncoefs) {
+        wxLogError(__FILE__ ":%d: Number of ADPCM coefficients"
+                   " must be non null", __LINE__);
+        return FALSE;
+    }
     
     pcm.SetSampleRate(adpcm->GetSampleRate());
     pcm.SetBPS(16);
@@ -161,6 +379,10 @@ bool wxSoundStreamMSAdpcm::SetSoundFormat(const wxSoundFormatBase& format)
     pcm.Signed(TRUE);
     pcm.SetOrder(wxBYTE_ORDER);
 
+    m_stereo = (adpcm->GetChannels() == 2);
+    m_block_size = adpcm->GetBlockSize();
+    m_next_block = 0;
+    
     m_router->SetSoundFormat(pcm);
     
     return TRUE;

contrib/src/mmedia/sndulaw.cpp

@@ -163,8 +163,9 @@ bool wxSoundStreamUlaw::SetSoundFormat(const wxSoundFormatBase& format)
         return FALSE;
     }
     
-    // As the codec only support 16 bits, Mono we must use a wxSoundRouter to filter the data and
+    // As the codec only support 16 bits, Mono we must use a wxSoundRouter
-    // to translate them to a format supported by the sound card.
+    // to filter the data and to translate them to a format supported
+    // by the sound card.
     
     wxSoundFormatPcm pcm;
     wxSoundFormatUlaw *ulaw;

contrib/src/mmedia/sndwav.cpp

@@ -29,6 +29,7 @@
 #include "wx/mmedia/sndfile.h"
 #include "wx/mmedia/sndpcm.h"
 #include "wx/mmedia/sndg72x.h"
+#include "wx/mmedia/sndmsad.h"
 #include "wx/mmedia/sndwav.h"
 
 #define BUILD_SIGNATURE(a,b,c,d) (((wxUint32)a) | (((wxUint32)b) << 8) | (((wxUint32)c) << 16)  | (((wxUint32)d) << 24)) 
@@ -97,7 +98,8 @@ bool wxSoundWave::CanRead()
     return TRUE;
 }
 
-bool wxSoundWave::HandleOutputPCM(wxDataInputStream& data, wxUint16 channels, 
+bool wxSoundWave::HandleOutputPCM(wxDataInputStream& data, wxUint32 len,
+                                  wxUint16 channels, 
                                   wxUint32 sample_fq, wxUint32 byte_p_sec,
                                   wxUint16 byte_p_spl, wxUint16 bits_p_spl)
 {
@@ -112,10 +114,53 @@ bool wxSoundWave::HandleOutputPCM(wxDataInputStream& data, wxUint16 channels,
     if (!SetSoundFormat(sndformat))
         return FALSE;
     
+    m_input->SeekI(len, wxFromCurrent);
+
     return TRUE;
 }
 
-bool wxSoundWave::HandleOutputG721(wxDataInputStream& data, wxUint16 channels,
+bool wxSoundWave::HandleOutputMSADPCM(wxDataInputStream& data, wxUint32 len,
+                                      wxUint16 channels, 
+                                      wxUint32 sample_fq, wxUint32 byte_p_sec,
+                                      wxUint16 byte_p_spl, wxUint16 bits_p_spl)
+{
+    wxSoundFormatMSAdpcm sndformat;
+    wxInt16 *coefs[2];
+    wxUint16 coefs_len, i;
+    wxUint16 block_size;
+    
+    sndformat.SetSampleRate(sample_fq);
+    sndformat.SetChannels(channels);
+    
+    block_size = data.Read16();
+    coefs_len = data.Read16();
+
+    coefs[0] = new wxInt16[coefs_len];
+    coefs[1] = new wxInt16[coefs_len];
+    
+    for (i=0;i<coefs_len;i++) {
+        coefs[0][i] = data.Read16();
+        coefs[1][i] = data.Read16();
+    }
+
+    sndformat.SetCoefs(coefs, 2, coefs_len);
+    sndformat.SetBlockSize(block_size);
+
+    delete[] coefs[0];
+    delete[] coefs[1];
+    
+    if (!SetSoundFormat(sndformat))
+        return FALSE;
+
+    len -= coefs_len*4 + 4;
+    
+    m_input->SeekI(len, wxFromCurrent);
+    
+    return TRUE;
+}
+
+bool wxSoundWave::HandleOutputG721(wxDataInputStream& data, wxUint32 len,
+                                   wxUint16 channels,
                                    wxUint32 sample_fq, wxUint32 byte_p_sec,
                                    wxUint16 byte_p_spl, wxUint16 bits_p_spl)
 {
@@ -127,6 +172,8 @@ bool wxSoundWave::HandleOutputG721(wxDataInputStream& data, wxUint16 channels,
     if (!SetSoundFormat(sndformat))
         return FALSE;
     
+    m_input->SeekI(len, wxFromCurrent);
+
     return TRUE;
 }
 
@@ -173,16 +220,27 @@ bool wxSoundWave::PrepareToPlay()
                 // Get the common parameters
                 data >> format >> channels >> sample_fq 
                      >> byte_p_sec >> byte_p_spl >> bits_p_spl;
+                len -= 16;
                 
                 switch (format) {
                     case 0x01: // PCM
-                        if (!HandleOutputPCM(data, channels, sample_fq,
+                        if (!HandleOutputPCM(data, len, channels, sample_fq,
-                                             byte_p_sec, byte_p_spl, bits_p_spl))
+                                             byte_p_sec, byte_p_spl,
+                                             bits_p_spl))
+                            return FALSE;
+                        break;
+                    case 0x02: // MS ADPCM
+                        if (!HandleOutputMSADPCM(data, len,
+                                                 channels, sample_fq,
+                                                 byte_p_sec, byte_p_spl,
+                                                 bits_p_spl))
                             return FALSE;
                         break;
                     case 0x40: // G721
-                        if (!HandleOutputG721(data, channels, sample_fq,
+                        if (!HandleOutputG721(data, len,
-                                              byte_p_sec, byte_p_spl, bits_p_spl))
+                                              channels, sample_fq,
+                                              byte_p_sec, byte_p_spl,
+                                              bits_p_spl))
                             return FALSE;
                         break;
                     default: 

contrib/src/mmedia/sndwin.cpp

@@ -98,8 +98,11 @@ wxSoundStreamWin::wxSoundStreamWin()
 
   m_waiting_for = FALSE;
 
-  if (!OpenDevice(wxSOUND_OUTPUT))
+  if (!OpenDevice(wxSOUND_OUTPUT)) {
-    return;
+    m_snderror = wxSOUND_NOERROR; //next call to OpenDevice won't do this
+    if (!OpenDevice(wxSOUND_INPUT))
+      return;
+  }
 
   CloseDevice();
 }

contrib/src/mmedia/vidxanm.cpp

@@ -503,7 +503,8 @@ bool wxVideoXANIM::RestartXANIM()
     m_video_output->SetSize(vibrato_size);
     vibrato_size.SetWidth(vibrato_size.GetWidth()-1);
     m_video_output->SetSize(vibrato_size);
-    // Very useful ! Actually it sends a SETSIZE event to XAnim
+    // Very useful ! Actually it "should" sends a SETSIZE event to XAnim
+    // FIXME: This event is not sent !!
     
     m_paused = FALSE;
     

contrib/src/stc/Makefile.in

@@ -26,7 +26,6 @@ OBJECTS=PlatWX.o ScintillaWX.o stc.o \
 	DocumentAccessor.o	\
 	LexCPP.o		\
 	LexHTML.o		\
-	LexLua.o		\
 	LexOthers.o		\
 	LexPerl.o		\
 	LexPython.o		\
@@ -48,7 +47,6 @@ OBJECTS=PlatWX.o ScintillaWX.o stc.o \
         ScintillaBase.o	    	\
         Style.o		        \
         ViewStyle.o		\
-	PosRegExp.o		\
 
 
 APPEXTRADEFS=-D__WX__ -DSCI_LEXER -I$(scintilla_dir)/src -I$(scintilla_dir)/include -I$(top_srcdir)/contrib/include

contrib/src/stc/PlatWX.cpp

@@ -9,18 +9,13 @@
 #include "Platform.h"
 #include "wx/stc/stc.h"
 
-
-#ifdef __WXGTK__
-#include <gtk/gtk.h>
-#endif
-
 Point Point::FromLong(long lpoint) {
     return Point(lpoint & 0xFFFF, lpoint >> 16);
 }
 
 wxRect wxRectFromPRectangle(PRectangle prc) {
     wxRect rc(prc.left, prc.top,
-              prc.right-prc.left, prc.bottom-prc.top);
+              prc.right-prc.left+1, prc.bottom-prc.top+1);
     return rc;
 }
 
@@ -174,7 +169,7 @@ void Surface::InitPixMap(int width, int height, Surface *surface_) {
     Release();
     hdc = new wxMemoryDC(surface_->hdc);
     hdcOwned = true;
-    bitmap = new wxBitmap(width, height);
+    bitmap = new wxBitmap(width, height+1);
     ((wxMemoryDC*)hdc)->SelectObject(*bitmap);
     // **** ::SetTextAlign(hdc, TA_BASELINE);
 }
@@ -188,7 +183,12 @@ void Surface::BrushColor(Colour back) {
 }
 
 void Surface::SetFont(Font &font_) {
-  if (font_.GetID()) {
+
+  // I think the following check is valid.
+  // It eliminates a crash for me.  -- eric@sourcegear.com
+
+  if (font_.GetID())
+    {
       hdc->SetFont(*font_.GetID());
     }
 }
@@ -361,6 +361,9 @@ void Surface::SetClip(PRectangle rc) {
 }
 
 void Surface::FlushCachedState() {
+  // TODO Is there anything we need to do here? eric@sourcegear.com
+  // TODO I had to add this method when I merged new Scintilla code
+  // TODO from Neil.
 }
 
 Window::~Window() {
@@ -392,7 +395,7 @@ void Window::SetPositionRelative(PRectangle rc, Window) {
 
 PRectangle Window::GetClientPosition() {
     wxSize sz = id->GetClientSize();
-    return  PRectangle(0, 0, sz.x, sz.y);
+    return  PRectangle(0, 0, sz.x - 1, sz.y - 1);
 }
 
 void Window::Show(bool show) {
@@ -451,76 +454,6 @@ void Window::SetTitle(const char *s) {
 }
 
 
-class wxSTCListBox : public wxListBox {
-public:
-    wxSTCListBox(wxWindow* parent, wxWindowID id)
-        : wxListBox(parent, id, wxDefaultPosition, wxDefaultSize,
-                    0, NULL, wxLB_SINGLE | wxLB_SORT | wxSIMPLE_BORDER)
-        {}
-
-    void OnFocus(wxFocusEvent& event) {
-        GetParent()->SetFocus();
-        event.Skip();
-    }
-
-#ifdef __WXGTK__
-    void DoSetFirstItem(int n);
-#endif
-
-private:
-    DECLARE_EVENT_TABLE()
-};
-
-BEGIN_EVENT_TABLE(wxSTCListBox, wxListBox)
-    EVT_SET_FOCUS(wxSTCListBox::OnFocus)
-END_EVENT_TABLE()
-
-
-
-
-#ifdef __WXGTK__
-    // This can be removed after 2.2.2 I think
-void wxSTCListBox::DoSetFirstItem( int n )
-{
-    wxCHECK_RET( m_list, wxT("invalid listbox") );
-
-    if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (m_list))
-        return;
-
-    // terribly efficient
-    const gchar *vadjustment_key = "gtk-vadjustment";
-    guint vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
-
-    GtkAdjustment *adjustment =
-       (GtkAdjustment*) gtk_object_get_data_by_id (GTK_OBJECT (m_list), vadjustment_key_id);
-    wxCHECK_RET( adjustment, wxT("invalid listbox code") );
-
-    GList *target = g_list_nth( m_list->children, n );
-    wxCHECK_RET( target, wxT("invalid listbox index") );
-
-    GtkWidget *item = GTK_WIDGET(target->data);
-    wxCHECK_RET( item, wxT("invalid listbox code") );
-
-    // find the last item before this one which is already realized
-    size_t nItemsBefore;
-    for ( nItemsBefore = 0; item && (item->allocation.y == -1); nItemsBefore++ )
-    {
-        target = target->prev;
-        if ( !target )
-        {
-            // nothing we can do if there are no allocated items yet
-            return;
-        }
-
-        item = GTK_WIDGET(target->data);
-    }
-
-    gtk_adjustment_set_value(adjustment,
-                             item->allocation.y +
-                                nItemsBefore*item->allocation.height);
-}
-#endif
-
 
 ListBox::ListBox() {
 }
@@ -529,32 +462,8 @@ ListBox::~ListBox() {
 }
 
 void ListBox::Create(Window &parent, int ctrlID) {
-    id = new wxSTCListBox(parent.id, ctrlID);
+    id = new wxListBox(parent.id, ctrlID, wxDefaultPosition, wxDefaultSize,
-//    id = new wxListBox(parent.id, ctrlID,  wxDefaultPosition, wxDefaultSize,
+                       0, NULL, wxLB_SINGLE | wxLB_SORT);
-//                       0, NULL, wxLB_SINGLE | wxLB_SORT | wxSIMPLE_BORDER);
-}
-
-PRectangle ListBox::GetDesiredRect() {
-    wxSize sz = ((wxListBox*)id)->GetBestSize();
-    PRectangle rc;
-    rc.top = 0;
-    rc.left = 0;
-    if (sz.x > 150)   // TODO: A better way to determine these max sizes
-        sz.x = 150;
-    if (sz.y > 100)
-        sz.y = 100;
-    rc.right = sz.x;
-    rc.bottom = sz.y;
-
-    return rc;
-}
-
-void ListBox::SetAverageCharWidth(int width) {
-    aveCharWidth = width;
-}
-
-void ListBox::SetFont(Font &font) {
-    Window::SetFont(font);
 }
 
 void ListBox::Clear() {
@@ -571,13 +480,6 @@ int ListBox::Length() {
 
 void ListBox::Select(int n) {
     ((wxListBox*)id)->SetSelection(n);
-#ifdef __WXGTK__
-    if (n > 4)
-        n = n - 4;
-    else
-        n = 1;
-    ((wxListBox*)id)->SetFirstItem(n);
-#endif
 }
 
 int ListBox::GetSelection() {
@@ -585,12 +487,10 @@ int ListBox::GetSelection() {
 }
 
 int ListBox::Find(const char *prefix) {
-    if (prefix) {
+    for (int x=0; x < ((wxListBox*)id)->Number(); x++) {
-        for (int x=0; x < ((wxListBox*)id)->Number(); x++) {
+        wxString text = ((wxListBox*)id)->GetString(x);
-            wxString text = ((wxListBox*)id)->GetString(x);
+        if (text.StartsWith(prefix))
-            if (text.StartsWith(prefix))
+            return x;
-                return x;
-        }
     }
     return -1;
 }

contrib/src/stc/ScintillaWX.cpp

@@ -273,6 +273,8 @@ void ScintillaWX::AddToPopUp(const char *label, int cmd, bool enabled) {
 
     if (!enabled)
         popup.GetID()->Enable(cmd, enabled);
+
+    // TODO:  need to create event handler mappings for the cmd ID
 }
 
 
@@ -281,18 +283,18 @@ void ScintillaWX::ClaimSelection() {
 }
 
 
-long ScintillaWX::DefWndProc(unsigned int /*iMessage*/, unsigned long /*wParam*/, long /*lParam*/) {
+LRESULT ScintillaWX::DefWndProc(UINT /*iMessage*/, WPARAM /*wParam*/, LPARAM /*lParam*/) {
     return 0;
 }
 
-long ScintillaWX::WndProc(unsigned int iMessage, unsigned long wParam, long lParam) {
+LRESULT ScintillaWX::WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam) {
-//      switch (iMessage) {
+    switch (iMessage) {
-//      case EM_CANPASTE:
+    case EM_CANPASTE:
-//          return CanPaste();
+        return CanPaste();
-//      default:
+    default:
         return ScintillaBase::WndProc(iMessage, wParam, lParam);
-//      }
+    }
-//      return 0;
+    return 0;
 }
 
 
@@ -315,11 +317,6 @@ void ScintillaWX::DoPaint(wxDC* dc, wxRect rect) {
         FullPaint();
     }
     paintState = notPainting;
-#ifdef __WXGTK__
-    // On wxGTK the editor window paints can overwrite the listbox...
-    if (ac.Active())
-        ((wxWindow*)ac.lb.GetID())->Refresh(TRUE);
-#endif
 }
 
 
@@ -418,29 +415,6 @@ void ScintillaWX::DoAddChar(char ch) {
 }
 
 int  ScintillaWX::DoKeyDown(int key, bool shift, bool ctrl, bool alt) {
-    switch (key) {
-        case WXK_DOWN: key = SCK_DOWN; break;
-        case WXK_UP: key = SCK_UP; break;
-        case WXK_LEFT: key = SCK_LEFT; break;
-        case WXK_RIGHT: key = SCK_RIGHT; break;
-        case WXK_HOME: key = SCK_HOME; break;
-        case WXK_END: key = SCK_END; break;
-        case WXK_PRIOR: key = SCK_PRIOR; break;
-        case WXK_NEXT: key = SCK_NEXT; break;
-        case WXK_DELETE: key = SCK_DELETE; break;
-        case WXK_INSERT: key = SCK_INSERT; break;
-        case WXK_ESCAPE: key = SCK_ESCAPE; break;
-        case WXK_BACK: key = SCK_BACK; break;
-        case WXK_TAB: key = SCK_TAB; break;
-        case WXK_RETURN: key = SCK_RETURN; break;
-        case WXK_ADD: key = SCK_ADD; break;
-        case WXK_SUBTRACT: key = SCK_SUBTRACT; break;
-        case WXK_DIVIDE: key = SCK_DIVIDE; break;
-        case WXK_CONTROL: key = 0; break;
-        case WXK_ALT: key = 0; break;
-        case WXK_SHIFT: key = 0; break;
-    }
-
     return KeyDown(key, shift, ctrl, alt);
 }
 

contrib/src/stc/ScintillaWX.h

@@ -97,12 +97,8 @@ public:
     virtual void AddToPopUp(const char *label, int cmd = 0, bool enabled = true);
     virtual void ClaimSelection();
 
-    virtual long DefWndProc(unsigned int iMessage,
+    virtual LRESULT DefWndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
-                            unsigned long wParam,
+    virtual LRESULT WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
-                            long lParam);
-    virtual long WndProc(unsigned int iMessage,
-                         unsigned long wParam,
-                         long lParam);
 
     virtual void NotifyChange();
     virtual void NotifyParent(SCNotification scn);

contrib/src/stc/gen_iface.py

@@ -1,684 +0,0 @@
-#!/bin/env python
-#----------------------------------------------------------------------------
-# Name:         gen_iface.py
-# Purpose:      Generate stc.h and stc.cpp from the info in Scintilla.iface
-#
-# Author:       Robin Dunn
-#
-# Created:      5-Sept-2000
-# RCS-ID:       $Id$
-# Copyright:    (c) 2000 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-
-import sys, string, re
-from fileinput import FileInput
-
-
-IFACE         = './scintilla/include/Scintilla.iface'
-H_TEMPLATE    = './stc.h.in'
-CPP_TEMPLATE  = './stc.cpp.in'
-H_DEST        = '../../include/wx/stc/stc.h' # './stc_test.h' #
-CPP_DEST      = './stc.cpp' #'./stc_test.cpp'
-
-
-# Value prefixes to convert
-valPrefixes = [('SCI_', ''),
-               ('SC_',  ''),
-               ('SCN_', None),  # just toss these...
-               ('SCEN_', None),
-               ('SCE_', ''),
-               ('SCLEX_', 'LEX_'),
-               ('SCK_', 'KEY_'),
-               ('SCFIND_', 'FIND_'),
-               ('SCWS_', 'WS_'),
-]
-
-# Message funcion values that should have a CMD_ constant as well
-cmdValues = [ (2300, 2350), 2011, 2013, (2176, 2180) ]
-
-
-# Map some generic typenames to wx types, using return value syntax
-retTypeMap = {
-    'position': 'int',
-    'string':   'wxString',
-    'colour':   'wxColour',
-    }
-
-# Map some generic typenames to wx types, using parameter syntax
-paramTypeMap = {
-    'position': 'int',
-    'string':   'const wxString&',
-    'colour':   'const wxColour&',
-    'keymod':   'int',
-}
-
-# Map of method info that needs tweaked.  Either the name needs changed, or
-# the method definition/implementation.  Tuple items are:
-#
-#         1. New method name.  None to skip the method, 0 to leave the
-#            default name.
-#         2. Method definition for the .h file, 0 to leave alone
-#         3. Method implementation for the .cpp file, 0 to leave alone.
-#         4. tuple of Doc string lines, or 0 to leave alone.
-#
-methodOverrideMap = {
-    'AddText' : (0,
-                 'void %s(const wxString& text);',
-
-                 '''void %s(const wxString& text) {
-                    SendMsg(%s, text.Len(), (long)text.c_str());''',
-                 0),
-
-    'AddStyledText' : (0,
-                       'void %s(const wxString& text);',
-
-                       '''void %s(const wxString& text) {
-                          SendMsg(%s, text.Len(), (long)text.c_str());''',
-                       0),
-
-    'GetViewWS' : ( 'GetViewWhiteSpace', 0, 0, 0),
-    'SetViewWS' : ( 'SetViewWhiteSpace', 0, 0, 0),
-
-    'GetStyledText' : (0,
-                       'wxString %s(int startPos, int endPos);',
-
-                       '''wxString %s(int startPos, int endPos) {
-                          wxString text;
-                          int len = endPos - startPos;
-                          TextRange tr;
-                          tr.lpstrText = text.GetWriteBuf(len*2+1);
-                          tr.chrg.cpMin = startPos;
-                          tr.chrg.cpMax = endPos;
-                          SendMsg(%s, 0, (long)&tr);
-                          text.UngetWriteBuf(len*2);
-                          return text;''',
-
-                       ('Retrieve a buffer of cells.',)),
-
-
-    'PositionFromPoint' : (0,
-                           'int %s(wxPoint pt);',
-
-                           '''int %s(wxPoint pt) {
-                              return SendMsg(%s, pt.x, pt.y);''',
-
-                           0),
-
-    'GetCurLine' : (0,
-                    'wxString %s(int* OUTPUT=NULL);',
-
-                    '''wxString %s(int* linePos) {
-                       wxString text;
-                       int len = LineLength(GetCurrentLine());
-                       char* buf = text.GetWriteBuf(len+1);
-
-                       int pos = SendMsg(%s, len, (long)buf);
-                       text.UngetWriteBuf();
-                       if (linePos)  *linePos = pos;
-
-                       return text;''',
-
-                    0),
-
-    'SetUsePalette' : (None, 0,0,0),
-
-    'MarkerSetFore' : ('MarkerSetForeground', 0, 0, 0),
-    'MarkerSetBack' : ('MarkerSetBackground', 0, 0, 0),
-
-    'MarkerDefine' : (0,
-                      '''void %s(int markerNumber, int markerSymbol,
-                         const wxColour& foreground = wxNullColour,
-                         const wxColour& background = wxNullColour);''',
-
-                      '''void %s(int markerNumber, int markerSymbol,
-                            const wxColour& foreground,
-                            const wxColour& background) {
-
-                            SendMsg(%s, markerNumber, markerSymbol);
-                            if (foreground.Ok())
-                                MarkerSetForeground(markerNumber, foreground);
-                            if (background.Ok())
-                                MarkerSetBackground(markerNumber, background);''',
-
-                      ('Set the symbol used for a particular marker number,',
-                       'and optionally the for and background colours.')),
-
-    'SetMarginTypeN' : ('SetMarginType', 0, 0, 0),
-    'GetMarginTypeN' : ('GetMarginType', 0, 0, 0),
-    'SetMarginWidthN' : ('SetMarginWidth', 0, 0, 0),
-    'GetMarginWidthN' : ('GetMarginWidth', 0, 0, 0),
-    'SetMarginMaskN' : ('SetMarginMask', 0, 0, 0),
-    'GetMarginMaskN' : ('GetMarginMask', 0, 0, 0),
-    'SetMarginSensitiveN' : ('SetMarginSensitive', 0, 0, 0),
-    'GetMarginSensitiveN' : ('GetMarginSensitive', 0, 0, 0),
-
-    'StyleSetFore' : ('StyleSetForeground', 0, 0, 0),
-    'StyleSetBack' : ('StyleSetBackground', 0, 0, 0),
-    'SetSelFore' : ('SetSelForeground', 0, 0, 0),
-    'SetSelBack' : ('SetSelBackground', 0, 0, 0),
-    'SetCaretFore' : ('SetCaretForeground', 0, 0, 0),
-    'StyleSetFont' : ('StyleSetFaceName', 0, 0, 0),
-
-    # need to fix this to map between wx and scintilla encoding flags, leave it out for now...
-    'StyleSetCharacterSet' : (None, 0, 0, 0),
-
-    'AssignCmdKey' : ('CmdKeyAssign',
-                      'void %s(int key, int modifiers, int cmd);',
-
-                      '''void %s(int key, int modifiers, int cmd) {
-                          SendMsg(%s, MAKELONG(key, modifiers), cmd);''',
-
-                      0),
-
-    'ClearCmdKey' : ('CmdKeyClear',
-                      'void %s(int key, int modifiers);',
-
-                      '''void %s(int key, int modifiers) {
-                          SendMsg(%s, MAKELONG(key, modifiers));''',
-
-                      0),
-
-    'ClearAllCmdKeys' : ('CmdKeyClearAll', 0, 0, 0),
-
-
-    'SetStylingEx' : ('SetStyleBytes',
-                      'void %s(int length, char* styleBytes);',
-
-                      '''void %s(int length, char* styleBytes) {
-                          SendMsg(%s, length, (long)styleBytes);''',
-
-                      0),
-
-
-    'IndicSetStyle' : ('IndicatorSetStyle', 0, 0, 0),
-    'IndicGetStyle' : ('IndicatorGetStyle', 0, 0, 0),
-    'IndicSetFore' : ('IndicatorSetForeground', 0, 0, 0),
-    'IndicGetFore' : ('IndicatorGetForeground', 0, 0, 0),
-
-    'AutoCShow' : ('AutoCompShow', 0, 0, 0),
-    'AutoCCancel' : ('AutoCompCancel', 0, 0, 0),
-    'AutoCActive' : ('AutoCompActive', 0, 0, 0),
-    'AutoCPosStart' : ('AutoCompPosStart', 0, 0, 0),
-    'AutoCComplete' : ('AutoCompComplete', 0, 0, 0),
-    'AutoCStops' : ('AutoCompStops', 0, 0, 0),
-    'AutoCSetSeparator' : ('AutoCompSetSeparator', 0, 0, 0),
-    'AutoCGetSeparator' : ('AutoCompGetSeparator', 0, 0, 0),
-    'AutoCSelect' : ('AutoCompSelect', 0, 0, 0),
-    'AutoCSetCancelAtStart' : ('AutoCompSetCancelAtStart', 0, 0, 0),
-    'AutoCGetCancelAtStart' : ('AutoCompGetCancelAtStart', 0, 0, 0),
-    'AutoCSetFillUps' : ('AutoCompSetFillUps', 0, 0, 0),
-    'AutoCSetChooseSingle' : ('AutoCompSetChooseSingle', 0, 0, 0),
-    'AutoCGetChooseSingle' : ('AutoCompGetChooseSingle', 0, 0, 0),
-    'AutoCSetIgnoreCase' : ('AutoCompSetIgnoreCase', 0, 0, 0),
-    'AutoCGetIgnoreCase' : ('AutoCompGetIgnoreCase', 0, 0, 0),
-
-    'SetHScrollBar' : ('SetUseHorizontalScrollBar', 0, 0, 0),
-    'GetHScrollBar' : ('GetUseHorizontalScrollBar', 0, 0, 0),
-
-    'GetCaretFore' : ('GetCaretForeground', 0, 0, 0),
-
-    'GetUsePalette' : (None, 0, 0, 0),
-
-    'FindText' : (0,
-                  '''int %s(int minPos, int maxPos,
-                               const wxString& text,
-                               bool caseSensitive, bool wholeWord);''',
-                  '''int %s(int minPos, int maxPos,
-                               const wxString& text,
-                               bool caseSensitive, bool wholeWord) {
-                     TextToFind  ft;
-                     int         flags = 0;
-
-                     flags |= caseSensitive ? SCFIND_MATCHCASE : 0;
-                     flags |= wholeWord     ? SCFIND_WHOLEWORD : 0;
-                     ft.chrg.cpMin = minPos;
-                     ft.chrg.cpMax = maxPos;
-                     ft.lpstrText = (char*)text.c_str();
-
-                     return SendMsg(%s, flags, (long)&ft);''',
-                  0),
-
-    'FormatRange' : (0,
-                     '''int %s(bool   doDraw,
-                               int    startPos,
-                               int    endPos,
-                               wxDC*  draw,
-                               wxDC*  target,  // Why does it use two? Can they be the same?
-                               wxRect renderRect,
-                               wxRect pageRect);''',
-                     ''' int %s(bool   doDraw,
-                                int    startPos,
-                                int    endPos,
-                                wxDC*  draw,
-                                wxDC*  target,  // Why does it use two? Can they be the same?
-                                wxRect renderRect,
-                                wxRect pageRect) {
-                            RangeToFormat fr;
-
-                            fr.hdc = draw;
-                            fr.hdcTarget = target;
-                            fr.rc.top = renderRect.GetTop();
-                            fr.rc.left = renderRect.GetLeft();
-                            fr.rc.right = renderRect.GetRight();
-                            fr.rc.bottom = renderRect.GetBottom();
-                            fr.rcPage.top = pageRect.GetTop();
-                            fr.rcPage.left = pageRect.GetLeft();
-                            fr.rcPage.right = pageRect.GetRight();
-                            fr.rcPage.bottom = pageRect.GetBottom();
-                            fr.chrg.cpMin = startPos;
-                            fr.chrg.cpMax = endPos;
-
-                            return SendMsg(%s, doDraw, (long)&fr);''',
-                     0),
-
-
-    'GetLine' : (0,
-                    'wxString %s(int line);',
-
-                    '''wxString %s(int line) {
-                       wxString text;
-                       int len = LineLength(line);
-                       char* buf = text.GetWriteBuf(len+1);
-
-                       int pos = SendMsg(%s, line, (long)buf);
-                       text.UngetWriteBuf();
-
-                       return text;''',
-
-                    ('Retrieve the contents of a line.',)),
-
-    'SetSel' : ('SetSelection', 0, 0, 0),
-    'GetSelText' : ('GetSelectedText',
-                    'wxString %s();',
-
-                    '''wxString %s() {
-                            wxString text;
-                            int   start;
-                            int   end;
-
-                            GetSelection(&start, &end);
-                            int   len  = end - start;
-                            char* buff = text.GetWriteBuf(len+1);
-
-                            SendMsg(%s, 0, (long)buff);
-                            text.UngetWriteBuf();
-                            return text;''',
-
-                    ('Retrieve the selected text.',)),
-
-    'GetTextRange' : (0,
-                      'wxString %s(int startPos, int endPos);',
-
-                      '''wxString %s(int startPos, int endPos) {
-                            wxString text;
-                            int   len  = endPos - startPos;
-                            char* buff = text.GetWriteBuf(len+1);
-                            TextRange tr;
-                            tr.lpstrText = buff;
-                            tr.chrg.cpMin = startPos;
-                            tr.chrg.cpMax = endPos;
-
-                            SendMsg(%s, 0, (long)&tr);
-                            text.UngetWriteBuf();
-                            return text;''',
-
-                       ('Retrieve a range of text.',)),
-
-    'PointXFromPosition' : (None, 0, 0, 0),
-    'PointYFromPosition' : (None, 0, 0, 0),
-
-    'ScrollCaret' : ('EnsureCaretVisible', 0, 0, 0),
-    'ReplaceSel' : ('ReplaceSelection', 0, 0, 0),
-    'Null' : (None, 0, 0, 0),
-
-    'GetText' : (0,
-                 'wxString %s();',
-
-                 '''wxString %s() {
-                        wxString text;
-                        int   len  = GetTextLength();
-                        char* buff = text.GetWriteBuf(len+1);
-
-                        SendMsg(%s, len, (long)buff);
-                        buff[len] = 0;
-                        text.UngetWriteBuf();
-                        return text;''',
-
-                 ('Retrieve all the text in the document.', )),
-
-    'GetDirectFunction' : (None, 0, 0, 0),
-    'GetDirectPointer' : (None, 0, 0, 0),
-
-    'CallTipPosStart' : ('CallTipPosAtStart', 0, 0, 0),
-    'CallTipSetHlt' : ('CallTipSetHighlight', 0, 0, 0),
-    'CallTipSetBack' : ('CallTipSetBackground', 0, 0, 0),
-
-
-    # Remove all methods that are key commands since they can be
-    # executed with CmdKeyExecute
-    'LineDown' : (None, 0, 0, 0),
-    'LineDownExtend' : (None, 0, 0, 0),
-    'LineUp' : (None, 0, 0, 0),
-    'LineUpExtend' : (None, 0, 0, 0),
-    'CharLeft' : (None, 0, 0, 0),
-    'CharLeftExtend' : (None, 0, 0, 0),
-    'CharRight' : (None, 0, 0, 0),
-    'CharRightExtend' : (None, 0, 0, 0),
-    'WordLeft' : (None, 0, 0, 0),
-    'WordLeftExtend' : (None, 0, 0, 0),
-    'WordRight' : (None, 0, 0, 0),
-    'WordRightExtend' : (None, 0, 0, 0),
-    'Home' : (None, 0, 0, 0),
-    'HomeExtend' : (None, 0, 0, 0),
-    'LineEnd' : (None, 0, 0, 0),
-    'LineEndExtend' : (None, 0, 0, 0),
-    'DocumentStart' : (None, 0, 0, 0),
-    'DocumentStartExtend' : (None, 0, 0, 0),
-    'DocumentEnd' : (None, 0, 0, 0),
-    'DocumentEndExtend' : (None, 0, 0, 0),
-    'PageUp' : (None, 0, 0, 0),
-    'PageUpExtend' : (None, 0, 0, 0),
-    'PageDown' : (None, 0, 0, 0),
-    'PageDownExtend' : (None, 0, 0, 0),
-    'EditToggleOvertype' : (None, 0, 0, 0),
-    'Cancel' : (None, 0, 0, 0),
-    'DeleteBack' : (None, 0, 0, 0),
-    'Tab' : (None, 0, 0, 0),
-    'BackTab' : (None, 0, 0, 0),
-    'NewLine' : (None, 0, 0, 0),
-    'FormFeed' : (None, 0, 0, 0),
-    'VCHome' : (None, 0, 0, 0),
-    'VCHomeExtend' : (None, 0, 0, 0),
-    'ZoomIn' : (None, 0, 0, 0),
-    'ZoomOut' : (None, 0, 0, 0),
-    'DelWordLeft' : (None, 0, 0, 0),
-    'DelWordRight' : (None, 0, 0, 0),
-    'LineCut' : (None, 0, 0, 0),
-    'LineDelete' : (None, 0, 0, 0),
-    'LineTranspose' : (None, 0, 0, 0),
-    'LowerCase' : (None, 0, 0, 0),
-    'UpperCase' : (None, 0, 0, 0),
-    'LineScrollDown' : (None, 0, 0, 0),
-    'LineScrollUp' : (None, 0, 0, 0),
-
-
-    'GetDocPointer' : (0,
-                       'void* %s();',
-                       '''void* %s() {
-                           return (void*)SendMsg(%s);''',
-                       0),
-
-    'SetDocPointer' : (0,
-                       'void %s(void* docPointer);',
-                       '''void %s(void* docPointer) {
-                           SendMsg(%s, (long)docPointer);''',
-                       0),
-
-    'CreateDocument' : (0,
-                       'void* %s();',
-                       '''void* %s() {
-                           return (void*)SendMsg(%s);''',
-                        0),
-
-    'AddRefDocument' : (0,
-                       'void %s(void* docPointer);',
-                       '''void %s(void* docPointer) {
-                           SendMsg(%s, (long)docPointer);''',
-                        0),
-
-    'ReleaseDocument' : (0,
-                       'void %s(void* docPointer);',
-                       '''void %s(void* docPointer) {
-                           SendMsg(%s, (long)docPointer);''',
-                         0),
-
-    'GrabFocus' : (None, 0, 0, 0),
-
-    '' : ('', 0, 0, 0),
-
-    }
-
-#----------------------------------------------------------------------------
-
-def processIface(iface, h_tmplt, cpp_tmplt, h_dest, cpp_dest):
-    curDocStrings = []
-    values = []
-    methods = []
-
-    # parse iface file
-    fi = FileInput(iface)
-    for line in fi:
-        line = line[:-1]
-        if line[:2] == '##' or line == '':
-            #curDocStrings = []
-            continue
-
-        op = line[:4]
-        if line[:2] == '# ':   # a doc string
-            curDocStrings.append(line[2:])
-
-        elif op == 'val ':
-            parseVal(line[4:], values, curDocStrings)
-            curDocStrings = []
-
-        elif op == 'fun ' or op == 'set ' or op == 'get ':
-            parseFun(line[4:], methods, curDocStrings, values)
-            curDocStrings = []
-
-        elif op == 'cat ':
-            if string.strip(line[4:]) == 'Deprecated':
-                break    # skip the rest of the file
-
-        elif op == 'evt ':
-            pass
-
-        else:
-            print '***** Unknown line type: ', line
-
-
-    # process templates
-    data = {}
-    data['VALUES'] = processVals(values)
-    defs, imps = processMethods(methods)
-    data['METHOD_DEFS'] = defs
-    data['METHOD_IMPS'] = imps
-
-    # get template text
-    h_text = open(h_tmplt).read()
-    cpp_text = open(cpp_tmplt).read()
-
-    # do the substitutions
-    h_text = h_text % data
-    cpp_text = cpp_text % data
-
-    # write out destination files
-    open(h_dest, 'w').write(h_text)
-    open(cpp_dest, 'w').write(cpp_text)
-
-
-
-#----------------------------------------------------------------------------
-
-def processVals(values):
-    text = []
-    for name, value, docs in values:
-        if docs:
-            text.append('')
-            for x in docs:
-                text.append('// ' + x)
-        text.append('#define %s %s' % (name, value))
-    return string.join(text, '\n')
-
-#----------------------------------------------------------------------------
-
-def processMethods(methods):
-    defs = []
-    imps = []
-
-    for retType, name, number, param1, param2, docs in methods:
-        retType = retTypeMap.get(retType, retType)
-        params = makeParamString(param1, param2)
-
-        name, theDef, theImp, docs = checkMethodOverride(name, number, docs)
-
-        if name is None:
-            continue
-
-        # Build the method definition for the .h file
-        if docs:
-            defs.append('')
-            for x in docs:
-                defs.append('    // ' + x)
-        if not theDef:
-            theDef = '    %s %s(%s);' % (retType, name, params)
-        defs.append(theDef)
-
-        # Build the method implementation string
-        if docs:
-            imps.append('')
-            for x in docs:
-                imps.append('// ' + x)
-        if not theImp:
-            theImp = '%s wxStyledTextCtrl::%s(%s) {\n    ' % (retType, name, params)
-
-            if retType == 'wxColour':
-                theImp = theImp + 'long c = '
-            elif retType != 'void':
-                theImp = theImp + 'return '
-            theImp = theImp + 'SendMsg(%s, %s, %s)' % (number,
-                                                       makeArgString(param1),
-                                                       makeArgString(param2))
-            if retType == 'bool':
-                theImp = theImp + ' != 0'
-            if retType == 'wxColour':
-                theImp = theImp + ';\n    return wxColourFromLong(c)'
-
-            theImp = theImp + ';\n}'
-        imps.append(theImp)
-
-
-    return string.join(defs, '\n'), string.join(imps, '\n')
-
-
-#----------------------------------------------------------------------------
-
-def checkMethodOverride(name, number, docs):
-    theDef = theImp = None
-    if methodOverrideMap.has_key(name):
-        item = methodOverrideMap[name]
-
-        if item[0] != 0:
-            name = item[0]
-        if item[1] != 0:
-            theDef = '    ' + (item[1] % name)
-        if item[2] != 0:
-            theImp = item[2] % ('wxStyledTextCtrl::'+name, number) + '\n}'
-        if item[3] != 0:
-            docs = item[3]
-
-    return name, theDef, theImp, docs
-
-#----------------------------------------------------------------------------
-
-def makeArgString(param):
-    if not param:
-        return '0'
-
-    typ, name = param
-
-    if typ == 'string':
-        return '(long)%s.c_str()' % name
-    if typ == 'colour':
-        return 'wxColourAsLong(%s)' % name
-
-    return name
-
-#----------------------------------------------------------------------------
-
-def makeParamString(param1, param2):
-    def doOne(param):
-        if param:
-            aType = paramTypeMap.get(param[0], param[0])
-            return aType + ' ' + param[1]
-        else:
-            return ''
-
-    st = doOne(param1)
-    if st and param2:
-        st = st + ', '
-    st = st + doOne(param2)
-    return st
-
-
-#----------------------------------------------------------------------------
-
-def parseVal(line, values, docs):
-    name, val = string.split(line, '=')
-
-    # remove prefixes such as SCI, etc.
-    for old, new in valPrefixes:
-        lo = len(old)
-        if name[:lo] == old:
-            if new is None:
-                return
-            name = new + name[lo:]
-
-    # add it to the list
-    values.append( ('wxSTC_' + name, val, docs) )
-
-#----------------------------------------------------------------------------
-
-funregex = re.compile(r'\s*([a-zA-Z0-9_]+)'  # <ws>return type
-                      '\s+([a-zA-Z0-9_]+)='  # <ws>name=
-                      '([0-9]+)'             # number
-                      '\(([ a-zA-Z0-9_]*),'  # (param,
-                      '([ a-zA-Z0-9_]*)\)')  # param)
-
-def parseFun(line, methods, docs, values):
-    def parseParam(param):
-        param = string.strip(param)
-        if param == '':
-            param = None
-        else:
-            param = tuple(string.split(param))
-        return param
-
-    mo = funregex.match(line)
-    if mo is None:
-        print "***** Line doesn't match! : " + line
-
-    retType, name, number, param1, param2 = mo.groups()
-
-    param1 = parseParam(param1)
-    param2 = parseParam(param2)
-
-    # Special case.  For the key command functionss we want a value defined too
-    num = string.atoi(number)
-    for v in cmdValues:
-        if (type(v) == type(()) and v[0] <= num < v[1]) or v == num:
-            parseVal('CMD_%s=%s' % (string.upper(name), number), values, ())
-
-    #if retType == 'void' and not param1 and not param2:
-
-    methods.append( (retType, name, number, param1, param2, tuple(docs)) )
-
-
-#----------------------------------------------------------------------------
-
-
-def main(args):
-    # TODO: parse command line args to replace default input/output files???
-
-    # Now just do it
-    processIface(IFACE, H_TEMPLATE, CPP_TEMPLATE, H_DEST, CPP_DEST)
-
-
-
-if __name__ == '__main__':
-    main(sys.argv)
-
-#----------------------------------------------------------------------------
-
-

contrib/src/stc/makefile.b32

@@ -34,7 +34,6 @@ OBJECTS = \
 	KeyWords.obj		\
 	LexCPP.obj		\
 	LexHTML.obj		\
-	LexLua.obj		\
 	LexOthers.obj		\
 	LexPerl.obj		\
 	LexPython.obj		\
@@ -42,7 +41,6 @@ OBJECTS = \
 	LexVB.obj		\
 	LineMarker.obj		\
 	PropSet.obj		\
-	PosRegExp.obj		\
 	ScintillaBase.obj	\
 	Style.obj		\
 	UniConversion.obj	\

contrib/src/stc/makefile.g95

@@ -27,7 +27,6 @@ OBJECTS = \
 	$(S)/ViewStyle.$(OBJSUFF) \
 	$(S)/LexCPP.$(OBJSUFF)	\
 	$(S)/LexHTML.$(OBJSUFF)	\
-	$(S)/LexLua.$(OBJSUFF) \
 	$(S)/LexOthers.$(OBJSUFF) \
 	$(S)/LexPerl.$(OBJSUFF)	\
 	$(S)/LexPython.$(OBJSUFF) \
@@ -36,7 +35,6 @@ OBJECTS = \
 	$(S)/DocumentAccessor.$(OBJSUFF)\
 	$(S)/UniConversion.$(OBJSUFF)	\
 	$(S)/WindowAccessor.$(OBJSUFF)	\
-	$(S)/PosRegExp.$(OBJSUFF) \
 	PlatWX.$(OBJSUFF) \
 	ScintillaWX.$(OBJSUFF) \
 	stc.$(OBJSUFF)

contrib/src/stc/makefile.vc

@@ -27,14 +27,12 @@ OBJECTS = \
 	$(D)\KeyWords.obj	\
 	$(D)\LexCPP.obj		\
 	$(D)\LexHTML.obj	\
-	$(D)\LexLua.obj		\
 	$(D)\LexOthers.obj	\
 	$(D)\LexPerl.obj	\
 	$(D)\LexPython.obj	\
 	$(D)\LexSQL.obj		\
 	$(D)\LexVB.obj		\
 	$(D)\LineMarker.obj	\
-	$(D)\PosRegExp.obj	\
 	$(D)\PropSet.obj	\
 	$(D)\ScintillaBase.obj	\
 	$(D)\Style.obj		\

contrib/src/stc/scintilla/README.txt

@@ -3,5 +3,6 @@ scintilla/include directories from the Scintilla/SCiTE source
 distribution.  All other code needed to implement Scintilla on top of
 wxWindows is located in the directory above this one.
 
-The current version of the Scintilla code is 1.32
+The current version of the Scintilla code is 1.25+ (from their CVS on
+5-19-2000).
 

contrib/src/stc/scintilla/include/Platform.h

@@ -80,6 +80,12 @@ typedef wxWindow* WindowID;
 typedef wxMenu* MenuID;
 #endif
 
+#if PLAT_GTK || PLAT_WX
+#define SHIFT_PRESSED 1
+#define LEFT_CTRL_PRESSED 2
+#define LEFT_ALT_PRESSED 4
+#endif
+
 // Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably
 
 class Point {
@@ -193,7 +199,6 @@ public:
 };
 
 class Font {
-protected:
 	FontID id;
 #if PLAT_WX
 	int ascent;
@@ -203,10 +208,10 @@ protected:
 	Font &operator=(const Font &) { id=0; return *this; }
 public:
 	Font();
-	virtual ~Font();
+	~Font();
 
-	virtual void Create(const char *faceName, int characterSet, int size, bool bold, bool italic);
+	void Create(const char *faceName, int characterSet, int size, bool bold, bool italic);
-	virtual void Release();
+	void Release();
 
 	FontID GetID() { return id; }
 	// Alias another font - caller guarantees not to Release
@@ -322,7 +327,7 @@ public:
 	void Show(bool show=true);
 	void InvalidateAll();
 	void InvalidateRectangle(PRectangle rc);
-	virtual void SetFont(Font &font);
+	void SetFont(Font &font);
 	enum Cursor { cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow };
 	void SetCursor(Cursor curs);
 	void SetTitle(const char *s);
@@ -339,17 +344,14 @@ class ListBox : public Window {
 	WindowID scroller;
 	int current;
 #endif
-	int desiredVisibleRows;
-	unsigned int maxItemCharacters;
-	unsigned int aveCharWidth;
 public:
 	ListBox();
 	virtual ~ListBox();
+	ListBox &operator=(WindowID id_) {
+		id = id_;
+		return *this;
+	}
 	void Create(Window &parent, int ctrlID);
-	virtual void SetFont(Font &font);
-	void SetAverageCharWidth(int width);
-	void SetVisibleRows(int rows);
-	PRectangle GetDesiredRect();
 	void Clear();
 	void Append(char *s);
 	int Length();
@@ -394,16 +396,6 @@ public:
 	// These are utility functions not really tied to a platform
 	static int Minimum(int a, int b);
 	static int Maximum(int a, int b);
-	// Next three assume 16 bit shorts and 32 bit longs
-	static long LongFromTwoShorts(short a,short b) {
-		return (a) | ((b) << 16);
-	}
-	static short HighShortFromLong(long x) {
-		return static_cast<short>(x >> 16);
-	}
-	static short LowShortFromLong(long x) {
-		return static_cast<short>(x & 0xffff);
-	}
 	static void DebugPrintf(const char *format, ...);
 	static int Clamp(int val, int minVal, int maxVal);
 };

contrib/src/stc/scintilla/include/PosRegExp.h

@@ -1,138 +0,0 @@
-#ifndef POSREGEXP_H
-#define POSREGEXP_H
-
-#define MatchesNum 0x10
-
-enum EOps
-{
-  ReBlockOps = 0x1000,
-  ReMul,              // *
-  RePlus,             // +
-  ReQuest,            // ?
-  ReNGMul,            // *?
-  ReNGPlus,           // +?
-  ReNGQuest,          // ??
-  ReRangeN,           // {n,}
-  ReRangeNM,          // {n,m}
-  ReNGRangeN,         // {n,}?
-  ReNGRangeNM,        // {n,m}?
-  ReOr,               // |
-  ReBehind  = 0x1100, // ?#n
-  ReNBehind = 0x1200, // ?~n
-  ReAhead   = 0x1300, // ?=
-  ReNAhead  = 0x1400, // ?!
-
-  ReSymbolOps = 0x2000,
-  ReEmpty,
-  ReSymb,             // a b \W \s ...
-  ReEnum,             // []
-  ReNEnum,            // [^]
-  ReBrackets,         // (...)
-  ReBkTrace = 0x2100, // \yN
-  ReBkBrack = 0x2200 // \N
-};
-
-enum ESymbols
-{
-  ReAnyChr = 0x4000,  // .
-  ReSoL,              // ^
-  ReEoL,              // $
-  ReDigit,            // \d
-  ReNDigit,           // \D
-  ReWordSymb,         // \w
-  ReNWordSymb,        // \W
-  ReWSpace,           // \s
-  ReNWSpace,          // \S
-  ReUCase,            // \u
-  ReNUCase ,          // \l
-  ReWBound,           // \b
-  ReNWBound,          // \B
-  RePreNW,            // \c
-  ReStart,            // \m
-  ReEnd,              // \M
-
-  ReChr    = 0x0      // Char in Lower Byte
-};
-enum ETempSymb
-{
-  ReTemp = 0x7000,
-  ReLBrack, ReRBrack,
-  ReEnumS, ReEnumE, ReNEnumS,
-  ReRangeS, ReRangeE, ReNGRangeE, ReFrToEnum
-};
-
-#define BackSlash '\\'
-
-typedef union SCharData
-{
-  int  IArr[8];
-  char CArr[32];
-  void SetBit(unsigned char Bit);
-  void ClearBit(unsigned char Bit);
-  bool GetBit(unsigned char Bit);
-} *PCharData;
-
-typedef struct SRegInfo
-{
-  SRegInfo();
-  ~SRegInfo();
-
-  EOps   Op;
-  union{
-    SRegInfo *Param;
-    int Symb;
-    PCharData ChrClass;
-  }un;
-  int s,e;
-  SRegInfo *Parent;
-  SRegInfo *Next;
-} *PRegInfo;
-
-typedef struct SMatches
-{
-  int s[MatchesNum];
-  int e[MatchesNum];
-  int CurMatch;
-} *PMatches;
-
-typedef class PosRegExp
-{
-  PRegInfo Info;
-  PMatches BkTrace;
-  bool NoCase,Extend,NoMoves;
-  bool Error;
-  int  *Exprn;
-  int  posParse;
-  int  posEnd,posStart;
-  int  posBkStr;
-  int  FirstChar;
-
-  bool SetExprLow(const char *Expr);
-  bool SetStructs(PRegInfo &Info,int st,int end);
-  void Optimize();
-  bool CheckSymb(int Symb,bool Inc);
-  bool LowParse(PRegInfo Re);
-  bool LowParseRe(PRegInfo &Next);
-  bool LowCheckNext(PRegInfo Re);
-  bool ParseRe(int posStr);
-  bool QuickCheck();
-public:
-  PMatches Matches;
-  int Ok, CurMatch;
-
-  void *param;
-  char (*CharAt)(int pos, void *param);
-
-  PosRegExp();
-  ~PosRegExp();
-
-  bool isok();
-  bool SetNoMoves(bool Moves);
-  bool SetBkTrace(int posStr,PMatches Trace);
-  bool SetExpr(const char *Expr);
-  bool Parse(int posStr, int posStop, PMatches Mtch);
-  bool Parse(int posStr,int posSol, int posEol, PMatches Mtch, int Moves = -1);
-  bool Evaluate(char *Expr, int posStr, PMatches Mtch, char **Res);
-} *PPosRegExp;
-
-#endif /* POSREGEXP_H */

contrib/src/stc/scintilla/include/PropSet.h

@@ -8,92 +8,44 @@
 
 bool EqualCaseInsensitive(const char *a, const char *b);
 
-#if PLAT_WIN
-#define strcasecmp  stricmp
-#define strncasecmp strnicmp
-#endif
-
-#ifdef __WXMSW__
-#define strcasecmp  stricmp
-#define strncasecmp strnicmp
-#endif
-
 // Define another string class.
 // While it would be 'better' to use std::string, that doubles the executable size.
 
-inline char *StringDup(const char *s, int len=-1) {
+inline char *StringDup(const char *s) {
 	if (!s)
 		return 0;
-	if (len == -1)
+	char *sNew = new char[strlen(s) + 1];
-		len = strlen(s);
+	if (sNew)
-	char *sNew = new char[len + 1];
+		strcpy(sNew, s);
-	if (sNew) {
-		strncpy(sNew, s, len);
-		sNew[len] = '\0';
-	}
 	return sNew;
 }
 
 class SString {
 	char *s;
-	int ssize;
 public:
-	typedef const char* const_iterator;
-	typedef int size_type;
-	static size_type npos;
-	const char* begin(void) const {
-		return s;
-	}
-	const char* end(void) const {
-		return &s[ssize];
-	}
-	size_type size(void) const {
-		if (s)
-			return ssize;
-		else
-			return 0;
-	}
-	SString &assign(const char* sother, int size_ = -1) {
-		char *t = s;
-		s = StringDup(sother,size_);
-		ssize = (s) ? strlen(s) : 0;
-		delete []t;
-		return *this;
-	}
-	SString &assign(const SString& sother, int size_ = -1) {
-		return assign(sother.s,size_);
-	}
-	SString &assign(const_iterator ibeg, const_iterator iend) {
-		return assign(ibeg,iend - ibeg);
-	}
 	SString() {
 		s = 0;
-		ssize = 0;
 	}
 	SString(const SString &source) {
 		s = StringDup(source.s);
-		ssize = (s) ? strlen(s) : 0;
 	}
 	SString(const char *s_) {
 		s = StringDup(s_);
-		ssize = (s) ? strlen(s) : 0;
 	}
 	SString(int i) {
 		char number[100];
 		sprintf(number, "%0d", i);
+		//itoa(i, number, 10);
 		s = StringDup(number);
-		ssize = (s) ? strlen(s) : 0;
 	}
 	~SString() {
 		delete []s;
 		s = 0;
-		ssize = 0;
 	}
 	SString &operator=(const SString &source) {
 		if (this != &source) {
 			delete []s;
 			s = StringDup(source.s);
-			ssize = (s) ? strlen(s) : 0;
 		}
 		return *this;
 	}
@@ -104,9 +56,6 @@ public:
 			return false;
 		return strcmp(s, other.s) == 0;
 	}
-	bool operator!=(const SString &other) const {
-		return !operator==(other);
-	}
 	bool operator==(const char *sother) const {
 		if ((s == 0) && (sother == 0))
 			return true;
@@ -114,9 +63,6 @@ public:
 			return false;
 		return strcmp(s, sother) == 0;
 	}
-	bool operator!=(const char *sother) const {
-		return !operator==(sother);
-	}
 	const char *c_str() const {
 		if (s)
 			return s;
@@ -136,27 +82,16 @@ public:
 			return '\0';
 	}
 	SString &operator +=(const char *sother) {
-		return append(sother,-1);
-	}
-	SString &operator +=(const SString &sother) {
-		return append(sother.s,sother.ssize);
-	}
-	SString &operator +=(char ch) {
-		return append(&ch,1);
-	}
-	SString &append(const char* sother, int lenOther) {
 		int len = length();
-		if(lenOther < 0)
+		int lenOther = strlen(sother);
-			lenOther = strlen(sother);
 		char *sNew = new char[len + lenOther + 1];
 		if (sNew) {
 			if (s)
 				memcpy(sNew, s, len);
-			strncpy(&sNew[len], sother, lenOther);
+			memcpy(sNew + len, sother, lenOther);
 			sNew[len + lenOther] = '\0';
 			delete []s;
 			s = sNew;
-			ssize = (s) ? strlen(s) : 0;
 		}
 		return *this;
 	}
@@ -166,79 +101,80 @@ public:
 		else 
 			return 0;
 	}
-	void substitute(char find, char replace) {
-		char *t = s;
-		while (t) {
-			t = strchr(t, find);
-			if (t)
-				*t = replace;
-		}
-	}
-	// I don't think this really belongs here -- Neil
-	void correctPath() {
-#ifdef unix
-		substitute('\\', '/');
-#else
-		substitute('/', '\\');
-#endif
-	}
-};
-
-struct Property {
-	unsigned int hash;
-	char *key;
-	char *val;
-	Property *next;
-	Property() : hash(0), key(0), val(0), next(0) {}
 };
 
 class PropSet {
 private:
-	enum { hashRoots=31 };
+	char **vals;
-	Property *props[hashRoots];
+	int size;
+	int used;
 public:
 	PropSet *superPS;
 	PropSet();
 	~PropSet();
+	void EnsureCanAddEntry();
 	void Set(const char *key, const char *val);
 	void Set(char *keyval);
 	SString Get(const char *key);
-	SString GetExpanded(const char *key);
-	SString Expand(const char *withvars);
 	int GetInt(const char *key, int defaultValue=0);
 	SString GetWild(const char *keybase, const char *filename);
 	SString GetNewExpand(const char *keybase, const char *filename);
 	void Clear();
-	void ReadFromMemory(const char *data, int len, const char *directoryForImports=0);
+	void ReadFromMemory(const char *data, int len);
-	void Read(const char *filename, const char *directoryForImports);
+	void Read(const char *filename);
+};
+
+// This is a fixed length list of strings suitable for display  in combo boxes
+// as a memory of user entries
+template<int sz>
+class EntryMemory {
+	SString entries[sz];
+public:
+	void Insert(SString s) {
+		for (int i=0;i<sz;i++) {
+			if (entries[i] == s) {
+				for (int j=i;j>0;j--) {
+					entries[j] = entries[j-1];
+				}
+				entries[0] = s;
+				return;
+			}
+		}
+		for (int k=sz-1;k>0;k--) {
+			entries[k] = entries[k-1];
+		}
+		entries[0] = s;
+	}
+	int Length() const {
+		int len = 0;
+		for (int i=0;i<sz;i++)
+			if (entries[i].length())
+				len++;
+		return len;
+	}
+	SString At(int n) const {
+		return entries[n];
+	}
 };
 
 class WordList {
 public:
 	// Each word contains at least one character - a empty word acts as sentinal at the end.
 	char **words;
-	char **wordsNoCase;
 	char *list;
 	int len;
 	bool onlyLineEnds;	// Delimited by any white space or only line ends
-	bool sorted;
 	int starts[256];
 	WordList(bool onlyLineEnds_ = false) : 
-		words(0), wordsNoCase(0), list(0), len(0), onlyLineEnds(onlyLineEnds_), sorted(false) {}
+		words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) {}
 	~WordList() { Clear(); }
-	operator bool() { return words ? true : false; }
+	operator bool() { return list ? true : false; }
 	const char *operator[](int ind) { return words[ind]; }
 	void Clear();
 	void Set(const char *s);
 	char *Allocate(int size);
 	void SetFromAllocated();
 	bool InList(const char *s);
-	const char *GetNearestWord(const char *wordStart, int searchLen = -1, bool ignoreCase = false);
-	char *GetNearestWords(const char *wordStart, int searchLen = -1, bool ignoreCase = false);
 };
 
-inline bool nonFuncChar(char ch) {
-	return strchr("\t\n\r !\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", ch) != NULL;
-}
-
 #endif

contrib/src/stc/scintilla/include/SciLexer.h

@@ -3,15 +3,11 @@
 // Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-// Most of this file is automatically generated from the Scintilla.iface interface definition
-// file which contains any comments about the definitions. HFacer.py does the generation.
-
 #ifndef SCILEXER_H
 #define SCILEXER_H
 
 // SciLexer features - not in standard Scintilla
 
-//++Autogenerated -- start of section automatically generated from Scintilla.iface
 #define SCLEX_CONTAINER 0
 #define SCLEX_NULL 1
 #define SCLEX_PYTHON 2
@@ -27,8 +23,8 @@
 #define SCLEX_BATCH 12
 #define SCLEX_XCODE 13
 #define SCLEX_LATEX 14
-#define SCLEX_LUA 15
+
-#define SCLEX_DIFF 16
+// Lexical states for SCLEX_PYTHON
 #define SCE_P_DEFAULT 0
 #define SCE_P_COMMENTLINE 1
 #define SCE_P_NUMBER 2
@@ -43,6 +39,8 @@
 #define SCE_P_IDENTIFIER 11
 #define SCE_P_COMMENTBLOCK 12
 #define SCE_P_STRINGEOL 13
+
+// Lexical states for SCLEX_CPP, SCLEX_VB
 #define SCE_C_DEFAULT 0
 #define SCE_C_COMMENT 1
 #define SCE_C_COMMENTLINE 2
@@ -56,7 +54,8 @@
 #define SCE_C_OPERATOR 10
 #define SCE_C_IDENTIFIER 11
 #define SCE_C_STRINGEOL 12
-#define SCE_C_VERBATIM 13
+
+// Lexical states for SCLEX_HTML, SCLEX_xML
 #define SCE_H_DEFAULT 0
 #define SCE_H_TAG 1
 #define SCE_H_TAGUNKNOWN 2
@@ -68,15 +67,14 @@
 #define SCE_H_OTHER 8
 #define SCE_H_COMMENT 9
 #define SCE_H_ENTITY 10
+// XML and ASP
 #define SCE_H_TAGEND 11
 #define SCE_H_XMLSTART 12
 #define SCE_H_XMLEND 13
 #define SCE_H_SCRIPT 14
 #define SCE_H_ASP 15
 #define SCE_H_ASPAT 16
-#define SCE_H_CDATA 17
+// Embedded Javascript
-#define SCE_H_QUESTION 18
-#define SCE_H_VALUE 19
 #define SCE_HJ_START 40
 #define SCE_HJ_DEFAULT 41
 #define SCE_HJ_COMMENT 42
@@ -89,6 +87,7 @@
 #define SCE_HJ_SINGLESTRING 49
 #define SCE_HJ_SYMBOLS 50
 #define SCE_HJ_STRINGEOL 51
+// ASP Javascript
 #define SCE_HJA_START 55
 #define SCE_HJA_DEFAULT 56
 #define SCE_HJA_COMMENT 57
@@ -101,6 +100,7 @@
 #define SCE_HJA_SINGLESTRING 64
 #define SCE_HJA_SYMBOLS 65
 #define SCE_HJA_STRINGEOL 66
+// Embedded VBScript
 #define SCE_HB_START 70
 #define SCE_HB_DEFAULT 71
 #define SCE_HB_COMMENTLINE 72
@@ -109,6 +109,7 @@
 #define SCE_HB_STRING 75
 #define SCE_HB_IDENTIFIER 76
 #define SCE_HB_STRINGEOL 77
+// ASP VBScript
 #define SCE_HBA_START 80
 #define SCE_HBA_DEFAULT 81
 #define SCE_HBA_COMMENTLINE 82
@@ -117,6 +118,7 @@
 #define SCE_HBA_STRING 85
 #define SCE_HBA_IDENTIFIER 86
 #define SCE_HBA_STRINGEOL 87
+// Embedded Python
 #define SCE_HP_START 90
 #define SCE_HP_DEFAULT 91
 #define SCE_HP_COMMENTLINE 92
@@ -130,6 +132,7 @@
 #define SCE_HP_DEFNAME 100
 #define SCE_HP_OPERATOR 101
 #define SCE_HP_IDENTIFIER 102
+// ASP Python
 #define SCE_HPA_START 105
 #define SCE_HPA_DEFAULT 106
 #define SCE_HPA_COMMENTLINE 107
@@ -143,15 +146,8 @@
 #define SCE_HPA_DEFNAME 115
 #define SCE_HPA_OPERATOR 116
 #define SCE_HPA_IDENTIFIER 117
-#define SCE_HPHP_DEFAULT 118
+
-#define SCE_HPHP_HSTRING 119
+// Lexical states for SCLEX_PERL
-#define SCE_HPHP_SIMPLESTRING 120
-#define SCE_HPHP_WORD 121
-#define SCE_HPHP_NUMBER 122
-#define SCE_HPHP_VARIABLE 123
-#define SCE_HPHP_COMMENT 124
-#define SCE_HPHP_COMMENTLINE 125
-#define SCE_HPHP_STRINGEOL 126
 #define SCE_PL_DEFAULT 0
 #define SCE_PL_HERE 1
 #define SCE_PL_COMMENTLINE 2
@@ -174,31 +170,12 @@
 #define SCE_PL_LONGQUOTE 19
 #define SCE_PL_BACKTICKS 20
 #define SCE_PL_DATASECTION 21
+    
+// Lexical states for SCLEX_LATEX
 #define SCE_L_DEFAULT 0
 #define SCE_L_COMMAND 1
 #define SCE_L_TAG 2
 #define SCE_L_MATH 3
 #define SCE_L_COMMENT 4
-#define SCE_LUA_DEFAULT 0
-#define SCE_LUA_COMMENT 1
-#define SCE_LUA_COMMENTLINE 2
-#define SCE_LUA_COMMENTDOC 3
-#define SCE_LUA_NUMBER 4
-#define SCE_LUA_WORD 5
-#define SCE_LUA_STRING 6
-#define SCE_LUA_CHARACTER 7
-#define SCE_LUA_LITERALSTRING 8
-#define SCE_LUA_PREPROCESSOR 9
-#define SCE_LUA_OPERATOR 10
-#define SCE_LUA_IDENTIFIER 11
-#define SCE_LUA_STRINGEOL 12
-#define SCE_ERR_DEFAULT 0
-#define SCE_ERR_PYTHON 1
-#define SCE_ERR_GCC 2
-#define SCE_ERR_MS 3
-#define SCE_ERR_CMD 4
-#define SCE_ERR_BORLAND 5
-#define SCE_ERR_PERL 6
-//--Autogenerated -- end of section automatically generated from Scintilla.iface
 
 #endif

contrib/src/stc/scintilla/include/Scintilla.h

@@ -3,74 +3,119 @@
 // Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-// Most of this file is automatically generated from the Scintilla.iface interface definition
-// file which contains any comments about the definitions. HFacer.py does the generation.
-
 #ifndef SCINTILLA_H
 #define SCINTILLA_H
 
 // Compile-time configuration options
 #define MACRO_SUPPORT 1  // Comment out to remove macro hooks
 
-#if PLAT_WIN
+#if PLAT_GTK
-#ifdef STATIC_BUILD
+#include <gdk/gdk.h>
-void Scintilla_RegisterClasses(HINSTANCE hInstance);
+#include <gtk/gtkvbox.h>
-#endif
+
+#ifdef __cplusplus
+extern "C" {
 #endif
 
-typedef long (*SciFnDirect)(long ptr, unsigned int iMessage, unsigned long wParam, long lParam);
+#define SCINTILLA(obj)          GTK_CHECK_CAST (obj, scintilla_get_type (), ScintillaObject)
+#define SCINTILLA_CLASS(klass)  GTK_CHECK_CLASS_CAS	T (klass, scintilla_get_type (), ScintillaClass)
+#define IS_SCINTILLA(obj)       GTK_CHECK_TYPE (obj, scintilla_get_type ())
+
+	typedef struct _ScintillaObject ScintillaObject;
+	typedef struct _ScintillaClass  ScintillaClass;
+
+	struct _ScintillaObject
+	{
+		GtkFixed vbox;
+		void *pscin;
+	};
+
+	struct _ScintillaClass
+	{
+		GtkFixedClass parent_class;
+
+		void (* command) (ScintillaObject *ttt);
+		void (* notify) (ScintillaObject *ttt);
+	};
+
+	guint		scintilla_get_type	(void);
+	GtkWidget*	scintilla_new		(void);
+	void		scintilla_set_id	(ScintillaObject *sci,int id);
+	long 		scintilla_send_message	(ScintillaObject *sci,int iMessage,int wParam,int lParam);
+
+#include "WinDefs.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#if PLAT_WX
+#include "WinDefs.h"
+#endif
+
+// Both GTK and Windows
 
-//++Autogenerated -- start of section automatically generated from Scintilla.iface
 #define INVALID_POSITION -1 
+
+// Define start of Scintilla messages to be greater than all edit (EM_*) messages
+// as many EM_ messages can be used.
 #define SCI_START 2000
 #define SCI_OPTIONAL_START 3000
 #define SCI_LEXER_START 4000
-#define SCI_ADDTEXT 2001
+
-#define SCI_ADDSTYLEDTEXT 2002
+#define SCI_ADDTEXT SCI_START + 1
-#define SCI_INSERTTEXT 2003
+#define SCI_ADDSTYLEDTEXT SCI_START + 2
-#define SCI_CLEARALL 2004
+#define SCI_INSERTTEXT SCI_START + 3
-#define SCI_CLEARDOCUMENTSTYLE 2005
+#define SCI_CLEARALL SCI_START + 4
-#define SCI_GETLENGTH 2006
+#define SCI_GETLENGTH SCI_START + 6
-#define SCI_GETCHARAT 2007
+#define SCI_GETCHARAT SCI_START + 7
-#define SCI_GETCURRENTPOS 2008
+#define SCI_GETCURRENTPOS SCI_START + 8
-#define SCI_GETANCHOR 2009
+#define SCI_GETANCHOR SCI_START + 9
-#define SCI_GETSTYLEAT 2010
+#define SCI_GETSTYLEAT SCI_START + 10
-#define SCI_REDO 2011
+
-#define SCI_SETUNDOCOLLECTION 2012
+#define SCI_REDO SCI_START + 11
-#define SCI_SELECTALL 2013
+#define SCI_SETUNDOCOLLECTION SCI_START + 12
-#define SCI_SETSAVEPOINT 2014
+#define SCI_SELECTALL SCI_START + 13
-#define SCI_GETSTYLEDTEXT 2015
+#define SCI_SETSAVEPOINT SCI_START + 14
-#define SCI_CANREDO 2016
+#define SCI_GETSTYLEDTEXT SCI_START + 15
-#define SCI_MARKERLINEFROMHANDLE 2017
+#define SCI_CANREDO SCI_START + 16
-#define SCI_MARKERDELETEHANDLE 2018
+#define SCI_MARKERLINEFROMHANDLE SCI_START + 17
-#define SCI_GETUNDOCOLLECTION 2019
+#define SCI_MARKERDELETEHANDLE SCI_START + 18
-#define SCWS_INVISIBLE 0
+
-#define SCWS_VISIBLEALWAYS 1
+#define SC_UNDOCOLLECT_NONE 0
-#define SCWS_VISIBLEAFTERINDENT 2
+#define SC_UNDOCOLLECT_AUTOSTART 1
-#define SCI_GETVIEWWS 2020
+
-#define SCI_SETVIEWWS 2021
+#define SCI_GETVIEWWS SCI_START + 20
-#define SCI_POSITIONFROMPOINT 2022
+#define SCI_SETVIEWWS SCI_START + 21
-#define SCI_GOTOLINE 2024
+#define SCI_GOTOLINE SCI_START + 24
-#define SCI_GOTOPOS 2025
+#define SCI_GOTOPOS SCI_START + 25
-#define SCI_SETANCHOR 2026
+#define SCI_SETANCHOR SCI_START + 26
-#define SCI_GETCURLINE 2027
+#define SCI_GETCURLINE SCI_START + 27
-#define SCI_GETENDSTYLED 2028
+#define SCI_GETENDSTYLED SCI_START + 28
-#define SCI_CONVERTEOLS 2029
+#define SCI_CONVERTEOLS SCI_START + 29
+
+#define SCI_GETEOLMODE SCI_START + 30
+#define SCI_SETEOLMODE SCI_START + 31
+
 #define SC_EOL_CRLF 0
 #define SC_EOL_CR 1
 #define SC_EOL_LF 2
-#define SCI_GETEOLMODE 2030
+
-#define SCI_SETEOLMODE 2031
+#define SCI_STARTSTYLING SCI_START + 32
-#define SCI_STARTSTYLING 2032
+#define SCI_SETSTYLING SCI_START + 33
-#define SCI_SETSTYLING 2033
+
-#define SCI_GETBUFFEREDDRAW 2034
+// This is the same value as CP_UTF8 in Windows
-#define SCI_SETBUFFEREDDRAW 2035
-#define SCI_SETTABWIDTH 2036
-#define SCI_GETTABWIDTH 2121
 #define SC_CP_UTF8 65001
-#define SCI_SETCODEPAGE 2037
+
-#define SCI_SETUSEPALETTE 2039
+#define SCI_SETBUFFEREDDRAW SCI_START + 35
+#define SCI_SETTABWIDTH SCI_START + 36
+#define SCI_SETCODEPAGE SCI_START + 37
+#define SCI_SETUSEPALETTE SCI_START + 39
+
 #define MARKER_MAX 31
+
 #define SC_MARK_CIRCLE 0
 #define SC_MARK_ROUNDRECT 1
 #define SC_MARK_ARROW 2
@@ -80,296 +125,255 @@ typedef long (*SciFnDirect)(long ptr, unsigned int iMessage, unsigned long wPara
 #define SC_MARK_ARROWDOWN 6
 #define SC_MARK_MINUS 7
 #define SC_MARK_PLUS 8
+
+#define SCI_MARKERDEFINE SCI_START + 40
+#define SCI_MARKERSETFORE SCI_START + 41
+#define SCI_MARKERSETBACK SCI_START + 42
+#define SCI_MARKERADD SCI_START + 43
+#define SCI_MARKERDELETE SCI_START + 44
+#define SCI_MARKERDELETEALL SCI_START + 45
+#define SCI_MARKERGET SCI_START + 46
+#define SCI_MARKERNEXT SCI_START + 47
+#define SCI_MARKERPREVIOUS SCI_START + 48
+
 #define SC_MARKNUM_FOLDER 30
 #define SC_MARKNUM_FOLDEROPEN 31
-#define SCI_MARKERDEFINE 2040
+
-#define SCI_MARKERSETFORE 2041
+#define SC_MASK_FOLDERS ((1<<SC_MARKNUM_FOLDER) | (1<<SC_MARKNUM_FOLDEROPEN))
-#define SCI_MARKERSETBACK 2042
+
-#define SCI_MARKERADD 2043
-#define SCI_MARKERDELETE 2044
-#define SCI_MARKERDELETEALL 2045
-#define SCI_MARKERGET 2046
-#define SCI_MARKERNEXT 2047
-#define SCI_MARKERPREVIOUS 2048
 #define SC_MARGIN_SYMBOL 0
 #define SC_MARGIN_NUMBER 1
-#define SCI_SETMARGINTYPEN 2240
+
-#define SCI_GETMARGINTYPEN 2241
+#define SCI_SETMARGINTYPEN SCI_START + 240
-#define SCI_SETMARGINWIDTHN 2242
+#define SCI_GETMARGINTYPEN SCI_START + 241
-#define SCI_GETMARGINWIDTHN 2243
+#define SCI_SETMARGINWIDTHN SCI_START + 242
-#define SCI_SETMARGINMASKN 2244
+#define SCI_GETMARGINWIDTHN SCI_START + 243
-#define SCI_GETMARGINMASKN 2245
+#define SCI_SETMARGINMASKN SCI_START + 244
-#define SCI_SETMARGINSENSITIVEN 2246
+#define SCI_GETMARGINMASKN SCI_START + 245
-#define SCI_GETMARGINSENSITIVEN 2247
+#define SCI_SETMARGINSENSITIVEN SCI_START + 246
+#define SCI_GETMARGINSENSITIVEN SCI_START + 247
+
 #define STYLE_DEFAULT 32
 #define STYLE_LINENUMBER 33
 #define STYLE_BRACELIGHT 34
 #define STYLE_BRACEBAD 35
 #define STYLE_CONTROLCHAR 36
-#define STYLE_INDENTGUIDE 37
 #define STYLE_MAX 127
+
 #define SC_CHARSET_ANSI 0
 #define SC_CHARSET_DEFAULT 1
-#define SC_CHARSET_BALTIC 186
-#define SC_CHARSET_CHINESEBIG5 136
-#define SC_CHARSET_EASTEUROPE 238
-#define SC_CHARSET_GB2312 134
-#define SC_CHARSET_GREEK 161
-#define SC_CHARSET_HANGUL 129
-#define SC_CHARSET_MAC 77
-#define SC_CHARSET_OEM 255
 #define SC_CHARSET_RUSSIAN 204
-#define SC_CHARSET_SHIFTJIS 128
+
-#define SC_CHARSET_SYMBOL 2
+#define SCI_STYLECLEARALL SCI_START + 50
-#define SC_CHARSET_TURKISH 162
+#define SCI_STYLESETFORE SCI_START + 51
-#define SC_CHARSET_JOHAB 130
+#define SCI_STYLESETBACK SCI_START + 52
-#define SC_CHARSET_HEBREW 177
+#define SCI_STYLESETBOLD SCI_START + 53
-#define SC_CHARSET_ARABIC 178
+#define SCI_STYLESETITALIC SCI_START + 54
-#define SC_CHARSET_VIETNAMESE 163
+#define SCI_STYLESETSIZE SCI_START + 55
-#define SC_CHARSET_THAI 222
+#define SCI_STYLESETFONT SCI_START + 56
-#define SCI_STYLECLEARALL 2050
+#define SCI_STYLESETEOLFILLED SCI_START + 57
-#define SCI_STYLESETFORE 2051
+#define SCI_STYLERESETDEFAULT SCI_START + 58
-#define SCI_STYLESETBACK 2052
+#define SCI_STYLESETUNDERLINE SCI_START + 59
-#define SCI_STYLESETBOLD 2053
+#define SCI_STYLESETCHARACTERSET SCI_START + 66
-#define SCI_STYLESETITALIC 2054
+
-#define SCI_STYLESETSIZE 2055
+#define SCI_SETSELFORE SCI_START + 67
-#define SCI_STYLESETFONT 2056
+#define SCI_SETSELBACK SCI_START + 68
-#define SCI_STYLESETEOLFILLED 2057
+#define SCI_SETCARETFORE SCI_START + 69
-#define SCI_STYLERESETDEFAULT 2058
+
-#define SCI_STYLESETUNDERLINE 2059
+#define SCI_ASSIGNCMDKEY SCI_START + 70
-#define SCI_STYLESETCHARACTERSET 2066
+#define SCI_CLEARCMDKEY SCI_START + 71
-#define SCI_SETSELFORE 2067
+#define SCI_CLEARALLCMDKEYS SCI_START + 72
-#define SCI_SETSELBACK 2068
+
-#define SCI_SETCARETFORE 2069
+#define SCI_SETSTYLINGEX SCI_START + 73
-#define SCI_ASSIGNCMDKEY 2070
+
-#define SCI_CLEARCMDKEY 2071
+#define SCI_GETCARETPERIOD SCI_START + 75
-#define SCI_CLEARALLCMDKEYS 2072
+#define SCI_SETCARETPERIOD SCI_START + 76
-#define SCI_SETSTYLINGEX 2073
+#define SCI_SETWORDCHARS SCI_START + 77
-#define SCI_STYLESETVISIBLE 2074
+
-#define SCI_GETCARETPERIOD 2075
+#define SCI_BEGINUNDOACTION SCI_START + 78
-#define SCI_SETCARETPERIOD 2076
+#define SCI_ENDUNDOACTION SCI_START + 79
-#define SCI_SETWORDCHARS 2077
+
-#define SCI_BEGINUNDOACTION 2078
-#define SCI_ENDUNDOACTION 2079
 #define INDIC_MAX 7
+
 #define INDIC_PLAIN 0
 #define INDIC_SQUIGGLE 1
 #define INDIC_TT 2
 #define INDIC_DIAGONAL 3
 #define INDIC_STRIKE 4
+
 #define INDIC0_MASK 32
 #define INDIC1_MASK 64
 #define INDIC2_MASK 128
-#define INDICS_MASK INDIC0_MASK | INDIC1_MASK | INDIC2_MASK
+#define INDICS_MASK (INDIC0_MASK | INDIC1_MASK | INDIC2_MASK)
-#define SCI_INDICSETSTYLE 2080
+
-#define SCI_INDICGETSTYLE 2081
+#define SCI_INDICSETSTYLE SCI_START + 80
-#define SCI_INDICSETFORE 2082
+#define SCI_INDICGETSTYLE SCI_START + 81
-#define SCI_INDICGETFORE 2083
+#define SCI_INDICSETFORE SCI_START + 82
-#define SCI_SETSTYLEBITS 2090
+#define SCI_INDICGETFORE SCI_START + 83
-#define SCI_GETSTYLEBITS 2091
+
-#define SCI_SETLINESTATE 2092
+#define SCI_SETSTYLEBITS SCI_START + 90
-#define SCI_GETLINESTATE 2093
+#define SCI_GETSTYLEBITS SCI_START + 91
-#define SCI_GETMAXLINESTATE 2094
+#define SCI_SETLINESTATE SCI_START + 92
-#define SCI_AUTOCSHOW 2100
+#define SCI_GETLINESTATE SCI_START + 93
-#define SCI_AUTOCCANCEL 2101
+#define SCI_GETMAXLINESTATE SCI_START + 94
-#define SCI_AUTOCACTIVE 2102
+
-#define SCI_AUTOCPOSSTART 2103
+#define SCI_AUTOCSHOW SCI_START + 100
-#define SCI_AUTOCCOMPLETE 2104
+#define SCI_AUTOCCANCEL SCI_START + 101
-#define SCI_AUTOCSTOPS 2105
+#define SCI_AUTOCACTIVE SCI_START + 102
-#define SCI_AUTOCSETSEPARATOR 2106
+#define SCI_AUTOCPOSSTART SCI_START + 103
-#define SCI_AUTOCGETSEPARATOR 2107
+#define SCI_AUTOCCOMPLETE SCI_START + 104
-#define SCI_AUTOCSELECT 2108
+#define SCI_AUTOCSTOPS SCI_START + 105
-#define SCI_AUTOCSETCANCELATSTART 2110
+#define SCI_AUTOCSETSEPARATOR SCI_START + 106
-#define SCI_AUTOCGETCANCELATSTART 2111
+#define SCI_AUTOCGETSEPARATOR SCI_START + 107
-#define SCI_AUTOCSETFILLUPS 2112
+#define SCI_AUTOCSELECT SCI_START + 108
-#define SCI_AUTOCSETCHOOSESINGLE 2113
+
-#define SCI_AUTOCGETCHOOSESINGLE 2114
+#define SCI_GETTABWIDTH SCI_START + 121
-#define SCI_AUTOCSETIGNORECASE 2115
+#define SCI_SETINDENT SCI_START + 122
-#define SCI_AUTOCGETIGNORECASE 2116
+#define SCI_GETINDENT SCI_START + 123
-#define SCI_SETINDENT 2122
+#define SCI_SETUSETABS SCI_START + 124
-#define SCI_GETINDENT 2123
+#define SCI_GETUSETABS SCI_START + 125
-#define SCI_SETUSETABS 2124
+#define SCI_SETLINEINDENTATION SCI_START + 126
-#define SCI_GETUSETABS 2125
+#define SCI_GETLINEINDENTATION SCI_START + 127
-#define SCI_SETLINEINDENTATION 2126
+#define SCI_GETLINEINDENTPOSITION SCI_START + 128
-#define SCI_GETLINEINDENTATION 2127
+
-#define SCI_GETLINEINDENTPOSITION 2128
+#define SCI_SETHSCROLLBAR SCI_START + 130
-#define SCI_GETCOLUMN 2129
+#define SCI_GETHSCROLLBAR SCI_START + 131
-#define SCI_SETHSCROLLBAR 2130
+
-#define SCI_GETHSCROLLBAR 2131
+#define SCI_CALLTIPSHOW SCI_START + 200
-#define SCI_SETINDENTATIONGUIDES 2132
+#define SCI_CALLTIPCANCEL SCI_START + 201
-#define SCI_GETINDENTATIONGUIDES 2133
+#define SCI_CALLTIPACTIVE SCI_START + 202
-#define SCI_SETHIGHLIGHTGUIDE 2134
+#define SCI_CALLTIPPOSSTART SCI_START + 203
-#define SCI_GETHIGHLIGHTGUIDE 2135
+#define SCI_CALLTIPSETHLT SCI_START + 204
-#define SCI_GETLINEENDPOSITION 2136
+#define SCI_CALLTIPSETBACK SCI_START + 205
-#define SCI_GETCODEPAGE 2137
+
-#define SCI_GETCARETFORE 2138
-#define SCI_GETUSEPALETTE 2139
-#define SCI_GETREADONLY 2140
-#define SCI_SETCURRENTPOS 2141
-#define SCI_SETSELECTIONSTART 2142
-#define SCI_GETSELECTIONSTART 2143
-#define SCI_SETSELECTIONEND 2144
-#define SCI_GETSELECTIONEND 2145
-#define SCI_SETPRINTMAGNIFICATION 2146
-#define SCI_GETPRINTMAGNIFICATION 2147
-#define SC_PRINT_NORMAL 0
-#define SC_PRINT_INVERTLIGHT 1
-#define SC_PRINT_BLACKONWHITE 2
-#define SCI_SETPRINTCOLOURMODE 2148
-#define SCI_GETPRINTCOLOURMODE 2149
-#define SCFIND_DOWN 1
-#define SCFIND_WHOLEWORD 2
-#define SCFIND_MATCHCASE 4
-#define SCFIND_WORDSTART 0x00100000
-#define SCFIND_REGEXP 0x00200000
-#define SCI_FINDTEXT 2150
-#define SCI_FORMATRANGE 2151
-#define SCI_GETFIRSTVISIBLELINE 2152
-#define SCI_GETLINE 2153
-#define SCI_GETLINECOUNT 2154
-#define SCI_SETMARGINLEFT 2155
-#define SCI_GETMARGINLEFT 2156
-#define SCI_SETMARGINRIGHT 2157
-#define SCI_GETMARGINRIGHT 2158
-#define SCI_GETMODIFY 2159
-#define SCI_SETSEL 2160
-#define SCI_GETSELTEXT 2161
-#define SCI_GETTEXTRANGE 2162
-#define SCI_HIDESELECTION 2163
-#define SCI_POINTXFROMPOSITION 2164
-#define SCI_POINTYFROMPOSITION 2165
-#define SCI_LINEFROMPOSITION 2166
-#define SCI_POSITIONFROMLINE 2167
-#define SCI_LINESCROLL 2168
-#define SCI_SCROLLCARET 2169
-#define SCI_REPLACESEL 2170
-#define SCI_SETREADONLY 2171
-#define SCI_NULL 2172
-#define SCI_CANPASTE 2173
-#define SCI_CANUNDO 2174
-#define SCI_EMPTYUNDOBUFFER 2175
-#define SCI_UNDO 2176
-#define SCI_CUT 2177
-#define SCI_COPY 2178
-#define SCI_PASTE 2179
-#define SCI_CLEAR 2180
-#define SCI_SETTEXT 2181
-#define SCI_GETTEXT 2182
-#define SCI_GETTEXTLENGTH 2183
-#define SCI_GETDIRECTFUNCTION 2184
-#define SCI_GETDIRECTPOINTER 2185
-#define SCI_SETOVERTYPE 2186
-#define SCI_GETOVERTYPE 2187
-#define SCI_CALLTIPSHOW 2200
-#define SCI_CALLTIPCANCEL 2201
-#define SCI_CALLTIPACTIVE 2202
-#define SCI_CALLTIPPOSSTART 2203
-#define SCI_CALLTIPSETHLT 2204
-#define SCI_CALLTIPSETBACK 2205
-#define SCI_VISIBLEFROMDOCLINE 2220
-#define SCI_DOCLINEFROMVISIBLE 2221
 #define SC_FOLDLEVELBASE 0x400
 #define SC_FOLDLEVELWHITEFLAG 0x1000
 #define SC_FOLDLEVELHEADERFLAG 0x2000
 #define SC_FOLDLEVELNUMBERMASK 0x0FFF
-#define SCI_SETFOLDLEVEL 2222
+
-#define SCI_GETFOLDLEVEL 2223
+#define SCI_VISIBLEFROMDOCLINE SCI_START + 220
-#define SCI_GETLASTCHILD 2224
+#define SCI_DOCLINEFROMVISIBLE SCI_START + 221
-#define SCI_GETFOLDPARENT 2225
+#define SCI_SETFOLDLEVEL SCI_START + 222
-#define SCI_SHOWLINES 2226
+#define SCI_GETFOLDLEVEL SCI_START + 223
-#define SCI_HIDELINES 2227
+#define SCI_GETLASTCHILD SCI_START + 224
-#define SCI_GETLINEVISIBLE 2228
+#define SCI_GETFOLDPARENT SCI_START + 225
-#define SCI_SETFOLDEXPANDED 2229
+#define SCI_SHOWLINES SCI_START + 226
-#define SCI_GETFOLDEXPANDED 2230
+#define SCI_HIDELINES SCI_START + 227
-#define SCI_TOGGLEFOLD 2231
+#define SCI_GETLINEVISIBLE SCI_START + 228
-#define SCI_ENSUREVISIBLE 2232
+#define SCI_SETFOLDEXPANDED SCI_START + 229
-#define SCI_SETFOLDFLAGS 2233
+#define SCI_GETFOLDEXPANDED SCI_START + 230
-#define SCI_LINEDOWN 2300
+#define SCI_TOGGLEFOLD SCI_START + 231
-#define SCI_LINEDOWNEXTEND 2301
+#define SCI_ENSUREVISIBLE SCI_START + 232
-#define SCI_LINEUP 2302
+#define SCI_SETFOLDFLAGS SCI_START + 233
-#define SCI_LINEUPEXTEND 2303
+
-#define SCI_CHARLEFT 2304
+// Key messages
-#define SCI_CHARLEFTEXTEND 2305
+#define SCI_LINEDOWN SCI_START + 300
-#define SCI_CHARRIGHT 2306
+#define SCI_LINEDOWNEXTEND SCI_START + 301
-#define SCI_CHARRIGHTEXTEND 2307
+#define SCI_LINEUP SCI_START + 302
-#define SCI_WORDLEFT 2308
+#define SCI_LINEUPEXTEND SCI_START + 303
-#define SCI_WORDLEFTEXTEND 2309
+#define SCI_CHARLEFT SCI_START + 304
-#define SCI_WORDRIGHT 2310
+#define SCI_CHARLEFTEXTEND SCI_START + 305
-#define SCI_WORDRIGHTEXTEND 2311
+#define SCI_CHARRIGHT SCI_START + 306
-#define SCI_HOME 2312
+#define SCI_CHARRIGHTEXTEND SCI_START + 307
-#define SCI_HOMEEXTEND 2313
+#define SCI_WORDLEFT SCI_START + 308
-#define SCI_LINEEND 2314
+#define SCI_WORDLEFTEXTEND SCI_START + 309
-#define SCI_LINEENDEXTEND 2315
+#define SCI_WORDRIGHT SCI_START + 310
-#define SCI_DOCUMENTSTART 2316
+#define SCI_WORDRIGHTEXTEND SCI_START + 311
-#define SCI_DOCUMENTSTARTEXTEND 2317
+#define SCI_HOME SCI_START + 312
-#define SCI_DOCUMENTEND 2318
+#define SCI_HOMEEXTEND SCI_START + 313
-#define SCI_DOCUMENTENDEXTEND 2319
+#define SCI_LINEEND SCI_START + 314
-#define SCI_PAGEUP 2320
+#define SCI_LINEENDEXTEND SCI_START + 315
-#define SCI_PAGEUPEXTEND 2321
+#define SCI_DOCUMENTSTART SCI_START + 316
-#define SCI_PAGEDOWN 2322
+#define SCI_DOCUMENTSTARTEXTEND SCI_START + 317
-#define SCI_PAGEDOWNEXTEND 2323
+#define SCI_DOCUMENTEND SCI_START + 318
-#define SCI_EDITTOGGLEOVERTYPE 2324
+#define SCI_DOCUMENTENDEXTEND SCI_START + 319
-#define SCI_CANCEL 2325
+#define SCI_PAGEUP SCI_START + 320
-#define SCI_DELETEBACK 2326
+#define SCI_PAGEUPEXTEND SCI_START + 321
-#define SCI_TAB 2327
+#define SCI_PAGEDOWN SCI_START + 322
-#define SCI_BACKTAB 2328
+#define SCI_PAGEDOWNEXTEND SCI_START + 323
-#define SCI_NEWLINE 2329
+#define SCI_EDITTOGGLEOVERTYPE SCI_START + 324
-#define SCI_FORMFEED 2330
+#define SCI_CANCEL SCI_START + 325
-#define SCI_VCHOME 2331
+#define SCI_DELETEBACK SCI_START + 326
-#define SCI_VCHOMEEXTEND 2332
+#define SCI_TAB SCI_START + 327
-#define SCI_ZOOMIN 2333
+#define SCI_BACKTAB SCI_START + 328
-#define SCI_ZOOMOUT 2334
+#define SCI_NEWLINE SCI_START + 329
-#define SCI_DELWORDLEFT 2335
+#define SCI_FORMFEED SCI_START + 330
-#define SCI_DELWORDRIGHT 2336
+#define SCI_VCHOME SCI_START + 331
-#define SCI_LINECUT 2337
+#define SCI_VCHOMEEXTEND SCI_START + 332
-#define SCI_LINEDELETE 2338
+#define SCI_ZOOMIN SCI_START + 333
-#define SCI_LINETRANSPOSE 2339
+#define SCI_ZOOMOUT SCI_START + 334
-#define SCI_LOWERCASE 2340
+#define SCI_DELWORDLEFT SCI_START + 335
-#define SCI_UPPERCASE 2341
+#define SCI_DELWORDRIGHT SCI_START + 336
-#define SCI_LINESCROLLDOWN 2342
+#define SCI_LINECUT SCI_START + 337
-#define SCI_LINESCROLLUP 2343
+#define SCI_LINEDELETE SCI_START + 338
-#define SCI_LINELENGTH 2350
+#define SCI_LINETRANSPOSE SCI_START + 339
-#define SCI_BRACEHIGHLIGHT 2351
+#define SCI_LOWERCASE SCI_START + 340
-#define SCI_BRACEBADLIGHT 2352
+#define SCI_UPPERCASE SCI_START + 341
-#define SCI_BRACEMATCH 2353
+#define SCI_LINESCROLLDOWN SCI_START + 342
-#define SCI_GETVIEWEOL 2355
+#define SCI_LINESCROLLUP SCI_START + 343
-#define SCI_SETVIEWEOL 2356
+
-#define SCI_GETDOCPOINTER 2357
+#define SCI_LINELENGTH SCI_START + 350
-#define SCI_SETDOCPOINTER 2358
+#define SCI_BRACEHIGHLIGHT SCI_START + 351
-#define SCI_SETMODEVENTMASK 2359
+#define SCI_BRACEBADLIGHT SCI_START + 352
+#define SCI_BRACEMATCH SCI_START + 353
+#define SCI_GETVIEWEOL SCI_START + 355
+#define SCI_SETVIEWEOL SCI_START + 356
+#define SCI_GETDOCPOINTER SCI_START + 357
+#define SCI_SETDOCPOINTER SCI_START + 358
+#define SCI_SETMODEVENTMASK SCI_START + 359
+
 #define EDGE_NONE 0
 #define EDGE_LINE 1
 #define EDGE_BACKGROUND 2
-#define SCI_GETEDGECOLUMN 2360
+
-#define SCI_SETEDGECOLUMN 2361
+#define SCI_GETEDGECOLUMN SCI_START + 360
-#define SCI_GETEDGEMODE 2362
+#define SCI_SETEDGECOLUMN SCI_START + 361
-#define SCI_SETEDGEMODE 2363
+#define SCI_GETEDGEMODE SCI_START + 362
-#define SCI_GETEDGECOLOUR 2364
+#define SCI_SETEDGEMODE SCI_START + 363
-#define SCI_SETEDGECOLOUR 2365
+#define SCI_GETEDGECOLOUR SCI_START + 364
-#define SCI_SEARCHANCHOR 2366
+#define SCI_SETEDGECOLOUR SCI_START + 365
-#define SCI_SEARCHNEXT 2367
+
-#define SCI_SEARCHPREV 2368
+#define SCI_SEARCHANCHOR SCI_START + 366
-#define CARET_SLOP 0x01
+#define SCI_SEARCHNEXT SCI_START + 367
-#define CARET_CENTER 0x02
+#define SCI_SEARCHPREV SCI_START + 368
-#define CARET_STRICT 0x04
+
-#define SCI_SETCARETPOLICY 2369
+#define CARET_SLOP 0x01    // Show caret within N lines of edge when it's scrolled to view
-#define SCI_LINESONSCREEN 2370
+#define CARET_CENTER 0x02  // Center caret on screen when it's scrolled to view
-#define SCI_USEPOPUP 2371
+#define CARET_STRICT 0x04  // OR this with CARET_CENTER to reposition even when visible, or
-#define SCI_SELECTIONISRECTANGLE 2372
+                           // OR this with CARET_SLOP to reposition whenever outside slop border
-#define SCI_SETZOOM 2373
+
-#define SCI_GETZOOM 2374
+#define SCI_SETCARETPOLICY SCI_START + 369
-#define SCI_CREATEDOCUMENT 2375
+#define SCI_LINESONSCREEN SCI_START + 370
-#define SCI_ADDREFDOCUMENT 2376
+#define SCI_USEPOPUP SCI_START + 371
-#define SCI_RELEASEDOCUMENT 2377
+#define SCI_SELECTIONISRECTANGLE SCI_START + 372
-#define SCI_GETMODEVENTMASK 2378
+#define SCI_SETZOOM SCI_START + 373
-#define SCI_GRABFOCUS 2400
+#define SCI_GETZOOM SCI_START + 374
-#define SCI_STARTRECORD 3001
+
-#define SCI_STOPRECORD 3002
+#define SCI_ADDREFDOC SCI_START + 375
-#define SCI_SETLEXER 4001
+#define SCI_RELEASEDOC SCI_START + 376
-#define SCI_GETLEXER 4002
+
-#define SCI_COLOURISE 4003
+// GTK+ Specific
-#define SCI_SETPROPERTY 4004
+#define SCI_GRABFOCUS SCI_START + 400
-#define SCI_SETKEYWORDS 4005
+
+// Optional module for macro recording
+#ifdef MACRO_SUPPORT
+typedef void (tMacroRecorder)(UINT iMessage, WPARAM wParam, LPARAM lParam, 
+                              void *userData);
+#define SCI_STARTRECORD SCI_OPTIONAL_START + 1
+#define SCI_STOPRECORD SCI_OPTIONAL_START + 2
+#endif
+
+#define SCI_SETLEXER SCI_LEXER_START + 1
+#define SCI_GETLEXER SCI_LEXER_START + 2
+#define SCI_COLOURISE SCI_LEXER_START + 3
+#define SCI_SETPROPERTY SCI_LEXER_START + 4
+#define SCI_SETKEYWORDS SCI_LEXER_START + 5
+
+// Notifications
+
+// Type of modification and the action which caused the modification
+// These are defined as a bit mask to make it easy to specify which notifications are wanted.
+// One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
 #define SC_MOD_INSERTTEXT 0x1
 #define SC_MOD_DELETETEXT 0x2
 #define SC_MOD_CHANGESTYLE 0x4
@@ -381,98 +385,11 @@ typedef long (*SciFnDirect)(long ptr, unsigned int iMessage, unsigned long wPara
 #define SC_MOD_CHANGEMARKER 0x200
 #define SC_MOD_BEFOREINSERT 0x400
 #define SC_MOD_BEFOREDELETE 0x800
+
 #define SC_MODEVENTMASKALL 0xF77
-#define SCEN_CHANGE 768
-#define SCEN_SETFOCUS 512
-#define SCEN_KILLFOCUS 256
-#define SCK_DOWN 300
-#define SCK_UP 301
-#define SCK_LEFT 302
-#define SCK_RIGHT 303
-#define SCK_HOME 304
-#define SCK_END 305
-#define SCK_PRIOR 306
-#define SCK_NEXT 307
-#define SCK_DELETE 308
-#define SCK_INSERT 309
-#define SCK_ESCAPE 7
-#define SCK_BACK 8
-#define SCK_TAB 9
-#define SCK_RETURN 13
-#define SCK_ADD 310
-#define SCK_SUBTRACT 311
-#define SCK_DIVIDE 312
-#define SCMOD_SHIFT 1
-#define SCMOD_CTRL 2
-#define SCMOD_ALT 4
-#define SCN_STYLENEEDED 2000
-#define SCN_CHARADDED 2001
-#define SCN_SAVEPOINTREACHED 2002
-#define SCN_SAVEPOINTLEFT 2003
-#define SCN_MODIFYATTEMPTRO 2004
-#define SCN_KEY 2005
-#define SCN_DOUBLECLICK 2006
-#define SCN_UPDATEUI 2007
-#define SCN_CHECKBRACE 2007
-#define SCN_MODIFIED 2008
-#define SCN_MACRORECORD 2009
-#define SCN_MARGINCLICK 2010
-#define SCN_NEEDSHOWN 2011
-#define SCN_POSCHANGED 2012
-//--Autogenerated -- end of section automatically generated from Scintilla.iface
-
-// Optional module for macro recording
-#ifdef MACRO_SUPPORT
-typedef void (tMacroRecorder)(unsigned int iMessage, unsigned long wParam, 
-	long lParam, void *userData);
-#endif
-
-// These structures are defined to be exactly the same shape as the Win32
-// CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs.
-// So older code that treats Scintilla as a RichEdit will work.
-
-struct CharacterRange {
-	long cpMin;
-	long cpMax;
-};
-
-struct TextRange {
-	CharacterRange chrg;
-	char *lpstrText;
-};
-
-struct TextToFind {
-	CharacterRange chrg;
-	char *lpstrText;
-	CharacterRange chrgText;
-};
-
-#ifdef PLATFORM_H
-
-// This structure is used in printing and requires some of the graphics types 
-// from Platform.h.  Not needed by most client code.
-
-struct RangeToFormat {
-	SurfaceID hdc;
-	SurfaceID hdcTarget;
-	PRectangle rc;
-	PRectangle rcPage;
-	CharacterRange chrg;
-};
-
-#endif
-
-struct NotifyHeader {
-    // hwndFrom is really an environment specifc window handle or pointer
-    // but most clients of Scintilla.h do not have this type visible.
-	//WindowID hwndFrom;
-	void *hwndFrom; 
-	unsigned int idFrom;
-	unsigned int code;
-};
 
 struct SCNotification {
-	NotifyHeader nmhdr;
+	NMHDR nmhdr;
 	int position;			// SCN_STYLENEEDED, SCN_MODIFIED
 	int ch;					// SCN_CHARADDED, SCN_KEY
 	int modifiers;			// SCN_KEY
@@ -491,7 +408,28 @@ struct SCNotification {
 	int margin;	// SCN_MARGINCLICK
 };
 
-#define SC_MASK_FOLDERS ((1<<SC_MARKNUM_FOLDER) | (1<<SC_MARKNUM_FOLDEROPEN))
+#define SCN_STYLENEEDED 2000
+#define SCN_CHARADDED 2001
+#define SCN_SAVEPOINTREACHED 2002
+#define SCN_SAVEPOINTLEFT 2003
+#define SCN_MODIFYATTEMPTRO 2004
+// GTK+ Specific to work around focus and accelerator problems:
+#define SCN_KEY 2005
+#define SCN_DOUBLECLICK 2006
+#define SCN_UPDATEUI 2007
+// The old name for SCN_UPDATEUI:
+#define SCN_CHECKBRACE 2007
+#define SCN_MODIFIED 2008
+// Optional module for macro recording
+#ifdef MACRO_SUPPORT
+#define SCN_MACRORECORD 2009
+#endif
+#define SCN_MARGINCLICK 2010
+#define SCN_NEEDSHOWN 2011
+
+#ifdef STATIC_BUILD
+void Scintilla_RegisterClasses(HINSTANCE hInstance);
+#endif
 
 // Deprecation section listing all API features that are deprecated and will
 // will be removed completely in a future version.
@@ -499,9 +437,23 @@ struct SCNotification {
 
 #ifdef INCLUDE_DEPRECATED_FEATURES
 
-// Deprecated in 1.27
+#define SCI_CHANGEPOSITION SCI_START + 22
-#define SC_UNDOCOLLECT_NONE 0
+
-#define SC_UNDOCOLLECT_AUTOSTART 1
+// Default style settings. These are deprecated and will be removed in a future version.
+#define SCI_SETFORE SCI_START + 60
+#define SCI_SETBACK SCI_START + 61
+#define SCI_SETBOLD SCI_START + 62
+#define SCI_SETITALIC SCI_START + 63
+#define SCI_SETSIZE SCI_START + 64
+#define SCI_SETFONT SCI_START + 65
+
+#define SCI_APPENDUNDOSTARTACTION SCI_START + 74
+
+#define SC_UNDOCOLLECT_MANUALSTART 2
+
+// Deprecated in release 1.22
+#define SCI_SETMARGINWIDTH SCI_START + 34
+#define SCI_SETLINENUMBERWIDTH SCI_START + 38
 
 #endif
 

contrib/src/stc/scintilla/include/ScintillaWidget.h

@@ -1,46 +0,0 @@
-// Scintilla source code edit control
-// ScintillaWidget.h - definition of Scintilla widget for GTK+
-// Only needed by GTK+ code but is harmless on other platforms.
-// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifndef SCINTILLAWIDGET_H
-#define SCINTILLAWIDGET_H
-
-#if PLAT_GTK
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SCINTILLA(obj)          GTK_CHECK_CAST (obj, scintilla_get_type (), ScintillaObject)
-#define SCINTILLA_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, scintilla_get_type (), ScintillaClass)
-#define IS_SCINTILLA(obj)       GTK_CHECK_TYPE (obj, scintilla_get_type ())
-
-typedef struct _ScintillaObject ScintillaObject;
-typedef struct _ScintillaClass  ScintillaClass;
-
-struct _ScintillaObject {
-	GtkFixed vbox;
-	void *pscin;
-};
-
-struct _ScintillaClass {
-	GtkFixedClass parent_class;
-
-	void (* command) (ScintillaObject *ttt);
-	void (* notify) (ScintillaObject *ttt);
-};
-
-guint		scintilla_get_type	(void);
-GtkWidget*	scintilla_new		(void);
-void		scintilla_set_id	(ScintillaObject *sci,int id);
-long 		scintilla_send_message	(ScintillaObject *sci,int iMessage,int wParam,int lParam);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#endif

contrib/src/stc/scintilla/include/WinDefs.h

@@ -16,7 +16,6 @@
 #define LPSTR char *
 #define LONG long
 
-//#if 0
 /* RTF control */
 #define EM_CANPASTE	(1074)
 #define EM_CANUNDO	(198)
@@ -53,10 +52,12 @@
 
 #define WM_NULL		(0)
 #define WM_CLEAR	(771)
+#define WM_COMMAND	(273)
 #define WM_COPY	(769)
 #define WM_CUT	(768)
 #define WM_GETTEXT	(13)
 #define WM_GETTEXTLENGTH	(14)
+#define WM_NOTIFY	(78)
 #define WM_PASTE	(770)
 #define WM_SETTEXT	(12)
 #define WM_UNDO	(772)
@@ -69,9 +70,6 @@
 #define EC_RIGHTMARGIN 2
 #define EC_USEFONTINFO 0xffff
 
-//#endif
-
-#if 0
 #if PLAT_GTK
 #define VK_DOWN GDK_Down
 #define VK_UP GDK_Up
@@ -111,16 +109,12 @@
 #define VK_SUBTRACT     WXK_SUBTRACT
 //TODO:
 #define VK_DIVIDE	WXK_DIVIDE
-#endif
-
-#define SHIFT_PRESSED 1
-#define LEFT_CTRL_PRESSED 2
-#define LEFT_ALT_PRESSED 4
 
 // Are these needed any more
 #define LPSTR char *
 #define LONG long
 #define LPDWORD (long *)
+#endif
 
 /* SELCHANGE structure */
 #define SEL_EMPTY	(0)
@@ -129,6 +123,15 @@
 #define SEL_MULTICHAR	(4)
 #define SEL_MULTIOBJECT	(8)
 
+/* FINDREPLACE structure */
+#define FR_MATCHCASE	(0x4)
+#define FR_WHOLEWORD	(0x2)
+#define FR_DOWN		(0x1)
+
+#define SHIFT_PRESSED 1
+#define LEFT_CTRL_PRESSED 2
+#define LEFT_ALT_PRESSED 4
+
 struct RECT {
 	LONG left;
 	LONG top;
@@ -136,15 +139,6 @@ struct RECT {
 	LONG bottom;
 };
 
-/* FINDREPLACE structure */
-
-#define FR_MATCHCASE	(0x4)
-#define FR_WHOLEWORD	(0x2)
-#define FR_DOWN		(0x1)
-
-#endif
-
-#if 0
 struct CHARRANGE {
 	LONG cpMin;
 	LONG cpMax;
@@ -174,10 +168,9 @@ struct FORMATRANGE {
 	RECT rcPage;
 	CHARRANGE chrg;
 };
-#endif
 
-//#define MAKELONG(a, b) ((a) | ((b) << 16))
+#define MAKELONG(a, b) ((a) | ((b) << 16))
-//#define LOWORD(x) (x & 0xffff)
+#define LOWORD(x) (x & 0xffff)
-//#define HIWORD(x) (x >> 16)
+#define HIWORD(x) (x >> 16)
 
 #endif

contrib/src/stc/scintilla/include/WindowAccessor.h

@@ -22,7 +22,7 @@ protected:
 public:
 	WindowAccessor(WindowID id_, PropSet &props_) : 
 		Accessor(), id(id_), props(props_), 
-		lenDoc(-1), validLen(0), chFlags(0), chWhile(0) {
+		lenDoc(-1), validLen(0), chFlags(0) {
 	}
 	~WindowAccessor();
 	char StyleAt(int position);

contrib/src/stc/scintilla/src/Accessor.cxx

@@ -0,0 +1,112 @@
+// SciTE - Scintilla based Text Editor
+// Accessor.cxx - rapid easy access to contents of a Scintilla
+// Copyright 1998-2000 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "Platform.h"
+
+#include "PropSet.h"
+#include "Accessor.h"
+#include "Scintilla.h"
+
+void Accessor::Fill(int position) {
+	if (lenDoc == -1)
+		lenDoc = Platform::SendScintilla(id, WM_GETTEXTLENGTH, 0, 0);
+	startPos = position - slopSize;
+	if (startPos + bufferSize > lenDoc)
+		startPos = lenDoc - bufferSize;
+	if (startPos < 0)
+		startPos = 0;
+	endPos = startPos + bufferSize;
+	if (endPos > lenDoc)
+		endPos = lenDoc;
+
+	TEXTRANGE tr = {{startPos, endPos}, buf};
+	Platform::SendScintilla(id, EM_GETTEXTRANGE, 0, reinterpret_cast<LPARAM>(&tr));
+}
+
+char Accessor::StyleAt(int position) {
+	return static_cast<char>(Platform::SendScintilla(
+		id, SCI_GETSTYLEAT, position, 0));
+}
+
+int Accessor::GetLine(int position) {
+	return Platform::SendScintilla(id, EM_LINEFROMCHAR, position, 0);
+}
+
+int Accessor::LineStart(int line) {
+	return Platform::SendScintilla(id, EM_LINEINDEX, line, 0);
+}
+
+int Accessor::LevelAt(int line) {
+	return Platform::SendScintilla(id, SCI_GETFOLDLEVEL, line, 0);
+}
+
+int Accessor::Length() { 
+	if (lenDoc == -1) 
+		lenDoc = Platform::SendScintilla(id, WM_GETTEXTLENGTH, 0, 0);
+	return lenDoc; 
+}
+
+int Accessor::GetLineState(int line) {
+	return Platform::SendScintilla(id, SCI_GETLINESTATE, line);
+}
+
+int Accessor::SetLineState(int line, int state) {
+	return Platform::SendScintilla(id, SCI_SETLINESTATE, line, state);
+}
+
+void StylingContext::StartAt(unsigned int start, char chMask) {
+	Platform::SendScintilla(id, SCI_STARTSTYLING, start, chMask);
+}
+
+void StylingContext::ColourSegment(unsigned int start, unsigned int end, int chAttr) {
+	// Only perform styling if non empty range
+	if (end != start - 1) {
+		if (end < start) {
+			Platform::DebugPrintf("Bad colour positions %d - %d\n", start, end);
+		}
+
+		if (validLen + (end - start + 1) >= bufferSize)
+			Flush();
+		if (validLen + (end - start + 1) >= bufferSize) {
+			// Too big for buffer so send directly
+			Platform::SendScintilla(id, SCI_SETSTYLING, end - start + 1, chAttr);
+		} else {
+			if (chAttr != chWhile)
+				chFlags = 0;
+			chAttr |= chFlags;
+			for (unsigned int i = start; i <= end; i++) {
+				styleBuf[validLen++] = chAttr;
+			}
+		}
+	}
+}
+
+void StylingContext::StartSegment(unsigned int pos) {
+	startSeg = pos;
+}
+
+void StylingContext::ColourTo(unsigned int pos, int chAttr) {
+	ColourSegment(startSeg, pos, chAttr);
+	startSeg = pos+1;
+}
+
+int StylingContext::GetLine(int position) {
+	return Platform::SendScintilla(id, EM_LINEFROMCHAR, position, 0);
+}
+
+void StylingContext::SetLevel(int line, int level) {
+	Platform::SendScintilla(id, SCI_SETFOLDLEVEL, line, level);
+}
+
+void StylingContext::Flush() {
+	if (validLen > 0) {
+		Platform::SendScintilla(id, SCI_SETSTYLINGEX, validLen, 
+			reinterpret_cast<LPARAM>(styleBuf));
+		validLen = 0;
+	}
+}

contrib/src/stc/scintilla/src/AutoComplete.cxx

@@ -10,16 +10,12 @@
 
 #include "AutoComplete.h"
 
-AutoComplete::AutoComplete() : 
+AutoComplete::AutoComplete() {
-	active(false),
+	lb = 0;
-	separator(' '),
+	active = false;
-	ignoreCase(false),
+	posStart = 0;
-	chooseSingle(false),
+	strcpy(stopChars, "");
-	posStart(0),
+	separator = ' ';
-	startLen(0),
-	cancelAtStartPos(true) {
-	stopChars[0] = '\0';
-	fillUpChars[0] = '\0';
 }
 
 AutoComplete::~AutoComplete() {
@@ -49,15 +45,6 @@ bool AutoComplete::IsStopChar(char ch) {
 	return ch && strchr(stopChars, ch);
 }
 
-void AutoComplete::SetFillUpChars(const char *fillUpChars_) {
-	strncpy(fillUpChars, fillUpChars_, sizeof(fillUpChars));
-	fillUpChars[sizeof(fillUpChars) - 1] = '\0';
-}
-
-bool AutoComplete::IsFillUpChar(char ch) {
-	return ch && strchr(fillUpChars, ch);
-}
- 
 void AutoComplete::SetSeparator(char separator_) {
 	separator = separator_;
 }
@@ -66,7 +53,8 @@ char AutoComplete::GetSeparator() {
 	return separator;
 }
 
-void AutoComplete::SetList(const char *list) {
+int AutoComplete::SetList(const char *list) {
+	int maxStrLen = 12;
 	lb.Clear();
 	char *words = new char[strlen(list) + 1];
 	if (words) {
@@ -77,15 +65,18 @@ void AutoComplete::SetList(const char *list) {
 			if (words[i] == separator) {
 				words[i] = '\0';
 				lb.Append(startword);
+				maxStrLen = Platform::Maximum(maxStrLen, strlen(startword));
 				startword = words + i + 1;
 			}
 		}
 		if (startword) {
 			lb.Append(startword);
+			maxStrLen = Platform::Maximum(maxStrLen, strlen(startword));
 		}
 		delete []words;
 	}
 	lb.Sort();
+	return maxStrLen;
 }
 
 void AutoComplete::Show() {
@@ -96,6 +87,7 @@ void AutoComplete::Show() {
 void AutoComplete::Cancel() {
 	if (lb.Created()) {
 		lb.Destroy();
+		lb = 0;
 		active = false;
 	}
 }

contrib/src/stc/scintilla/src/AutoComplete.h

@@ -9,16 +9,11 @@
 class AutoComplete {
 	bool active;
 	char stopChars[256];
-	char fillUpChars[256];
 	char separator;
 public:
-	bool ignoreCase;
-	bool chooseSingle;
 	ListBox lb;
 	int posStart;
 	int startLen;
-	// Should autocompletion be canceled if editor's currentPos <= startPos?
-	bool cancelAtStartPos;
 	
 	AutoComplete();
 	~AutoComplete();
@@ -33,16 +28,12 @@ public:
 	void SetStopChars(const char *stopChars_);
 	bool IsStopChar(char ch);
 	
-	// The fillup chars are characters which, when typed, fill up the selected word
-	void SetFillUpChars(const char *fillUpChars_);
-	bool IsFillUpChar(char ch);
-
 	// The separator character is used when interpreting the list in SetList
 	void SetSeparator(char separator_);
 	char GetSeparator();
 	
 	// The list string contains a sequence of words separated by the separator character
-	void SetList(const char *list);
+	int SetList(const char *list);
 	
 	void Show();
 	void Cancel();

contrib/src/stc/scintilla/src/CellBuffer.cxx

@@ -88,7 +88,7 @@ void MarkerHandleSet::RemoveHandle(int handle) {
 		if (mhn->handle == handle) {
 			*pmhn = mhn->next;
 			delete mhn;
-			return ;
+			return;
 		}
 		pmhn = &((*pmhn)->next);
 	}
@@ -101,7 +101,7 @@ void MarkerHandleSet::RemoveNumber(int markerNum) {
 		if (mhn->number == markerNum) {
 			*pmhn = mhn->next;
 			delete mhn;
-			return ;
+			return;
 		}
 		pmhn = &((*pmhn)->next);
 	}
@@ -119,11 +119,7 @@ void MarkerHandleSet::CombineWith(MarkerHandleSet *other) {
 LineVector::LineVector() {
 	linesData = 0;
 	lines = 0;
-	size = 0;
 	levels = 0;
-	sizeLevels = 0;
-	handleCurrent = 1;
-
 	Init();
 }
 
@@ -165,7 +161,6 @@ void LineVector::Expand(int sizeNew) {
 		Platform::DebugPrintf("No memory available\n");
 		// TODO: Blow up
 	}
-
 }
 
 void LineVector::ExpandLevels(int sizeNew) {
@@ -185,13 +180,6 @@ void LineVector::ExpandLevels(int sizeNew) {
 		Platform::DebugPrintf("No memory available\n");
 		// TODO: Blow up
 	}
-
-}
-
-void LineVector::ClearLevels() {
-	delete []levels;
-	levels = 0;
-	sizeLevels = 0;
 }
 
 void LineVector::InsertValue(int pos, int value) {
@@ -214,10 +202,10 @@ void LineVector::InsertValue(int pos, int value) {
 		}
 		if (pos == 0) {
 			levels[pos] = SC_FOLDLEVELBASE;
-		} else if (pos == (lines - 1)) {	// Last line will not be a folder
+		} else if (pos == (lines-1)) {	// Last line will not be a folder
 			levels[pos] = SC_FOLDLEVELBASE;
 		} else {
-			levels[pos] = levels[pos - 1];
+			levels[pos] = levels[pos-1];
 		}
 	}
 }
@@ -246,10 +234,10 @@ void LineVector::Remove(int pos) {
 		linesData[i] = linesData[i + 1];
 	}
 	if (levels) {
-		// Level information merges back onto previous line
+        // Level information merges back onto previous line
-		int posAbove = pos - 1;
+        int posAbove = pos-1;
-		if (posAbove < 0)
+        if (posAbove < 0)
-			posAbove = 0;
+            posAbove = 0;
 		for (int j = posAbove; j < lines; j++) {
 			levels[j] = levels[j + 1];
 		}
@@ -292,12 +280,11 @@ int LineVector::AddMark(int line, int markerNum) {
 }
 
 void LineVector::MergeMarkers(int pos) {
-	if (linesData[pos + 1].handleSet != NULL) {
+	if (linesData[pos].handleSet || linesData[pos + 1].handleSet) {
-		if (linesData[pos].handleSet == NULL )
+		if (linesData[pos].handleSet && linesData[pos + 1].handleSet) {
-			linesData[pos].handleSet = new MarkerHandleSet;
+			linesData[pos].handleSet->CombineWith(linesData[pos].handleSet);
-		linesData[pos].handleSet->CombineWith(linesData[pos + 1].handleSet);
+			linesData[pos].handleSet = 0;
-		delete linesData[pos + 1].handleSet;
+		}
-		linesData[pos + 1].handleSet = NULL;
 	}
 }
 
@@ -425,7 +412,7 @@ void UndoHistory::EnsureUndoRoom() {
 			int lenActionsNew = lenActions * 2;
 			Action *actionsNew = new Action[lenActionsNew];
 			if (!actionsNew)
-				return ;
+				return;
 			for (int act = 0; act <= currentAction; act++)
 				actionsNew[act].Grab(&actions[act]);
 			delete []actions;
@@ -442,7 +429,7 @@ void UndoHistory::AppendAction(actionType at, int position, char *data, int leng
 	//	actions[currentAction - 1].position, actions[currentAction - 1].lenData);
 	if (currentAction >= 1) {
 		if (0 == undoSequenceDepth) {
-			// Top level actions may not always be coalesced
+		// Top level actions may not always be coalesced
 			Action &actPrevious = actions[currentAction - 1];
 			// See if current action can be coalesced into previous action
 			// Will work if both are inserts or deletes and position is same
@@ -451,17 +438,16 @@ void UndoHistory::AppendAction(actionType at, int position, char *data, int leng
 			} else if (currentAction == savePoint) {
 				currentAction++;
 			} else if ((at == removeAction) && 
-			           ((position + lengthData * 2) != actPrevious.position)) {
+				((position + lengthData * 2) != actPrevious.position)) {
 				// Removals must be at same position to coalesce
 				currentAction++;
 			} else if ((at == insertAction) && 
-			           (position != (actPrevious.position + actPrevious.lenData*2))) {
+				(position != (actPrevious.position + actPrevious.lenData*2))) {
 				// Insertions must be immediately after to coalesce
 				currentAction++;
 			} else {
 				//Platform::DebugPrintf("action coalesced\n");
 			}
-
 		} else {
 			// Actions not at top level are always coalesced unless this is after return to top level
 			if (!actions[currentAction].mayCoalesce)
@@ -581,7 +567,7 @@ CellBuffer::CellBuffer(int initialLength) {
 	gaplen = initialLength;
 	part2body = body + gaplen;
 	readOnly = false;
-	collectingUndo = true;
+	collectingUndo = undoCollectAutoStart;
 }
 
 CellBuffer::~CellBuffer() {
@@ -591,7 +577,7 @@ CellBuffer::~CellBuffer() {
 
 void CellBuffer::GapTo(int position) {
 	if (position == part1len)
-		return ;
+		return;
 	if (position < part1len) {
 		int diff = part1len - position;
 		//Platform::DebugPrintf("Move gap backwards to %d diff = %d part1len=%d length=%d \n", position,diff, part1len, length);
@@ -623,7 +609,6 @@ void CellBuffer::RoomFor(int insertionLength) {
 		size = newSize;
 		//Platform::DebugPrintf("end need room %d %d - size=%d length=%d\n", gaplen, insertionLength,size,length);
 	}
-
 }
 
 // To make it easier to write code that uses ByteAt, a position outside the range of the buffer
@@ -648,16 +633,16 @@ void CellBuffer::SetByteAt(int position, char ch) {
 
 	if (position < 0) {
 		//Platform::DebugPrintf("Bad position %d\n",position);
-		return ;
+		return;
 	}
 	if (position >= length + 11) {
 		Platform::DebugPrintf("Very Bad position %d of %d\n", position, length);
 		//exit(2);
-		return ;
+		return;
 	}
 	if (position >= length) {
 		//Platform::DebugPrintf("Bad position %d of %d\n",position,length);
-		return ;
+		return;
 	}
 
 	if (position < part1len) {
@@ -673,20 +658,20 @@ char CellBuffer::CharAt(int position) {
 
 void CellBuffer::GetCharRange(char *buffer, int position, int lengthRetrieve) {
 	if (lengthRetrieve < 0)
-		return ;
+		return;
 	if (position < 0)
-		return ;
+		return;
 	int bytePos = position * 2;
 	if ((bytePos + lengthRetrieve * 2) > length) {
-		Platform::DebugPrintf("Bad GetCharRange %d for %d of %d\n", bytePos,
+		Platform::DebugPrintf("Bad GetCharRange %d for %d of %d\n",bytePos,
-		                      lengthRetrieve, length);
+			lengthRetrieve, length);
-		return ;
+		return;
 	}
 	GapTo(0); 	// Move the buffer so its easy to subscript into it
 	char *pb = part2body + bytePos;
 	while (lengthRetrieve--) {
 		*buffer++ = *pb;
-		pb += 2;
+		pb +=2;
 	}
 }
 
@@ -721,7 +706,7 @@ void CellBuffer::InsertCharStyle(int position, char ch, char style) {
 }
 
 bool CellBuffer::SetStyleAt(int position, char style, char mask) {
-	char curVal = ByteAt(position * 2 + 1);
+	char curVal = ByteAt(position*2 + 1);
 	if ((curVal & mask) != style) {
 		SetByteAt(position*2 + 1, static_cast<char>((curVal & ~mask) | style));
 		return true;
@@ -838,7 +823,7 @@ int CellBuffer::LineFromHandle(int markerHandle) {
 void CellBuffer::BasicInsertString(int position, char *s, int insertLength) {
 	//Platform::DebugPrintf("Inserting at %d for %d\n", position, insertLength);
 	if (insertLength == 0)
-		return ;
+		return;
 	RoomFor(insertLength);
 	GapTo(position);
 
@@ -898,7 +883,7 @@ void CellBuffer::BasicInsertString(int position, char *s, int insertLength) {
 void CellBuffer::BasicDeleteChars(int position, int deleteLength) {
 	//Platform::DebugPrintf("Deleting at %d for %d\n", position, deleteLength);
 	if (deleteLength == 0)
-		return ;
+		return;
 
 	if ((position == 0) && (deleteLength == length)) {
 		// If whole buffer is being deleted, faster to reinitialise lines data
@@ -930,7 +915,6 @@ void CellBuffer::BasicDeleteChars(int position, int deleteLength) {
 			ignoreNL = true; 	// First \n is not real deletion
 		}
 
-
 		char ch = chNext;
 		for (int i = 0; i < deleteLength; i += 2) {
 			chNext = ' ';
@@ -948,7 +932,6 @@ void CellBuffer::BasicDeleteChars(int position, int deleteLength) {
 				ignoreNL = false; 	// Further \n are not real deletions
 			}
 
-
 			ch = chNext;
 		}
 		// May have to fix up end if last deletion causes cr to be next to lf
@@ -969,7 +952,7 @@ void CellBuffer::BasicDeleteChars(int position, int deleteLength) {
 	part2body = body + gaplen;
 }
 
-bool CellBuffer::SetUndoCollection(bool collectUndo) {
+undoCollectionType CellBuffer::SetUndoCollection(undoCollectionType collectUndo) {
 	collectingUndo = collectUndo;
 	uh.DropUndoSequence();
 	return collectingUndo;
@@ -1011,12 +994,12 @@ void CellBuffer::PerformUndoStep() {
 		char *styledData = new char[actionStep.lenData * 2];
 		for (int i = 0; i < actionStep.lenData; i++) {
 			styledData[i*2] = actionStep.data[i];
-			styledData[i*2 + 1] = 0;
+			styledData[i*2+1] = 0;
 		}
 		BasicInsertString(actionStep.position, styledData, actionStep.lenData*2);
 		delete []styledData;
 	}
-	uh.CompletedUndoStep();
+    uh.CompletedUndoStep();
 }
 
 bool CellBuffer::CanRedo() {
@@ -1037,14 +1020,14 @@ void CellBuffer::PerformRedoStep() {
 		char *styledData = new char[actionStep.lenData * 2];
 		for (int i = 0; i < actionStep.lenData; i++) {
 			styledData[i*2] = actionStep.data[i];
-			styledData[i*2 + 1] = 0;
+			styledData[i*2+1] = 0;
 		}
 		BasicInsertString(actionStep.position, styledData, actionStep.lenData*2);
 		delete []styledData;
 	} else if (actionStep.at == removeAction) {
 		BasicDeleteChars(actionStep.position, actionStep.lenData*2);
 	}
-	uh.CompletedRedoStep();
+    uh.CompletedRedoStep();
 }
 
 int CellBuffer::SetLineState(int line, int state) {
@@ -1083,6 +1066,3 @@ int CellBuffer::GetLevel(int line) {
 	}
 }
 
-void CellBuffer::ClearLevels() {
-	lv.ClearLevels();
-}

contrib/src/stc/scintilla/src/CellBuffer.h

@@ -58,7 +58,6 @@ public:
 
 	void Expand(int sizeNew);
 	void ExpandLevels(int sizeNew=-1);
-    void ClearLevels();
 	void InsertValue(int pos, int value);
 	void SetValue(int pos, int value);
 	void Remove(int pos);
@@ -89,6 +88,8 @@ public:
 	void Grab(Action *source);
 };
 
+enum undoCollectionType { undoCollectNone, undoCollectAutoStart, undoCollectManualStart };
+
 class UndoHistory {
 	Action *actions;
 	int lenActions;
@@ -140,12 +141,12 @@ private:
 	char *part2body;
 	bool readOnly;
 
-	bool collectingUndo;
+	undoCollectionType collectingUndo;
 	UndoHistory uh;
 
 	LineVector lv;
 
-	SVector lineStates;
+	SVector<int, 4000> lineStates;
 
 	void GapTo(int position);
 	void RoomFor(int insertionLength);
@@ -198,7 +199,7 @@ public:
 	void BasicInsertString(int position, char *s, int insertLength);
 	void BasicDeleteChars(int position, int deleteLength);
 
-	bool SetUndoCollection(bool collectUndo);
+	undoCollectionType SetUndoCollection(undoCollectionType collectUndo);
 	bool IsCollectingUndo();
 	void BeginUndoAction();
 	void EndUndoAction();
@@ -221,7 +222,6 @@ public:
 		
 	int SetLevel(int line, int level);
 	int GetLevel(int line);
-    void ClearLevels();
 };
 
 #define CELL_SIZE	2

contrib/src/stc/scintilla/src/ContractionState.cxx

@@ -171,6 +171,12 @@ bool ContractionState::SetVisible(int lineDocStart, int lineDocEnd, bool visible
 				delta += visible ? 1 : -1;		
 				lines[line].visible = visible;
 			}
+			lines[line].displayLine += delta;
+		}
+		if (delta != 0) {
+			for (int line=lineDocEnd+1; line <= linesInDoc; line++) {
+				lines[line].displayLine += delta;
+			}
 		}
 	}
 	linesInDisplay += delta;
@@ -200,9 +206,3 @@ bool ContractionState::SetExpanded(int lineDoc, bool expanded) {
 	}
 	return false;
 }
-
-void ContractionState::ShowAll() {
-	delete []lines;
-	lines = 0;
-	size = 0;
-}

contrib/src/stc/scintilla/src/ContractionState.h

@@ -45,8 +45,6 @@ public:
 	
 	bool GetExpanded(int lineDoc) const;
 	bool SetExpanded(int lineDoc, bool expanded);
-
-    void ShowAll();
 };
 
 #endif

contrib/src/stc/scintilla/src/Document.cxx

@@ -54,7 +54,7 @@ int Document::AddRef() {
 	return refCount++;
 }
 
-// Decrease reference count and return its previous value.
+// Decrease reference count and return its provius value.
 // Delete the document if reference count reaches zero.
 int Document::Release() {
 	int curRefCount = --refCount;
@@ -201,8 +201,8 @@ bool Document::IsCrLf(int pos) {
 	return (cb.CharAt(pos) == '\r') && (cb.CharAt(pos + 1) == '\n');
 }
 
-#if PLAT_WIN
 bool Document::IsDBCS(int pos) {
+#if PLAT_WIN
 	if (dbcsCodePage) {
 		if (SC_CP_UTF8 == dbcsCodePage) {
 			unsigned char ch = static_cast<unsigned char>(cb.CharAt(pos));
@@ -224,14 +224,10 @@ bool Document::IsDBCS(int pos) {
 		}
 	}
 	return false;
-}
 #else
-// PLAT_GTK or PLAT_WX
-// TODO: support DBCS under GTK+ and WX
-bool Document::IsDBCS(int) {
 	return false;
-}
 #endif
+}
 
 int Document::LenChar(int pos) {
 	if (IsCrLf(pos)) {
@@ -338,8 +334,6 @@ void Document::ModifiedAt(int pos) {
 
 // Unlike Undo, Redo, and InsertStyledString, the pos argument is a cell number not a char number
 void Document::DeleteChars(int pos, int len) {
-    if ((pos + len) > Length())
-        return;
 	if (cb.IsReadOnly() && enteredReadOnlyCount==0) {
 		enteredReadOnlyCount++;
 		NotifyModifyAttempt();
@@ -596,8 +590,6 @@ void Document::SetLineIndentation(int line, int indent) {
 }
 
 int Document::GetLineIndentPosition(int line) {
-    if (line < 0)
-        return 0;
 	int pos = LineStart(line);
 	int length = Length();
 	while ((pos < length) && isindentchar(cb.CharAt(pos))) {
@@ -606,25 +598,6 @@ int Document::GetLineIndentPosition(int line) {
 	return pos;
 }
 
-int Document::GetColumn(int pos) {
-	int column = 0;
-	int line = LineFromPosition(pos);
-	if ((line >= 0) && (line < LinesTotal())) {
-		for (int i=LineStart(line);i<pos;i++) {
-			char ch = cb.CharAt(i);
-			if (ch == '\t')
-				column = NextTab(column, tabInChars);
-			else if (ch == '\r')
-				return column;
-			else if (ch == '\n')
-				return column;
-			else
-				column++;
-		}
-	}
-	return column;
-}
-
 void Document::Indent(bool forwards, int lineBottom, int lineTop) {
 	// Dedent - suck white space off the front of the line to dedent by equivalent of a tab
 	for (int line = lineBottom; line >= lineTop; line--) {
@@ -717,29 +690,25 @@ int Document::NextWordStart(int pos, int delta) {
 	return pos;
 }
 
-bool Document::IsWordStartAt(int pos) {
-	if (pos > 0) {
-		return !IsWordChar(CharAt(pos - 1));
-	}
-	return true;
-}
-
-bool Document::IsWordEndAt(int pos) {
-	if (pos < Length() - 1) {
-		return !IsWordChar(CharAt(pos));
-	}
-	return true;
-}
-
 bool Document::IsWordAt(int start, int end) {
-	return IsWordStartAt(start) && IsWordEndAt(end);
+	int lengthDoc = Length();
+	if (start > 0) {
+		char ch = CharAt(start - 1);
+		if (IsWordChar(ch))
+			return false;
+	}
+	if (end < lengthDoc - 1) {
+		char ch = CharAt(end);
+		if (IsWordChar(ch))
+			return false;
+	}
+	return true;
 }
 
 // Find text in document, supporting both forward and backward
 // searches (just pass minPos > maxPos to do a backward search)
 // Has not been tested with backwards DBCS searches yet.
-long Document::FindText(int minPos, int maxPos, const char *s, 
+long Document::FindText(int minPos, int maxPos, const char *s, bool caseSensitive, bool word) {
-	bool caseSensitive, bool word, bool wordStart) {
  	bool forward = minPos <= maxPos;
 	int increment = forward ? 1 : -1;
 
@@ -769,10 +738,8 @@ long Document::FindText(int minPos, int maxPos, const char *s,
 						found = false;
 				}
 				if (found) {
-					if ((!word && !wordStart) ||
+					if ((!word) || IsWordAt(pos, pos + lengthFind))
-						word && IsWordAt(pos, pos + lengthFind) ||
+						return pos;
-						wordStart && IsWordStartAt(pos))
- 						return pos;
 				}
 			}
 		} else {
@@ -784,10 +751,8 @@ long Document::FindText(int minPos, int maxPos, const char *s,
 						found = false;
 				}
 				if (found) {
-					if (!(word && wordStart) ||
+					if ((!word) || IsWordAt(pos, pos + lengthFind))
-						word && IsWordAt(pos, pos + lengthFind) ||
+						return pos;
-						wordStart && IsWordStartAt(pos))
- 						return pos;
 				}
 			}
 		}

contrib/src/stc/scintilla/src/Document.h

@@ -113,10 +113,9 @@ public:
 	bool CanUndo() { return cb.CanUndo(); }
 	bool CanRedo() { return cb.CanRedo(); }
 	void DeleteUndoHistory() { cb.DeleteUndoHistory(); }
-	bool SetUndoCollection(bool collectUndo) {
+	undoCollectionType SetUndoCollection(undoCollectionType collectUndo) {
 		return cb.SetUndoCollection(collectUndo);
 	}
-	bool IsCollectingUndo() { return cb.IsCollectingUndo(); }
 	void BeginUndoAction() { cb.BeginUndoAction(); }
 	void EndUndoAction() { cb.EndUndoAction(); }
 	void SetSavePoint();
@@ -125,11 +124,9 @@ public:
 	int GetLineIndentation(int line);
 	void SetLineIndentation(int line, int indent);
 	int GetLineIndentPosition(int line);
-	int GetColumn(int position);
 	void Indent(bool forwards, int lineBottom, int lineTop);
 	void ConvertLineEnds(int eolModeSet);
 	void SetReadOnly(bool set) { cb.SetReadOnly(set); }
-	bool IsReadOnly() { return cb.IsReadOnly(); }
 
 	void InsertChar(int pos, char ch);
 	void InsertString(int position, const char *s);
@@ -156,7 +153,6 @@ public:
 
 	int SetLevel(int line, int level);
 	int GetLevel(int line) { return cb.GetLevel(line); }
-	void ClearLevels() { cb.ClearLevels(); }
 	int GetLastChild(int lineParent, int level=-1);
 	int GetFoldParent(int line);
 
@@ -164,9 +160,8 @@ public:
 	int ExtendWordSelect(int pos, int delta);
 	int NextWordStart(int pos, int delta);
 	int Length() { return cb.Length(); }
-	long FindText(int minPos, int maxPos, const char *s, 
+	long FindText(int minPos, int maxPos, const char *s, bool caseSensitive, bool word);
-		bool caseSensitive, bool word, bool wordStart);
+	long FindText(WORD iMessage,WPARAM wParam,LPARAM lParam);
-	long FindText(int iMessage, unsigned long wParam, long lParam);
 	int LinesTotal();
 	
 	void ChangeCase(Range r, bool makeUpperCase);
@@ -191,8 +186,6 @@ public:
 private:
 	bool IsDBCS(int pos);
 	bool IsWordChar(unsigned char ch);
-	bool IsWordStartAt(int pos);
-	bool IsWordEndAt(int pos);
 	bool IsWordAt(int start, int end);
 	void ModifiedAt(int pos);
 	

contrib/src/stc/scintilla/src/DocumentAccessor.cxx

@@ -4,7 +4,6 @@
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
-#include <string.h>
 #include <ctype.h> 
 #include <stdio.h>
 
@@ -21,22 +20,21 @@
 DocumentAccessor::~DocumentAccessor() {
 }
 
-#if PLAT_WIN 
 bool DocumentAccessor::InternalIsLeadByte(char ch) {
+#if PLAT_GTK
+	// TODO: support DBCS under GTK+
+	return false;
+#elif PLAT_WIN 
 	if (SC_CP_UTF8 == codePage)
 		// For lexing, all characters >= 0x80 are treated the
 		// same so none is considered a lead byte.
 		return false;	
 	else
 		return IsDBCSLeadByteEx(codePage, ch);
-}
+#elif PLAT_WX 
-#else
-// PLAT_GTK or PLAT_WX
-// TODO: support DBCS under GTK+ and WX
-bool DocumentAccessor::InternalIsLeadByte(char) {
 	return false;
-}
 #endif 
+}
 
 void DocumentAccessor::Fill(int position) {
 	if (lenDoc == -1)

contrib/src/stc/scintilla/src/DocumentAccessor.h

@@ -24,7 +24,7 @@ protected:
 public:
 	DocumentAccessor(Document *pdoc_, PropSet &props_) : 
 		Accessor(), pdoc(pdoc_), props(props_), 
-		lenDoc(-1), validLen(0), chFlags(0), chWhile(0) {
+		lenDoc(-1), validLen(0), chFlags(0) {
 	}
 	~DocumentAccessor();
 	char StyleAt(int position);

contrib/src/stc/scintilla/src/Editor.h

@@ -31,15 +31,10 @@ public:
 	// Drawing is only performed for maxLineLength characters on each line.
 	enum {maxLineLength = 4000};
 	int numCharsInLine;
-	int xHighlightGuide;
+	char chars[maxLineLength];
-	bool highlightColumn;
+	char styles[maxLineLength];
-	int selStart;
+	char indicators[maxLineLength];
-	int selEnd;
+	int positions[maxLineLength];
-	int edgeColumn;
-	char chars[maxLineLength+1];
-	char styles[maxLineLength+1];
-	char indicators[maxLineLength+1];
-	int positions[maxLineLength+1];
 };
 
 class Editor : public DocWatcher {
@@ -59,8 +54,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	bool stylesValid;	
 	ViewStyle vs;
 	Palette palette;
-	int printMagnification;
-	int printColourMode;
 	
 	bool hideSelection;
 	bool inOverstrike;
@@ -76,8 +69,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	Surface pixmapLine;
 	Surface pixmapSelMargin;
 	Surface pixmapSelPattern;
-	Surface pixmapIndentGuide;
-	Surface pixmapIndentGuideHighlight;
 	// Intellimouse support - currently only implemented for Windows
 	unsigned int ucWheelScrollLines;
 	int cWheelDelta; //wheel delta from roll
@@ -107,8 +98,8 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	bool needUpdateUI;
 	Position braces[2];
 	int bracesMatchStyle;
-	int highlightGuideColumn;
 	
+	int edgeState;
 	int theEdge;
 
 	enum { notPainting, painting, paintAbandoned } paintState;
@@ -123,7 +114,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	enum { selStream, selRectangle, selRectangleFixed } selType;
 	int xStartSelect;
 	int xEndSelect;
-	bool primarySelection;
 	
 	int caretPolicy;
 	int caretSlop;
@@ -178,7 +168,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	void SetSelection(int currentPos_, int anchor_);
 	void SetSelection(int currentPos_);
 	void SetEmptySelection(int currentPos_);
-	int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
 	int MovePositionTo(int newPos, bool extend = false);
 	int MovePositionSoVisible(int pos, int moveDir);
 	void SetLastXChosen();
@@ -194,10 +183,10 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 
 	void PaintSelMargin(Surface *surface, PRectangle &rc);
         void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout &ll);
-	void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart, 
+	void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int xStart, 
 		PRectangle rcLine, LineLayout &ll);
 	void Paint(Surface *surfaceWindow, PRectangle rcArea);
-	long FormatRange(bool draw, RangeToFormat *pfr);
+	long FormatRange(bool draw, FORMATRANGE *pfr);
 
 	virtual void SetVerticalScrollPos() = 0;
 	virtual void SetHorizontalScrollPos() = 0;
@@ -210,7 +199,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	virtual void AddCharUTF(char *s, unsigned int len);
 	void ClearSelection();
 	void ClearAll();
-    	void ClearDocumentStyle();
 	void Cut();
 	void PasteRectangular(int pos, const char *ptr, int len);
 	virtual void Copy() = 0;
@@ -228,7 +216,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	virtual void NotifyParent(SCNotification scn) = 0;
 	virtual void NotifyStyleToNeeded(int endStyleNeeded);
 	void NotifyChar(char ch);
-	void NotifyMove(int position);
 	void NotifySavePoint(bool isSavePoint);
 	void NotifyModifyAttempt();
 	virtual void NotifyDoubleClick(Point pt, bool shift);
@@ -244,25 +231,24 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 
 	
 #ifdef MACRO_SUPPORT
-	void NotifyMacroRecord(unsigned int iMessage, unsigned long wParam, long lParam);
+	void NotifyMacroRecord(UINT iMessage, WPARAM wParam, LPARAM lParam);
 #endif
 
 	void PageMove(int direction, bool extend=false);
 	void ChangeCaseOfSelection(bool makeUpperCase);
 	void LineTranspose();
-    	virtual void CancelModes();
+	virtual int KeyCommand(UINT iMessage);
-	virtual int KeyCommand(unsigned int iMessage);
 	virtual int KeyDefault(int /* key */, int /*modifiers*/);
 	int KeyDown(int key, bool shift, bool ctrl, bool alt);
 
-	int GetWhitespaceVisible();
+	bool GetWhitespaceVisible();
-	void SetWhitespaceVisible(int view);
+	void SetWhitespaceVisible(bool view);
 
 	void Indent(bool forwards);
 
-	long FindText(unsigned int iMessage, unsigned long wParam, long lParam);
+	long FindText(UINT iMessage,WPARAM wParam,LPARAM lParam);
 	void SearchAnchor();
-	long SearchText(unsigned int iMessage, unsigned long wParam, long lParam);
+	long SearchText(UINT iMessage,WPARAM wParam,LPARAM lParam);
 	void GoToLine(int lineNo);
 
 	char *CopyRange(int start, int end);
@@ -296,11 +282,11 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	void ToggleContraction(int line);
 	void EnsureLineVisible(int line);
 
-	virtual long DefWndProc(unsigned int iMessage, unsigned long wParam, long lParam) = 0;
+	virtual LRESULT DefWndProc(UINT iMessage, WPARAM wParam, LPARAM lParam) = 0;
 	
 public:
 	// Public so scintilla_send_message can use it
-	virtual long WndProc(unsigned int iMessage, unsigned long wParam, long lParam);
+	virtual LRESULT WndProc(UINT iMessage, WPARAM wParam, LPARAM lParam);
 	// Public so scintilla_set_id can use it
 	int ctrlID;	
 };

contrib/src/stc/scintilla/src/KeyMap.cxx

@@ -28,7 +28,7 @@ void KeyMap::Clear() {
 	alloc = 0;
 }
 
-void KeyMap::AssignCmdKey(int key, int modifiers, unsigned int msg) {
+void KeyMap::AssignCmdKey(int key, int modifiers, UINT msg) {
 	if ((len+1) >= alloc) {
 		KeyToCommand *ktcNew = new KeyToCommand[alloc + 5];
 		if (!ktcNew)
@@ -51,7 +51,7 @@ void KeyMap::AssignCmdKey(int key, int modifiers, unsigned int msg) {
 	len++;
 }
 
-unsigned int KeyMap::Find(int key, int modifiers) {
+UINT KeyMap::Find(int key, int modifiers) {
 	for (int i=0; i < len; i++) {
 		if ((key == kmap[i].key) && (modifiers == kmap[i].modifiers)) {
 			return kmap[i].msg;
@@ -61,55 +61,53 @@ unsigned int KeyMap::Find(int key, int modifiers) {
 }
 
 KeyToCommand KeyMap::MapDefault[] = {
-    {SCK_DOWN,		SCI_NORM,	SCI_LINEDOWN},
+    {VK_DOWN,		SCI_NORM,	SCI_LINEDOWN},
-    {SCK_DOWN,		SCI_SHIFT,	SCI_LINEDOWNEXTEND},
+    {VK_DOWN,		SCI_SHIFT,	SCI_LINEDOWNEXTEND},
-    {SCK_DOWN,		SCI_CTRL,	SCI_LINESCROLLDOWN},
+    {VK_DOWN,		SCI_CTRL,	SCI_LINESCROLLDOWN},
-    {SCK_UP,			SCI_NORM,	SCI_LINEUP},
+    {VK_UP,			SCI_NORM,	SCI_LINEUP},
-    {SCK_UP,			SCI_SHIFT,	SCI_LINEUPEXTEND},
+    {VK_UP,			SCI_SHIFT,	SCI_LINEUPEXTEND},
-    {SCK_UP,			SCI_CTRL,	SCI_LINESCROLLUP},
+    {VK_UP,			SCI_CTRL,	SCI_LINESCROLLUP},
-    {SCK_LEFT,		SCI_NORM,	SCI_CHARLEFT},
+    {VK_LEFT,		SCI_NORM,	SCI_CHARLEFT},
-    {SCK_LEFT,		SCI_SHIFT,	SCI_CHARLEFTEXTEND},
+    {VK_LEFT,		SCI_SHIFT,	SCI_CHARLEFTEXTEND},
-    {SCK_LEFT,		SCI_CTRL,	SCI_WORDLEFT},
+    {VK_LEFT,		SCI_CTRL,	SCI_WORDLEFT},
-    {SCK_LEFT,		SCI_CSHIFT,	SCI_WORDLEFTEXTEND},
+    {VK_LEFT,		SCI_CSHIFT,	SCI_WORDLEFTEXTEND},
-    {SCK_RIGHT,		SCI_NORM,	SCI_CHARRIGHT},
+    {VK_RIGHT,		SCI_NORM,	SCI_CHARRIGHT},
-    {SCK_RIGHT,		SCI_SHIFT,	SCI_CHARRIGHTEXTEND},
+    {VK_RIGHT,		SCI_SHIFT,	SCI_CHARRIGHTEXTEND},
-    {SCK_RIGHT,		SCI_CTRL,	SCI_WORDRIGHT},
+    {VK_RIGHT,		SCI_CTRL,	SCI_WORDRIGHT},
-    {SCK_RIGHT,		SCI_CSHIFT,	SCI_WORDRIGHTEXTEND},
+    {VK_RIGHT,		SCI_CSHIFT,	SCI_WORDRIGHTEXTEND},
-    {SCK_HOME, 		SCI_NORM, 	SCI_VCHOME},
+    {VK_HOME, 		SCI_NORM, 	SCI_VCHOME},
-    {SCK_HOME, 		SCI_SHIFT, 	SCI_VCHOMEEXTEND},
+    {VK_HOME, 		SCI_SHIFT, 	SCI_VCHOMEEXTEND},
-    {SCK_HOME, 		SCI_CTRL, 	SCI_DOCUMENTSTART},
+    {VK_HOME, 		SCI_CTRL, 	SCI_DOCUMENTSTART},
-    {SCK_HOME, 		SCI_CSHIFT, 	SCI_DOCUMENTSTARTEXTEND},
+    {VK_HOME, 		SCI_CSHIFT, 	SCI_DOCUMENTSTARTEXTEND},
-    {SCK_END,	 	SCI_NORM, 	SCI_LINEEND},
+    {VK_END,	 	SCI_NORM, 	SCI_LINEEND},
-    {SCK_END,	 	SCI_SHIFT, 	SCI_LINEENDEXTEND},
+    {VK_END,	 	SCI_SHIFT, 	SCI_LINEENDEXTEND},
-    {SCK_END, 		SCI_CTRL, 	SCI_DOCUMENTEND},
+    {VK_END, 		SCI_CTRL, 	SCI_DOCUMENTEND},
-    {SCK_END, 		SCI_CSHIFT, 	SCI_DOCUMENTENDEXTEND},
+    {VK_END, 		SCI_CSHIFT, 	SCI_DOCUMENTENDEXTEND},
-    {SCK_PRIOR,		SCI_NORM, 	SCI_PAGEUP},
+    {VK_PRIOR,		SCI_NORM, 	SCI_PAGEUP},
-    {SCK_PRIOR,		SCI_SHIFT, 	SCI_PAGEUPEXTEND},
+    {VK_PRIOR,		SCI_SHIFT, 	SCI_PAGEUPEXTEND},
-    {SCK_NEXT, 		SCI_NORM, 	SCI_PAGEDOWN},
+    {VK_NEXT, 		SCI_NORM, 	SCI_PAGEDOWN},
-    {SCK_NEXT, 		SCI_SHIFT, 	SCI_PAGEDOWNEXTEND},
+    {VK_NEXT, 		SCI_SHIFT, 	SCI_PAGEDOWNEXTEND},
-    {SCK_DELETE, 	SCI_NORM,	SCI_CLEAR},
+    {VK_DELETE, 	SCI_NORM,	WM_CLEAR},
-    {SCK_DELETE, 	SCI_SHIFT,	SCI_CUT},
+    {VK_DELETE, 	SCI_SHIFT,	WM_CUT},
-    {SCK_DELETE, 	SCI_CTRL,	SCI_DELWORDRIGHT},
+    {VK_DELETE, 	SCI_CTRL,	SCI_DELWORDRIGHT},
-    {SCK_INSERT, 		SCI_NORM,	SCI_EDITTOGGLEOVERTYPE},
+    {VK_INSERT, 		SCI_NORM,	SCI_EDITTOGGLEOVERTYPE},
-    {SCK_INSERT, 		SCI_SHIFT,	SCI_PASTE},
+    {VK_INSERT, 		SCI_SHIFT,	WM_PASTE},
-    {SCK_INSERT, 		SCI_CTRL,	SCI_COPY},
+    {VK_INSERT, 		SCI_CTRL,	WM_COPY},
-    {SCK_ESCAPE,  	SCI_NORM,	SCI_CANCEL},
+    {VK_ESCAPE,  	SCI_NORM,	SCI_CANCEL},
-    {SCK_BACK,		SCI_NORM, 	SCI_DELETEBACK},
+    {VK_BACK,		SCI_NORM, 	SCI_DELETEBACK},
-    {SCK_BACK,		SCI_SHIFT, 	SCI_DELETEBACK},
+    {VK_BACK,		SCI_CTRL, 	SCI_DELWORDLEFT},
-    {SCK_BACK,		SCI_CTRL, 	SCI_DELWORDLEFT},
+    {'Z', 			SCI_CTRL,	WM_UNDO},
-    {SCK_BACK, 		SCI_ALT,	SCI_UNDO},
-    {'Z', 			SCI_CTRL,	SCI_UNDO},
     {'Y', 			SCI_CTRL,	SCI_REDO},
-    {'X', 			SCI_CTRL,	SCI_CUT},
+    {'X', 			SCI_CTRL,	WM_CUT},
-    {'C', 			SCI_CTRL,	SCI_COPY},
+    {'C', 			SCI_CTRL,	WM_COPY},
-    {'V', 			SCI_CTRL,	SCI_PASTE},
+    {'V', 			SCI_CTRL,	WM_PASTE},
     {'A', 			SCI_CTRL,	SCI_SELECTALL},
-    {SCK_TAB,		SCI_NORM,	SCI_TAB},
+    {VK_TAB,		SCI_NORM,	SCI_TAB},
-    {SCK_TAB,		SCI_SHIFT,	SCI_BACKTAB},
+    {VK_TAB,		SCI_SHIFT,	SCI_BACKTAB},
-    {SCK_RETURN, 	SCI_NORM,	SCI_NEWLINE},
+    {VK_RETURN, 	SCI_NORM,	SCI_NEWLINE},
-    {SCK_ADD, 		SCI_CTRL,	SCI_ZOOMIN},
+    {VK_ADD, 		SCI_CTRL,	SCI_ZOOMIN},
-    {SCK_SUBTRACT,	SCI_CTRL,	SCI_ZOOMOUT},
+    {VK_SUBTRACT,	SCI_CTRL,	SCI_ZOOMOUT},
-    {SCK_DIVIDE,	SCI_CTRL,	SCI_SETZOOM},
+    {VK_DIVIDE,	SCI_CTRL,	SCI_SETZOOM},
     //'L', 			SCI_CTRL,		SCI_FORMFEED,
     {'L', 			SCI_CTRL,	SCI_LINECUT},
     {'L', 			SCI_CSHIFT,	SCI_LINEDELETE},

contrib/src/stc/scintilla/src/KeyMap.h

@@ -7,9 +7,9 @@
 #define KEYTOCOMMAND_H
 
 #define SCI_NORM 0
-#define SCI_SHIFT SCMOD_SHIFT
+#define SCI_SHIFT SHIFT_PRESSED
-#define SCI_CTRL SCMOD_CTRL
+#define SCI_CTRL LEFT_CTRL_PRESSED
-#define SCI_ALT SCMOD_ALT
+#define SCI_ALT LEFT_ALT_PRESSED
 #define SCI_CSHIFT (SCI_CTRL | SCI_SHIFT)
 #define SCI_ASHIFT (SCI_ALT | SCI_SHIFT)
 
@@ -17,7 +17,7 @@ class KeyToCommand {
 public:
 	int key;
 	int modifiers;
-	unsigned int msg;
+	UINT msg;
 };
 
 class KeyMap {
@@ -29,8 +29,8 @@ public:
 	KeyMap();
 	~KeyMap();
 	void Clear();
-	void AssignCmdKey(int key, int modifiers, unsigned int msg);
+	void AssignCmdKey(int key, int modifiers, UINT msg);
-	unsigned int Find(int key, int modifiers);	// 0 returned on failure
+	UINT Find(int key, int modifiers);	// 0 returned on failure
 };
 
 #endif

contrib/src/stc/scintilla/src/LexCPP.cxx

@@ -19,13 +19,14 @@
 
 static bool classifyWordCpp(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
 	char s[100];
+	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
+	bool wordIsUUID = false;
 	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
 		s[i] = styler[start + i];
 		s[i + 1] = '\0';
 	}
-	bool wordIsUUID = false;
 	char chAttr = SCE_C_IDENTIFIER;
-	if (isdigit(s[0]) || (s[0] == '.'))
+	if (wordIsNumber)
 		chAttr = SCE_C_NUMBER;
 	else {
 		if (keywords.InList(s)) {
@@ -45,7 +46,6 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 	styler.StartAt(startPos);
 	
 	bool fold = styler.GetPropertyInt("fold");
-	bool stylingWithinPreprocessor = styler.GetPropertyInt("styling.within.preprocessor");
 	int lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
@@ -56,7 +56,7 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 	char chPrev = ' ';
 	char chNext = styler[startPos];
 	unsigned int lengthDoc = startPos + length;
-	int visibleChars = 0;
+	int visChars = 0;
 	styler.StartSegment(startPos);
 	bool lastWordWasUUID = false;
 	for (unsigned int i = startPos; i < lengthDoc; i++) {
@@ -64,8 +64,6 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 		chNext = styler.SafeGetCharAt(i + 1);
 
 		if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
-			// Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix)
-			// Avoid triggering two times on Dos/Win
 			// End of line
 			if (state == SCE_C_STRINGEOL) {
 				styler.ColourTo(i, state);
@@ -73,18 +71,18 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 			}
 			if (fold) {
 				int lev = levelPrev;
-				if (visibleChars == 0)
+				if (visChars == 0)
 					lev |= SC_FOLDLEVELWHITEFLAG;
-				if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				if ((levelCurrent > levelPrev) && (visChars > 0))
 					lev |= SC_FOLDLEVELHEADERFLAG;
 				styler.SetLevel(lineCurrent, lev);
 				lineCurrent++;
+				visChars = 0;
 				levelPrev = levelCurrent;
 			}
-			visibleChars = 0;
 		}
 		if (!isspace(ch))
-			visibleChars++;
+			visChars++;
 
 		if (styler.IsLeadByte(ch)) {
 			chNext = styler.SafeGetCharAt(i + 2);
@@ -94,19 +92,13 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 		}
 
 		if (state == SCE_C_DEFAULT) {
-			if (ch == '@' && chNext == '\"') {
+			if (iswordstart(ch)) {
-				styler.ColourTo(i-1, state);
-				state = SCE_C_VERBATIM;
-				i++;
-				ch = chNext;
-				chNext = styler.SafeGetCharAt(i + 1);
-			} else if (iswordstart(ch) || (ch == '@')) {
 				styler.ColourTo(i-1, state);
 				if (lastWordWasUUID) {
 					state = SCE_C_UUID;
 					lastWordWasUUID = false;
 				} else {
-					state = SCE_C_IDENTIFIER;
+					state = SCE_C_WORD;
 				}
 			} else if (ch == '/' && chNext == '*') {
 				styler.ColourTo(i-1, state);
@@ -123,16 +115,9 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 			} else if (ch == '\'') {
 				styler.ColourTo(i-1, state);
 				state = SCE_C_CHARACTER;
-			} else if (ch == '#' && visibleChars == 1) {
+			} else if (ch == '#') {
-				// Preprocessor commands are alone on their line
 				styler.ColourTo(i-1, state);
 				state = SCE_C_PREPROCESSOR;
-				// Skip whitespace between # and preprocessor word
-				do {
-					i++;
-					ch = chNext;
-					chNext = styler.SafeGetCharAt(i + 1);
-				} while (isspace(ch) && (i < lengthDoc));
 			} else if (isoperator(ch)) {
 				styler.ColourTo(i-1, state);
 				styler.ColourTo(i, SCE_C_OPERATOR);
@@ -140,7 +125,7 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 					levelCurrent += (ch == '{') ? 1 : -1;
 				}
 			}
-		} else if (state == SCE_C_IDENTIFIER) {
+		} else if (state == SCE_C_WORD) {
 			if (!iswordchar(ch)) {
 				lastWordWasUUID = classifyWordCpp(styler.GetStartSegment(), i - 1, keywords, styler);
 				state = SCE_C_DEFAULT;
@@ -155,6 +140,8 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 					state = SCE_C_STRING;
 				} else if (ch == '\'') {
 					state = SCE_C_CHARACTER;
+				} else if (ch == '#') {
+					state = SCE_C_PREPROCESSOR;
 				} else if (isoperator(ch)) {
 					styler.ColourTo(i, SCE_C_OPERATOR);
 					if ((ch == '{') || (ch == '}')) {
@@ -164,16 +151,9 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 			}
 		} else {
 			if (state == SCE_C_PREPROCESSOR) {
-				if (stylingWithinPreprocessor) {
+				if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) {
-					if (isspace(ch)) {
+					styler.ColourTo(i-1, state);
-						styler.ColourTo(i-1, state);
+					state = SCE_C_DEFAULT;
-						state = SCE_C_DEFAULT;
-					}
-				} else {
-					if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) {
-						styler.ColourTo(i-1, state);
-						state = SCE_C_DEFAULT;
-					}
 				}
 			} else if (state == SCE_C_COMMENT) {
 				if (ch == '/' && chPrev == '*') {
@@ -208,10 +188,13 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 				} else if (ch == '\"') {
 					styler.ColourTo(i, state);
 					state = SCE_C_DEFAULT;
-				} else if (chNext == '\r' || chNext == '\n') {
+					i++;
+					ch = chNext;
+					chNext = styler.SafeGetCharAt(i + 1);
+                } else if (chNext == '\r' || chNext == '\n') {
 					styler.ColourTo(i-1, SCE_C_STRINGEOL);
 					state = SCE_C_STRINGEOL;
-				}
+                }
 			} else if (state == SCE_C_CHARACTER) {
 				if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
 					styler.ColourTo(i-1, SCE_C_STRINGEOL);
@@ -225,26 +208,39 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 				} else if (ch == '\'') {
 					styler.ColourTo(i, state);
 					state = SCE_C_DEFAULT;
-				}
+					i++;
-			} else if (state == SCE_C_VERBATIM) {
+					ch = chNext;
-				if (ch == '\"') {
+					chNext = styler.SafeGetCharAt(i + 1);
-					if (chNext == '\"') {
-						i++;
-						ch = chNext;
-						chNext = styler.SafeGetCharAt(i + 1);
-					} else {
-						styler.ColourTo(i, state);
-						state = SCE_C_DEFAULT;
-					}
 				}
 			} else if (state == SCE_C_UUID) {
 				if (ch == '\r' || ch == '\n' || ch == ')') {
 					styler.ColourTo(i-1, state);
-					if (ch == ')')
-						styler.ColourTo(i, SCE_C_OPERATOR);
 					state = SCE_C_DEFAULT;
 				}
 			}
+			if (state == SCE_C_DEFAULT) {    // One of the above succeeded
+				if (ch == '/' && chNext == '*') {
+					if (styler.SafeGetCharAt(i + 2) == '*')
+						state = SCE_C_COMMENTDOC;
+					else
+						state = SCE_C_COMMENT;
+				} else if (ch == '/' && chNext == '/') {
+					state = SCE_C_COMMENTLINE;
+				} else if (ch == '\"') {
+					state = SCE_C_STRING;
+				} else if (ch == '\'') {
+					state = SCE_C_CHARACTER;
+				} else if (ch == '#') {
+					state = SCE_C_PREPROCESSOR;
+				} else if (iswordstart(ch)) {
+					state = SCE_C_WORD;
+				} else if (isoperator(ch)) {
+					styler.ColourTo(i, SCE_C_OPERATOR);
+					if ((ch == '{') || (ch == '}')) {
+						levelCurrent += (ch == '{') ? 1 : -1;
+					}
+				}
+			}
 		}
 		chPrev = ch;
 	}

contrib/src/stc/scintilla/src/LexLua.cxx

@@ -1,298 +0,0 @@
-// LexLua.cxx - lexer for Lua language
-// Written by Paul Winwood 
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <fcntl.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-static void classifyWordLua(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler)
-{
-    char s[100];
-    bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
-    
-    for (unsigned int i = 0; i < end - start + 1 && i < 30; i++)
-    {
-        s[i] = styler[start + i];
-        s[i + 1] = '\0';
-    }
-
-    char chAttr = SCE_LUA_IDENTIFIER;
-    
-    if (wordIsNumber)
-        chAttr = SCE_LUA_NUMBER;
-    else
-    {
-        if (keywords.InList(s))
-        {
-            chAttr = SCE_LUA_WORD;
-        }
-    }
-    styler.ColourTo(end, chAttr);
-}
-
-static void ColouriseLuaDoc(unsigned int startPos, 
-                            int          length, 
-                            int          initStyle, 
-                            WordList    *keywordlists[],
-                            Accessor    &styler)
-{
-
-    WordList &keywords = *keywordlists[0];
-
-    styler.StartAt(startPos);
-    styler.GetLine(startPos);
-
-    int  state = initStyle;
-    char chPrev = ' ';
-    char chNext = styler[startPos];
-    unsigned int lengthDoc = startPos + length;
-    bool firstChar = true;
-    int  literalString = 0;
-
-    styler.StartSegment(startPos);
-    for (unsigned int i = startPos; i <= lengthDoc; i++)
-    {
-        char ch = chNext;
-        chNext = styler.SafeGetCharAt(i + 1);
-
-        if (styler.IsLeadByte(ch))
-        {
-            chNext = styler.SafeGetCharAt(i + 2);
-            chPrev = ' ';
-            i += 1;
-            continue;
-        }
-
-        if (state == SCE_LUA_STRINGEOL)
-        {
-            if (ch != '\r' && ch != '\n')
-            {
-                styler.ColourTo(i-1, state);
-                state = SCE_LUA_DEFAULT;
-            }
-        }
-
-        if (state == SCE_LUA_LITERALSTRING && ch == '[' && chNext == '[')
-        {
-            literalString++;
-        }
-        else
-        if (state == SCE_LUA_DEFAULT)
-        {
-            if (ch == '-' && chNext == '-')
-            {
-                styler.ColourTo(i-1, state);
-                state = SCE_LUA_COMMENTLINE;
-            }
-            else
-            if (ch == '[' && chNext == '[')
-            {
-                state = SCE_LUA_LITERALSTRING;
-                literalString = 1;
-            }
-            else
-            if (iswordstart(ch))
-            {
-                styler.ColourTo(i-1, state);
-                state = SCE_LUA_WORD;
-            }
-            else
-            if (ch == '\"')
-            {
-                styler.ColourTo(i-1, state);
-                state = SCE_LUA_STRING;
-            }
-            else
-            if (ch == '\'')
-            {
-                styler.ColourTo(i-1, state);
-                state = SCE_LUA_CHARACTER;
-            }
-            else
-            if (ch == '$' && firstChar)
-            {
-                styler.ColourTo(i-1, state);
-                state = SCE_LUA_PREPROCESSOR;
-            }
-            else
-            if (isoperator(ch))
-            {
-                styler.ColourTo(i-1, state);
-                styler.ColourTo(i, SCE_LUA_OPERATOR);
-            }
-        }
-        else
-        if (state == SCE_LUA_WORD)
-        {
-            if (!iswordchar(ch))
-            {
-                classifyWordLua(styler.GetStartSegment(), i - 1, keywords, styler);
-                state = SCE_LUA_DEFAULT;
-                if (ch == '[' && chNext == '[')
-                {
-                    literalString = 1;
-                    state = SCE_LUA_LITERALSTRING;
-                }
-                else
-                if (ch == '-' && chNext == '-')
-                {
-                    state = SCE_LUA_COMMENTLINE;
-                }
-                else
-                if (ch == '\"')
-                {
-                    state = SCE_LUA_STRING;
-                }
-                else
-                if (ch == '\'')
-                {
-                    state = SCE_LUA_CHARACTER;
-                }
-                else
-                if (ch == '$' && firstChar)
-                {
-                    state = SCE_LUA_PREPROCESSOR;
-                }
-                else
-                if (isoperator(ch))
-                {
-                    styler.ColourTo(i, SCE_LUA_OPERATOR);
-                }
-            }
-        }
-        else
-        {
-            if (state == SCE_LUA_LITERALSTRING)
-            {
-                if (ch == ']' && (chPrev == ']') && (--literalString == 0))
-                {
-                    styler.ColourTo(i, state);
-                    state = SCE_LUA_DEFAULT;
-                }
-            }
-            else
-            if (state == SCE_LUA_PREPROCESSOR)
-            {
-                if ((ch == '\r' || ch == '\n') && (chPrev != '\\'))
-                {
-                    styler.ColourTo(i-1, state);
-                    state = SCE_LUA_DEFAULT;
-                }
-            }
-            else
-            if (state == SCE_LUA_COMMENTLINE)
-            {
-                if (ch == '\r' || ch == '\n')
-                {
-                    styler.ColourTo(i-1, state);
-                    state = SCE_LUA_DEFAULT;
-                }
-            }
-            else
-            if (state == SCE_LUA_STRING)
-            {
-                if ((ch == '\r' || ch == '\n') && (chPrev != '\\'))
-                {
-                    styler.ColourTo(i-1, state);
-                    state = SCE_LUA_STRINGEOL;
-                }
-                else
-                if (ch == '\\')
-                {
-                    if (chNext == '\"' || chNext == '\\')
-                    {
-                        i++;
-                        ch = chNext;
-                        chNext = styler.SafeGetCharAt(i + 1);
-                    }
-                }
-                else
-                if (ch == '\"')
-                {
-                    styler.ColourTo(i, state);
-                    state = SCE_LUA_DEFAULT;
-                    i++;
-                    ch = chNext;
-                    chNext = styler.SafeGetCharAt(i + 1);
-                }
-            }
-            else
-            if (state == SCE_LUA_CHARACTER)
-            {
-                if ((ch == '\r' || ch == '\n') && (chPrev != '\\'))
-                {
-                    styler.ColourTo(i-1, state);
-                    state = SCE_LUA_STRINGEOL;
-                }
-                else
-                if (ch == '\\')
-                {
-                    if (chNext == '\'' || chNext == '\\')
-                    {
-                        i++;
-                        ch = chNext;
-                        chNext = styler.SafeGetCharAt(i + 1);
-                    }
-                }
-                else
-                if (ch == '\'')
-                {
-                    styler.ColourTo(i, state);
-                    state = SCE_LUA_DEFAULT;
-                    i++;
-                    ch = chNext;
-                    chNext = styler.SafeGetCharAt(i + 1);
-                }
-            }
-
-            if (state == SCE_LUA_DEFAULT)
-            {    
-                if (ch == '-' && chNext == '-')
-                {
-                    state = SCE_LUA_COMMENTLINE;
-                }
-                else
-                if (ch == '\"')
-                {
-                    state = SCE_LUA_STRING;
-                }
-                else
-                if (ch == '\'')
-                {
-                    state = SCE_LUA_CHARACTER;
-                }
-                else
-                if (ch == '$' && firstChar)
-                {
-                    state = SCE_LUA_PREPROCESSOR;
-                }
-                else
-                if (iswordstart(ch))
-                {
-                    state = SCE_LUA_WORD;
-                }
-                else
-                if (isoperator(ch))
-                {
-                    styler.ColourTo(i, SCE_LUA_OPERATOR);
-                }
-            }
-        }
-        chPrev = ch;
-        firstChar = (ch == '\r' || ch == '\n');
-    }
-    styler.ColourTo(lengthDoc - 1, state);
-}
-
-LexerModule lmLua(SCLEX_LUA, ColouriseLuaDoc);

contrib/src/stc/scintilla/src/LexOthers.cxx

@@ -49,46 +49,6 @@ static void ColouriseBatchDoc(unsigned int startPos, int length, int, WordList *
 		ColouriseBatchLine(lineBuffer, startPos + length, styler);
 }
 
-static void ColouriseDiffLine(char *lineBuffer, int endLine, Accessor &styler) {
-	// It is needed to remember the current state to recognize starting
-	// comment lines before the first "diff " or "--- ". If a real
-	// difference starts then each line starting with ' ' is a whitespace
-	// otherwise it is considered a comment (Only in..., Binary file...)
-	if (0 == strncmp(lineBuffer, "diff ", 3)) {
-		styler.ColourTo(endLine, 2);
-	} else if (0 == strncmp(lineBuffer, "--- ", 3)) {
-		styler.ColourTo(endLine, 3);
-	} else if (0 == strncmp(lineBuffer, "+++ ", 3)) {
-		styler.ColourTo(endLine, 3);
-	} else if (lineBuffer[0] == '@') {
-		styler.ColourTo(endLine, 4);
-	} else if (lineBuffer[0] == '-') {
-		styler.ColourTo(endLine, 5);
-	} else if (lineBuffer[0] == '+') {
-		styler.ColourTo(endLine, 6);
-	} else if (lineBuffer[0] != ' ') {
-		styler.ColourTo(endLine, 1);
-	} else {
-		styler.ColourTo(endLine, 0);
-	}
-}
-
-static void ColouriseDiffDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	char lineBuffer[1024];
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (styler[i] == '\r' || styler[i] == '\n' || (linePos >= sizeof(lineBuffer) - 1)) {
-			ColouriseDiffLine(lineBuffer, i, styler);
-			linePos = 0;
-		}
-	}
-	if (linePos > 0)
-		ColouriseDiffLine(lineBuffer, startPos + length, styler);
-}
-
 static void ColourisePropsLine(char *lineBuffer, int lengthLine, int startLine, int endPos, Accessor &styler) {
 	int i = 0;
 	while (isspace(lineBuffer[i]) && (i < lengthLine))	// Skip initial spaces
@@ -166,21 +126,15 @@ static void ColouriseMakeDoc(unsigned int startPos, int length, int, WordList *[
 static void ColouriseErrorListLine(char *lineBuffer, int lengthLine, int endPos, Accessor &styler) {
 	if (lineBuffer[0] == '>') {
 		// Command or return status
-		styler.ColourTo(endPos, SCE_ERR_CMD);
+		styler.ColourTo(endPos, 4);
 	} else if (strstr(lineBuffer, "File \"") && strstr(lineBuffer, ", line ")) {
-		styler.ColourTo(endPos, SCE_ERR_PYTHON);
+		styler.ColourTo(endPos, 1);
 	} else if (0 == strncmp(lineBuffer, "Error ", strlen("Error "))) {
 		// Borland error message
-		styler.ColourTo(endPos, SCE_ERR_BORLAND);
+		styler.ColourTo(endPos, 5);
 	} else if (0 == strncmp(lineBuffer, "Warning ", strlen("Warning "))) {
 		// Borland warning message
-		styler.ColourTo(endPos, SCE_ERR_BORLAND);
+		styler.ColourTo(endPos, 5);
-	} else if (strstr(lineBuffer, " at "  ) && 
-		strstr(lineBuffer, " at "  ) < lineBuffer+lengthLine && 
-		strstr(lineBuffer, " line ") && 
-		strstr(lineBuffer, " line ") < lineBuffer+lengthLine) {
-		// perl error message
-		styler.ColourTo(endPos, SCE_ERR_PERL);
 	} else {
 		// Look for <filename>:<line>:message
 		// Look for <filename>(line)message
@@ -214,11 +168,11 @@ static void ColouriseErrorListLine(char *lineBuffer, int lengthLine, int endPos,
 			}
 		}
 		if (state == 3) {
-			styler.ColourTo(endPos, SCE_ERR_GCC);
+			styler.ColourTo(endPos, 2);
 		} else if ((state == 13) || (state == 14) || (state == 15)) {
-			styler.ColourTo(endPos, SCE_ERR_MS);
+			styler.ColourTo(endPos, 3);
 		} else {
-			styler.ColourTo(endPos, SCE_ERR_DEFAULT);
+			styler.ColourTo(endPos, 0);
 		}
 	}
 }
@@ -343,9 +297,8 @@ static void ColouriseLatexDoc(unsigned int startPos, int length, int initStyle,
 	styler.ColourTo(lengthDoc, state);
 }
 
-LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc);
-LexerModule lmDiff(SCLEX_DIFF, ColouriseDiffDoc);
 LexerModule lmProps(SCLEX_PROPERTIES, ColourisePropsDoc);
-LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc);
 LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc);
+LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc);
+LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc);
 LexerModule lmLatex(SCLEX_LATEX, ColouriseLatexDoc);

contrib/src/stc/scintilla/src/LexPerl.cxx

@@ -107,7 +107,7 @@ static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
 		state = SCE_PL_DEFAULT;
 	}
 	styler.StartAt(startPos);
-	char chPrev = styler.SafeGetCharAt(startPos - 1);
+	char chPrev = ' ';
 	char chNext = styler[startPos];
 	styler.StartSegment(startPos);
 	for (int i = startPos; i < lengthDoc; i++) {
@@ -230,7 +230,7 @@ static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
 				quotes = 0;
 				sookedpos = 0;
 				sooked[sookedpos] = '\0';
-			} else if (ch == '=' && (chPrev == '\r' || chPrev == '\n') && isalpha(chNext)) {
+			} else if (ch == '=' && isalpha(chNext)) {
 				styler.ColourTo(i - 1, state);
 				state = SCE_PL_POD;
 				quotes = 0;
@@ -284,7 +284,7 @@ static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
 					state = SCE_PL_DEFAULT;
 				}
 			} else if (state == SCE_PL_HERE) {
-				if ((isalnum(ch) || ch == '_') && quotes < 2) {
+				if (isalnum(ch) && quotes < 2) {
 					sooked[sookedpos++] = ch;
 					sooked[sookedpos] = '\0';
 					if (quotes == 0)
@@ -292,17 +292,14 @@ static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
 				} else {
 					quotes++;
 				}
-				if ((quotes > 1) && 
+				if (quotes > 1 && isMatch(styler, lengthDoc, i, sooked) && (chPrev == '\n' || chPrev == '\r') ) {
-					(chPrev == '\n' || chPrev == '\r') &&
+					styler.ColourTo(i + sookedpos - 1, SCE_PL_HERE);
-					isMatch(styler, lengthDoc, i, sooked)) {
 					i += sookedpos;
 					chNext = styler.SafeGetCharAt(i);
 					if (chNext == '\n' || chNext == '\r') {
-						styler.ColourTo(i - 1, SCE_PL_HERE);
 						state = SCE_PL_DEFAULT;
 					}
-					ch = chNext;
+					chNext = ' ';
-					chNext = styler.SafeGetCharAt(i + 1);
 				}
 			} else if (state == SCE_PL_STRING) {
 				if (ch == '\\') {
@@ -341,13 +338,13 @@ static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
 					chNext = styler.SafeGetCharAt(i + 1);
 				}
 			} else if (state == SCE_PL_POD) {
-				if (ch == '=' && (chPrev == '\r' || chPrev == '\n')) {
+				if (ch == '=') {
 					if (isMatch(styler, lengthDoc, i, "=cut")) {
 						styler.ColourTo(i - 1 + 4, state);
 						i += 4;
 						state = SCE_PL_DEFAULT;
-						ch = styler.SafeGetCharAt(i);
+						chNext = ' ';
-						chNext = styler.SafeGetCharAt(i + 1);
+						ch = ' ';
 					}
 				}
 			} else if (state == SCE_PL_SCALAR) {
@@ -412,32 +409,7 @@ static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
 					quoteDown = opposite(ch);
 					quotes++;
 				} else {
-					if (quotes == 0 && quoteRep == 1) {
+					if (ch == quoteDown && chPrev != '\\') {
-						/* We matched something like s(...) or tr{...}
-						* and are looking for the next matcher characters,
-						* which could be either bracketed ({...}) or non-bracketed
-						* (/.../).
-						*
-						* Number-signs are problematic.  If they occur after
-						* the close of the first part, treat them like
-						* a quoteUp char, even if they actually start comments.
-						*
-						* If we find an alnum, we end the regsubst, and punt.
-						*
-						* Eric Promislow   ericp@activestate.com  Aug 9,2000
-						*/
-						if (isspace(ch)) {
-							// Keep going
-						} else if (isalnum(ch)) {
-							styler.ColourTo(i, state);
-							state = SCE_PL_DEFAULT;
-							ch = ' ';
-						} else {
-							quoteUp = ch;
-							quoteDown = opposite(ch);
-							quotes++;
-						}
-					} else if (ch == quoteDown && chPrev != '\\') {
 						quotes--;
 						if (quotes == 0) {
 							quoteRep--;

contrib/src/stc/scintilla/src/LexPython.cxx

@@ -33,13 +33,6 @@ static void ClassifyWordPy(unsigned int start, unsigned int end, WordList &keywo
 		chAttr = SCE_P_NUMBER;
 	else if (keywords.InList(s))
 		chAttr = SCE_P_WORD;
-	// make sure that dot-qualifiers inside the word are lexed correct
-	else for (unsigned int i = 0; i < end - start + 1; i++) {
-		if (styler[start + i] == '.') {
-			styler.ColourTo(start + i - 1, chAttr);
-			styler.ColourTo(start + i, SCE_P_OPERATOR);
-		}
-	}
 	styler.ColourTo(end, chAttr);
 	strcpy(prevWord, s);
 }

contrib/src/stc/scintilla/src/LexVB.cxx

@@ -20,21 +20,20 @@
 static int classifyWordVB(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
 
 	char s[100];
-	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.') ||
+	bool wordIsNumber = isdigit(styler[start]) || (styler[start] == '.');
-		(styler[start] == '&' && tolower(styler[start+1]) == 'h');
+	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
-	unsigned int i;
-	for (i = 0; i < end - start + 1 && i < 30; i++) {
 		s[i] = static_cast<char>(tolower(styler[start + i]));
+		s[i + 1] = '\0';
 	}
-	s[i] = '\0';
 	char chAttr = SCE_C_DEFAULT;
 	if (wordIsNumber)
 		chAttr = SCE_C_NUMBER;
 	else {
-		if (strcmp(s, "rem") == 0)
+		if (keywords.InList(s)) {
-			chAttr = SCE_C_COMMENTLINE;
-		else if (keywords.InList(s))
 			chAttr = SCE_C_WORD;
+			if (strcmp(s, "rem") == 0)
+				chAttr = SCE_C_COMMENTLINE;
+		}
 	}
 	styler.ColourTo(end, chAttr);
 	if (chAttr == SCE_C_COMMENTLINE)
@@ -50,7 +49,6 @@ static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
 	
 	styler.StartAt(startPos);
 
-	int visibleChars = 0;
 	int state = initStyle;
 	char chNext = styler[startPos];
 	styler.StartSegment(startPos);
@@ -65,17 +63,6 @@ static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
 			continue;
 		}
 
-		if (ch == '\r' || ch == '\n') {
-			// End of line
-			if (state == SCE_C_COMMENTLINE || state == SCE_C_PREPROCESSOR) {
-				styler.ColourTo(i - 1, state);
-				state = SCE_C_DEFAULT;
-			}
-			visibleChars = 0;
-		}
-		if (!isspace(ch))
-			visibleChars++;
-
 		if (state == SCE_C_DEFAULT) {
 			if (iswordstart(ch)) {
 				styler.ColourTo(i - 1, state);
@@ -86,16 +73,6 @@ static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
 			} else if (ch == '\"') {
 				styler.ColourTo(i - 1, state);
 				state = SCE_C_STRING;
-			} else if (ch == '#' && visibleChars == 1) {
-				// Preprocessor commands are alone on their line
-				styler.ColourTo(i - 1, state);
-				state = SCE_C_PREPROCESSOR;
-			} else if (ch == '&' && tolower(chNext) == 'h') {
-				styler.ColourTo(i - 1, state);
-				state = SCE_C_WORD;
-			} else if (isoperator(ch)) {
-				styler.ColourTo(i - 1, state);
-				styler.ColourTo(i, SCE_C_OPERATOR);
 			}
 		} else if (state == SCE_C_WORD) {
 			if (!iswordchar(ch)) {
@@ -105,14 +82,16 @@ static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
 						state = SCE_C_COMMENTLINE;
 					} else if (ch == '\"') {
 						state = SCE_C_STRING;
-					} else if (isoperator(ch)) {
-						styler.ColourTo(i - 1, state);
-						styler.ColourTo(i, SCE_C_OPERATOR);
 					}
 				}
 			}
 		} else {
-			if (state == SCE_C_STRING) {
+			if (state == SCE_C_COMMENTLINE) {
+				if (ch == '\r' || ch == '\n') {
+					styler.ColourTo(i - 1, state);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_STRING) {
 				// VB doubles quotes to preserve them
 				if (ch == '\"') {
 					styler.ColourTo(i, state);

contrib/src/stc/scintilla/src/PropSet.cxx

@@ -24,18 +24,6 @@ bool EqualCaseInsensitive(const char *a, const char *b) {
 #endif
 }
 
-SString::size_type SString::npos = -1;
-
-inline unsigned int HashString(const char *s) {
-    unsigned int ret = 0;
-    while (*s) {
-        ret <<= 4;
-        ret ^= *s;
-        s++;
-    }
-    return ret;
-}
-
 // Get a line of input. If end of line escaped with '\\' then continue reading.
 static bool GetFullLine(const char *&fpc, int &lenData, char *s, int len) {
 	bool continuation = true;
@@ -68,39 +56,47 @@ static bool GetFullLine(const char *&fpc, int &lenData, char *s, int len) {
 
 PropSet::PropSet() {
 	superPS = 0;
-    for (int root=0; root < hashRoots; root++)
+	size = 10;
-        props[root] = 0;
+	used = 0;
+	vals = new char * [size];
 }
 
 PropSet::~PropSet() {
 	superPS = 0;
 	Clear();
+	delete []vals;
+}
+
+void PropSet::EnsureCanAddEntry() {
+	if (used >= size - 2) {
+		int newsize = size + 10;
+		char **newvals = new char * [newsize];
+
+		for (int i = 0; i < used; i++) {
+			newvals[i] = vals[i];
+		}
+		delete []vals;
+		vals = newvals;
+		size = newsize;
+	}
 }
 
 void PropSet::Set(const char *key, const char *val) {
-    unsigned int hash = HashString(key);
+	EnsureCanAddEntry();
-	for (Property *p=props[hash % hashRoots]; p; p=p->next) {
+	for (int i = 0; i < used; i += 2) {
-		if ((hash == p->hash) && (0 == strcmp(p->key, key))) {
+		if (EqualCaseInsensitive(vals[i], key)) {
 			// Replace current value
-			delete [](p->val);
+			delete [](vals[i + 1]);
-			p->val = StringDup(val);
+			vals[i + 1] = StringDup(val);
 			return;
 		}
 	}
 	// Not found
-    Property *pNew = new Property;
+	vals[used++] = StringDup(key);
-    if (pNew) {
+	vals[used++] = StringDup(val);
-        pNew->hash = HashString(key);
-	    pNew->key = StringDup(key);
-	    pNew->val = StringDup(val);
-	    pNew->next = props[hash % hashRoots];
-        props[hash % hashRoots] = pNew;
-    }
 }
 
 void PropSet::Set(char *keyval) {
-    while (isspace(*keyval))
-        keyval++;
 	char *eqat = strchr(keyval, '=');
 	if (eqat) {
 		*eqat = '\0';
@@ -110,12 +106,11 @@ void PropSet::Set(char *keyval) {
 }
 
 SString PropSet::Get(const char *key) {
-    unsigned int hash = HashString(key);
+	for (int i = 0; i < used; i += 2) {
-	for (Property *p=props[hash % hashRoots]; p; p=p->next) {
+		if (EqualCaseInsensitive(vals[i], key)) {
-		if ((hash == p->hash) && (0 == strcmp(p->key, key))) {
+			return vals[i + 1];
-            return p->val;
+		}
-        }
+	}
-    }
 	if (superPS) {
 		// Failed here, so try in base property set
 		return superPS->Get(key);
@@ -124,36 +119,6 @@ SString PropSet::Get(const char *key) {
 	}
 }
 
-SString PropSet::GetExpanded(const char *key) {
-    SString val = Get(key);
-    return Expand(val.c_str());
-}
-
-SString PropSet::Expand(const char *withvars) {
-	char *base = StringDup(withvars);
-	char *cpvar = strstr(base, "$(");
-	while (cpvar) {
-		char *cpendvar = strchr(cpvar, ')');
-		if (cpendvar) {
-			int lenvar = cpendvar - cpvar - 2;  	// Subtract the $()
-			char *var = StringDup(cpvar+2, lenvar);
-			SString val = GetExpanded(var);
-			int newlenbase = strlen(base) + val.length() - lenvar;
-			char *newbase = new char[newlenbase];
-			strncpy(newbase, base, cpvar - base);
-			strcpy(newbase + (cpvar - base), val.c_str());
-			strcpy(newbase + (cpvar - base) + val.length(), cpendvar + 1);
-			delete []var;
-			delete []base;
-			base = newbase;
-		}
-		cpvar = strstr(base, "$(");
-	}
-	SString sret = base;
-	delete []base;
-	return sret;
-}
-
 int PropSet::GetInt(const char *key, int defaultValue) {
 	SString val = Get(key);
 	if (val.length())
@@ -162,9 +127,9 @@ int PropSet::GetInt(const char *key, int defaultValue) {
 		return defaultValue;
 }
 
-inline bool isprefix(const char *target, const char *prefix) {
+bool isprefix(const char *target, const char *prefix) {
 	while (*target && *prefix) {
-		if (*target != *prefix)
+		if (toupper(*target) != toupper(*prefix))
 			return false;
 		target++;
 		prefix++;
@@ -181,63 +146,64 @@ bool issuffix(const char *target, const char *suffix) {
 	if (lensuffix > lentarget)
 		return false;
 	for (int i = lensuffix - 1; i >= 0; i--) {
-		if (target[i + lentarget - lensuffix] != suffix[i])
+		if (toupper(target[i + lentarget - lensuffix]) != toupper(suffix[i]))
 			return false;
 	}
 	return true;
 }
 
 SString PropSet::GetWild(const char *keybase, const char *filename) {
-    for (int root=0; root < hashRoots; root++) {
+	for (int i = 0; i < used; i += 2) {
-	    for (Property *p=props[root]; p; p=p->next) {
+		if (isprefix(vals[i], keybase)) {
-		    if (isprefix(p->key, keybase)) {
+			char *orgkeyfile = vals[i] + strlen(keybase);
-			    char *orgkeyfile = p->key + strlen(keybase);
+			char *keyfile = NULL;
-			    char *keyfile = NULL;
 
-			    if (strstr(orgkeyfile, "$(") == orgkeyfile) {
+			if (strstr(orgkeyfile, "$(") == orgkeyfile) {
-				    char *cpendvar = strchr(orgkeyfile, ')');
+				char *cpendvar = strchr(orgkeyfile, ')');
-				    if (cpendvar) {
+				if (cpendvar) {
-					    *cpendvar = '\0';
+					int lenvar = cpendvar - orgkeyfile - 2; 	// Subtract the $()
-					    SString s = Get(orgkeyfile + 2);
+					char *var = static_cast<char *>(malloc(lenvar + 1));
-					    *cpendvar= ')';
+					strncpy(var, orgkeyfile + 2, lenvar);
-					    keyfile = strdup(s.c_str());
+					var[lenvar] = '\0';
-				    }
+					SString s = Get(var);
-			    }
+					free(var);
-			    char *keyptr = keyfile;
+					keyfile = strdup(s.c_str());
+				}
+			}
+			char *keyptr = keyfile;
 
-			    if (keyfile == NULL)
+			if (keyfile == NULL)
-				    keyfile = orgkeyfile;
+				keyfile = orgkeyfile;
 
-			    for (; ; ) {
+			for (; ; ) {
-				    char *del = strchr(keyfile, ';');
+				char *del = strchr(keyfile, ';');
-				    if (del == NULL)
+				if (del == NULL)
-					    del = keyfile + strlen(keyfile);
+					del = keyfile + strlen(keyfile);
-				    char delchr = *del;
+				char delchr = *del;
-				    *del = '\0';
+				*del = '\0';
-				    if (*keyfile == '*') {
+				if (*keyfile == '*') {
-					    if (issuffix(filename, keyfile + 1)) {
+					if (issuffix(filename, keyfile + 1)) {
-						    *del = delchr;
+						*del = delchr;
-						    free(keyptr);
+						free(keyptr);
-						    return p->val;
+						return vals[i + 1];
-					    }
+					}
-				    } else if (0 == strcmp(keyfile, filename)) {
+				} else if (EqualCaseInsensitive(keyfile, filename)) {
-					    *del = delchr;
+					*del = delchr;
-					    free(keyptr);
+					free(keyptr);
-					    return p->val;
+					return vals[i + 1];
-				    }
+				}
-				    if (delchr == '\0')
+				if (delchr == '\0')
-					    break;
+					break;
-				    *del = delchr;
+				*del = delchr;
-				    keyfile = del + 1;
+				keyfile = del + 1;
-			    }
+			}
-			    free(keyptr);
+			free(keyptr);
 
-			    if (0 == strcmp(p->key, keybase)) {
+			if (EqualCaseInsensitive(vals[i], keybase)) {
-				    return p->val;
+				return vals[i + 1];
-			    }
+			}
-		    }
+		}
-	    }
+	}
-    }
 	if (superPS) {
 		// Failed here, so try in base property set
 		return superPS->GetWild(keybase, filename);
@@ -253,7 +219,9 @@ SString PropSet::GetNewExpand(const char *keybase, const char *filename) {
 		char *cpendvar = strchr(cpvar, ')');
 		if (cpendvar) {
 			int lenvar = cpendvar - cpvar - 2;  	// Subtract the $()
-			char *var = StringDup(cpvar+2, lenvar);
+			char *var = new char[lenvar + 1];
+			strncpy(var, cpvar + 2, lenvar);
+			var[lenvar] = '\0';
 			SString val = GetWild(var, filename);
 			int newlenbase = strlen(base) + val.length() - lenvar;
 			char *newbase = new char[newlenbase];
@@ -272,54 +240,36 @@ SString PropSet::GetNewExpand(const char *keybase, const char *filename) {
 }
 
 void PropSet::Clear() {
-    for (int root=0; root < hashRoots; root++) {
+	for (int i = 0; i < used; i++) {
-        Property *p=props[root];
+		delete [](vals[i]);
-	    while (p) {
+		vals[i] = 0;
-            Property *pNext=p->next;
+	}
-		    p->hash = 0;
+	used = 0;
-		    delete p->key;
-		    p->key = 0;
-		    delete p->val;
-		    p->val = 0;
-            delete p;
-            p = pNext;
-        }
-        props[root] = 0;
-    }
 }
 
-void PropSet::ReadFromMemory(const char *data, int len, const char *directoryForImports) {
+void PropSet::ReadFromMemory(const char *data, int len) {
-	const char *pd = data;
+	if (len > 0) {
-	char linebuf[60000];
+		const char *pd = data;
-	bool ifIsTrue = true;
+		char linebuf[60000];
-	while (len > 0) {
+		while (GetFullLine(pd, len, linebuf, sizeof(linebuf))) {
-		GetFullLine(pd, len, linebuf, sizeof(linebuf));
+			if (isalpha(linebuf[0]))
-		if (isalpha(linebuf[0]))    // If clause ends with first non-indented line
+				Set(linebuf);
-			ifIsTrue = true;
-		if (isprefix(linebuf, "if ")) {
-			const char *expr = linebuf + strlen("if") + 1;
-			ifIsTrue = GetInt(expr);
-		} else if (isprefix(linebuf, "import ") && directoryForImports) {
-			char importPath[1024];
-			strcpy(importPath, directoryForImports);
-			strcat(importPath, linebuf + strlen("import") + 1);
-			strcat(importPath, ".properties");
-            		Read(importPath,directoryForImports);
-		} else if (isalpha(linebuf[0])) {
-			Set(linebuf);
-		} else if (isspace(linebuf[0]) && ifIsTrue) {
-			Set(linebuf);
 		}
+		// If there is a final line:
+		if (isalpha(linebuf[0]))
+			Set(linebuf);
 	}
 }
 
-void PropSet::Read(const char *filename, const char *directoryForImports) {
+void PropSet::Read(const char *filename) {
+	//printf("Opening properties <%s>\n", filename);
+	Clear();
 	char propsData[60000];
 	FILE *rcfile = fopen(filename, "rb");
 	if (rcfile) {
 		int lenFile = fread(propsData, 1, sizeof(propsData), rcfile);
 		fclose(rcfile);
-		ReadFromMemory(propsData, lenFile, directoryForImports);
+		ReadFromMemory(propsData, lenFile);
 	} else {
 		//printf("Could not open <%s>\n", filename);
 	}
@@ -335,8 +285,7 @@ static bool iswordsep(char ch, bool onlyLineEnds) {
 
 // Creates an array that points into each word in the string and puts \0 terminators
 // after each word.
-static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = false) {
+static char **ArrayFromWordList(char *wordlist, bool onlyLineEnds = false) {
-#if 1
 	char prev = '\n';
 	int words = 0;
 	for (int j = 0; wordlist[j]; j++) {
@@ -348,8 +297,8 @@ static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = fa
 	if (keywords) {
 		words = 0;
 		prev = '\0';
-		int slen = strlen(wordlist);
+		int len = strlen(wordlist);
-		for (int k = 0; k < slen; k++) {
+		for (int k = 0; k < len; k++) {
 			if (!iswordsep(wordlist[k], onlyLineEnds)) {
 				if (!prev) {
 					keywords[words] = &wordlist[k];
@@ -360,69 +309,25 @@ static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = fa
 			}
 			prev = wordlist[k];
 		}
-		keywords[words] = &wordlist[slen];
+		keywords[words] = &wordlist[len];
-		*len = words;
-	} else {
-		*len = 0;
 	}
-#else
-	int words = 0; // length of the returned buffer of pointers
-	#undef APICHUNK // how many pointers will be pre-allocated (to avoid buffer reallocation on each new pointer)
-	#define APICHUNK 256
-	int size = APICHUNK; // real size of the returned buffer of pointers
-	char **keywords; // buffer for the pointers returned
-	int slen = strlen(wordlist); //length of the buffer with api file
-	keywords = (char**) malloc((size + 1) * sizeof (*keywords));
-	words = 0;
-	for (int k = 0;;) {
-		while (iswordsep(wordlist[k], onlyLineEnds))
-			wordlist[k++] = '\0';
-		if (k >= slen)
-			break;
-		if (words >= size) {
-			do
-				size += APICHUNK;
-			while (size <= words);
-			keywords = (char**) realloc(keywords, (size + 1) * sizeof (*keywords));
-		}
-		keywords[words++] = wordlist + k;
-		do
-			if (k < slen)
-				k++;
-			else
-				goto out;
-		while (!iswordsep(wordlist[k], onlyLineEnds));
-	}
-out:
-	keywords[words] = wordlist + slen;
-	*len = words;
-#endif
 	return keywords;
 }
 
 void WordList::Clear() {
 	if (words) {
+		delete []words;
 		delete []list;
-#if 1
-        delete []words;
-#else
-		free(words);
-#endif
-		free(wordsNoCase);
 	}
 	words = 0;
-	wordsNoCase = 0;
 	list = 0;
 	len = 0;
-	sorted = false;
 }
 
 void WordList::Set(const char *s) {
+	len = 0;
 	list = StringDup(s);
-	sorted = false;
+	words = ArrayFromWordList(list, onlyLineEnds);
-	words = ArrayFromWordList(list, &len, onlyLineEnds);
-	wordsNoCase = (char**) malloc ((len + 1) * sizeof (*wordsNoCase));
-	memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
 }
 
 char *WordList::Allocate(int size) {
@@ -432,35 +337,45 @@ char *WordList::Allocate(int size) {
 }
 
 void WordList::SetFromAllocated() {
-	sorted = false;
+	len = 0;
-	words = ArrayFromWordList(list, &len, onlyLineEnds);
+	words = ArrayFromWordList(list, onlyLineEnds);
-	wordsNoCase = (char**) malloc ((len + 1) * sizeof (*wordsNoCase));
-	memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
 }
 
-int cmpString(const void *a1, const void *a2) {
+// Shell sort based upon public domain C implementation by Raymond Gardner 1991
-    // Can't work out the correct incantation to use modern casts here
+// Used here because of problems with mingw qsort.
-    return strcmp(*(char**)(a1), *(char**)(a2));
+static void SortWordList(char **words, unsigned int len) {
-}
+	unsigned int gap = len / 2;
 
-int cmpStringNoCase(const void *a1, const void *a2) {
+	while (gap > 0) {
-    // Can't work out the correct incantation to use modern casts here
+		unsigned int i = gap;
-    return strcasecmp(*(char**)(a1), *(char**)(a2));
+		while (i < len) {
-}
+			unsigned int j = i;
-
+			char **a = words + j;
-static void SortWordList(char **words, char **wordsNoCase, unsigned int len) {
+			do {
-	qsort(reinterpret_cast<void*>(words), len, sizeof(*words),
+				j -= gap;
-		cmpString);
+				char **b = a;
-	qsort(reinterpret_cast<void*>(wordsNoCase), len, sizeof(*wordsNoCase),
+				a -= gap;
-		cmpStringNoCase);
+				if (strcmp(*a, *b) > 0) {
+					char *tmp = *a;
+					*a = *b;
+					*b = tmp;
+				} else {
+					break;
+				}
+			} while (j >= gap);
+			i++;
+		}
+		gap = gap / 2;
+	}
 }
 
 bool WordList::InList(const char *s) {
 	if (0 == words)
 		return false;
-	if (!sorted) {
+	if (len == 0) {
-		sorted = true;
+		for (int i = 0; words[i][0]; i++)
-		SortWordList(words, wordsNoCase, len);
+			len++;
+		SortWordList(words, len);
 		for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
 			starts[k] = -1;
 		for (int l = len - 1; l >= 0; l--) {
@@ -487,256 +402,3 @@ bool WordList::InList(const char *s) {
 	}
 	return false;
 }
-
-/**
- * Returns an element (complete) of the wordlist array which has the beginning
- * the same as the passed string. The length of the word to compare is passed
- * too. Letter case can be ignored or preserved (default).
- */
-const char *WordList::GetNearestWord(const char *wordStart, int searchLen /*= -1*/, bool ignoreCase /*= false*/) {
-	int start = 0; // lower bound of the api array block to search
-	int end = len - 1; // upper bound of the api array block to search
-	int pivot; // index of api array element just being compared
-	int cond; // comparison result (in the sense of strcmp() result)
-	const char *word; // api array element just being compared
-
-	if (0 == words)
-		return NULL;
-	if (!sorted) {
-		sorted = true;
-		SortWordList(words, wordsNoCase, len);
-	}
-	if (ignoreCase)
-		while (start <= end) { // binary searching loop
-			pivot = (start + end) >> 1;
-			word = wordsNoCase[pivot];
-			cond = strncasecmp(wordStart, word, searchLen);
-			if (!cond && nonFuncChar(word[searchLen])) // maybe there should be a "non-word character" test here?
-				return word; // result must not be freed with free()
-			else if (cond < 0)
-				end = pivot - 1;
-			else if (cond > 0)
-				start = pivot + 1;
-		}
-	else // preserve the letter case
-		while (start <= end) { // binary searching loop
-			pivot = (start + end) >> 1;
-			word = words[pivot];
-			cond = strncmp(wordStart, word, searchLen);
-			if (!cond && nonFuncChar(word[searchLen])) // maybe there should be a "non-word character" test here?
-				return word; // result must not be freed with free()
-			else if (cond >= 0)
-				start = pivot + 1;
-			else if (cond < 0)
-				end = pivot - 1;
-		}
-	return NULL;
-}
-	
-/**
- * Returns elements (first words of them) of the wordlist array which have
- * the beginning the same as the passed string. The length of the word to
- * compare is passed too. Letter case can be ignored or preserved (default).
- * If there are more words meeting the condition they are returned all of
- * them in the ascending order separated with spaces.
- *
- * NOTE: returned buffer has to be freed with a free() call.
- */
-char *WordList::GetNearestWords(const char *wordStart, int searchLen /*= -1*/, bool ignoreCase /*= false*/) {
-	int wordlen; // length of the word part (before the '(' brace) of the api array element
-	int length = 0; // length of the returned buffer of words (string)
-	int newlength; // length of the new buffer before the reallocating itself
-	#undef WORDCHUNK // how many characters will be pre-allocated (to avoid buffer reallocation on each new word)
-	#define WORDCHUNK 100
-	int size = WORDCHUNK; // real size of the returned buffer of words
-	char *buffer; // buffer for the words returned
-	int start = 0; // lower bound of the api array block to search
-	int end = len - 1; // upper bound of the api array block to search
-	int pivot; // index of api array element just being compared
-	int cond; // comparison result (in the sense of strcmp() result)
-	int oldpivot; // pivot storage to be able to browse the api array upwards and then downwards
-	const char *word; // api array element just being compared
-	const char *brace; // position of the opening brace in the api array element just being compared
-
-	if (0 == words)
-		return NULL;
-	if (!sorted) {
-		sorted = true;
-		SortWordList(words, wordsNoCase, len);
-	}
-	buffer = (char*) malloc(size);
-	*buffer = '\0';
-	if (ignoreCase)
-		while (start <= end) { // binary searching loop
-			pivot = (start + end) >> 1;
-			word = wordsNoCase[pivot];
-			cond = strncasecmp(wordStart, word, searchLen);
-			if (!cond) {
-				oldpivot = pivot;
-				do { // browse sequentially the rest after the hit
-					brace = strchr(word, '(');
-					if (brace)
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					else {
-						brace = word + strlen(word);
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					}
-					wordlen = brace - word + 1;
-					newlength = length + wordlen; // stretch the buffer
-					if (length)
-						newlength++;
-					if (newlength >= size) {
-						do
-							size += WORDCHUNK;
-						while (size <= newlength);
-						buffer = (char*) realloc(buffer, size);
-					}
-					if (length) // append a new entry
-						buffer[length++] = ' ';
-					memcpy(buffer + length, word, wordlen);
-					length = newlength;
-					buffer[length] = '\0';
-					if (++pivot > end)
-						break;
-					word = wordsNoCase[pivot];
-				} while (!strncasecmp(wordStart, word, searchLen));
-
-				pivot = oldpivot;
-				for (;;) { // browse sequentially the rest before the hit
-					if (--pivot < start)
-						break;
-					word = wordsNoCase[pivot];
-					if (strncasecmp(wordStart, word, searchLen))
-						break;                 
-					brace = strchr(word, '(');
-					if (brace)
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					else {
-						brace = word + strlen(word);
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					}
-					wordlen = brace - word + 1;
-					newlength = length + wordlen; // stretch the buffer
-					if (length)
-						newlength++;
-					if (newlength >= size)
-					{
-						do
-							size += WORDCHUNK;
-						while (size <= newlength);
-						buffer = (char*) realloc(buffer, size);
-					}
-					if (length) // append a new entry
-						buffer[length++] = ' ';
-					memcpy(buffer + length, word, wordlen);
-					length = newlength;
-					buffer[length] = '\0';
-				}
-				return buffer; // result has to be freed with free()
-			}
-			else if (cond < 0)
-				end = pivot - 1;
-			else if (cond > 0)
-				start = pivot + 1;
-		}
-	else // preserve the letter case
-		while (start <= end) { // binary searching loop
-			pivot = (start + end) >> 1;
-			word = words[pivot];
-			cond = strncmp(wordStart, word, searchLen);
-			if (!cond) {
-				oldpivot = pivot;
-				do { // browse sequentially the rest after the hit
-					brace = strchr(word, '(');
-					if (brace)
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					else {
-						brace = word + strlen(word);
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					}
-					wordlen = brace - word + 1;
-					newlength = length + wordlen; // stretch the buffer
-					if (length)
-						newlength++;
-					if (newlength >= size)
-					{
-						do
-							size += WORDCHUNK;
-						while (size <= newlength);
-						buffer = (char*) realloc(buffer, size);
-					}
-					if (length) // append a new entry
-						buffer[length++] = ' ';
-					memcpy(buffer + length, word, wordlen);
-					length = newlength;
-					buffer[length] = '\0';
-					if (++pivot > end)
-						break;
-					word = words[pivot];
-				} while (!strncmp(wordStart, word, searchLen));
-
-				pivot = oldpivot;
-				for (;;) { // browse sequentially the rest before the hit
-					if (--pivot < start)
-						break;
-					word = words[pivot];
-					if (strncmp(wordStart, word, searchLen))
-						break;
-					brace = strchr(word, '(');
-					if (brace)
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					else {
-						brace = word + strlen(word);
-						do
-							if (--brace < word)
-								break;
-						while (isspace(*brace));
-					}
-					wordlen = brace - word + 1;
-					newlength = length + wordlen; // stretch the buffer
-					if (length)
-						newlength++;
-					if (newlength >= size)
-					{
-						do
-							size += WORDCHUNK;
-						while (size <= newlength);
-						buffer = (char*) realloc(buffer, size);
-					}
-					if (length) // append a new entry
-						buffer[length++] = ' ';
-					memcpy(buffer + length, word, wordlen);
-					length = newlength;
-					buffer[length] = '\0';
-				}
-				return buffer; // result has to be freed with free()
-			}
-			else if (cond < 0)
-				end = pivot - 1;
-			else if (cond > 0)
-				start = pivot + 1;
-		}
-	free(buffer);
-	return NULL;
-}