--- a/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,3 +1,13 @@
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* INSTALL: Remove references to OffiX.
+	* configure.ac: Remove support for OffiX drag-and-drop.
+	* configure: Regenerate.
+
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* INSTALL: Replace reference to yow.
+
 2009-12-18  Jerry James  <james@xemacs.org>
 
 	* INSTALL: Remove reference to rcs-checkin.

--- a/INSTALL	Sat Dec 19 18:10:20 2009 +0000
+++ b/INSTALL	Thu Dec 31 15:47:03 2009 +0000
@@ -379,11 +379,6 @@
 drop support.  `configure' will attempt to detect this option and
 define `--with-cde' for you.
 
-The `--with-offix' option allows you to enable or disable OffiX drag
-and drop support.  This requires no external library support, so if
-X11 support is available, then this option defaults to `yes'.  OffiX
-support can be explicitly disabled via the `--with-offix=no' option.
-
 Internationalization Options
 ----------------------------
 
@@ -586,7 +581,7 @@
 		`/usr/local/lib/xemacs/site-lisp/*'.
 
 `/usr/local/lib/xemacs-VERSION/etc' holds the XEmacs tutorial, the
-		`yow' database, and other architecture-independent
+		Unicode database, and other architecture-independent
 		files XEmacs might need while running.  VERSION is as
 		specified for `.../lisp'.
 
@@ -895,7 +890,6 @@
 --with-widgets            Unchanged
 --with-dragndrop          Unchanged
 --with-cde                Unchanged
---with-offix              Unchanged
 --with-xmu                Unchanged
 --external-widget         --with-external-widget
 

--- a/configure	Sat Dec 19 18:10:20 2009 +0000
+++ b/configure	Thu Dec 31 15:47:03 2009 +0000
@@ -954,8 +954,6 @@
 with_dragndrop
 enable_cde
 with_cde
-enable_offix
-with_offix
 enable_external_widget
 with_external_widget
 enable_tty
@@ -1851,15 +1849,10 @@
                           can be found, else Athena is used.
   --with-dragndrop        Compile in the generic drag and drop API. This is
                           automatically added if one of the drag and drop
-                          protocols is found (currently CDE, OffiX, MSWindows,
-                          and GTK). *WARNING* The Drag'n'drop support is under
+                          protocols is found (currently CDE, MSWindows, and
+                          GTK). *WARNING* The Drag'n'drop support is under
                           development and is considered experimental.
   --with-cde              Compile in support for CDE drag and drop.
-  --with-offix            Compile in support for OffiX drag and drop.
-                          *WARNING* If you compile in OffiX, you may not be
-                          able to use multiple X displays success- fully. If
-                          the two servers are from different vendors, the
-                          results may be unpredictable.
   --with-external-widget
                           Support XEmacs server for text widgets in other
                           applications.
@@ -3539,22 +3532,6 @@
   withval="$with_cde"
 
 fi;
-# If --with-offix or --without-offix were given then copy the value to the
-# equivalent enable_offix variable.
-if test "${with_offix+set}" = set; then
-  enable_offix="$with_offix"
-fi;
-# If -enable-offix or --disable-offix were given then copy the value to the
-# equivalent with_offix variable.
-if test "${enable_offix+set}" = set; then
-  with_offix="$enable_offix"
-fi;
-# Check whether --with-offix or --without-offix was given.
-if test "${with_offix+set}" = set; then
-  enableval="$with_offix"
-  withval="$with_offix"
-
-fi;
 # If --with-external-widget or --without-external-widget were given then copy the value to the
 # equivalent enable_external-widget variable.
 if test "${with_external_widget+set}" = set; then
@@ -21053,7 +21030,7 @@
 fi
 
 if test "$with_x11" != "yes"; then
-            for feature in with_tooltalk with_cde with_offix with_wmcommand with_xim enable_sound_nas
+            for feature in with_tooltalk with_cde with_wmcommand with_xim enable_sound_nas
   do
     if eval "test -n \"\$${feature}\" -a \"\$${feature}\" != \"no\"" ; then
        { $as_echo "$as_me:$LINENO: WARNING: --$feature ignored:  Not valid without X support" >&5
@@ -23384,30 +23361,6 @@
   need_motif=yes    # CDE requires Motif
 fi
 
-test "$window_system" != "x11" && with_offix=no
-if test "$with_dragndrop" = no; then
-  if test "$with_offix" = "yes" ; then
-    { $as_echo "$as_me:$LINENO: WARNING: --with-offix forced to \`no'; no generic Drag'n'Drop support" >&5
-$as_echo "$as_me: WARNING: --with-offix forced to \`no'; no generic Drag'n'Drop support" >&2;}
-  fi
-  with_offix=no
-fi
-if test "$with_cde" = yes; then
-  if test "$with_offix" = "yes" ; then
-    { $as_echo "$as_me:$LINENO: WARNING: --with-offix forced to \`no'; CDE already found" >&5
-$as_echo "$as_me: WARNING: --with-offix forced to \`no'; CDE already found" >&2;}
-  fi
-  with_offix=no
-fi
-test -z "$with_offix" && with_offix=no
-if test "$with_offix" = "yes"; then
-  cat >>confdefs.h <<\_ACEOF
-#define HAVE_OFFIX_DND 1
-_ACEOF
-
-  dnd_objs="$dnd_objs offix.o" &&  if test "$verbose" = "yes"; then echo "    Appending \"offix.o\" to \$dnd_objs"; fi
-  dragndrop_proto="$dragndrop_proto OffiX" &&  if test "$verbose" = "yes"; then echo "    Appending \"OffiX\" to \$dragndrop_proto"; fi
-fi
 if test "$with_gtk" = "yes"; then
    dragndrop_proto="$dragndrop_proto GTK" &&  if test "$verbose" = "yes"; then echo "    Appending \"GTK\" to \$dragndrop_proto"; fi
 fi

--- a/configure.ac	Sat Dec 19 18:10:20 2009 +0000
+++ b/configure.ac	Thu Dec 31 15:47:03 2009 +0000
@@ -741,22 +741,13 @@
 	[], [],[yes,no,lucid,motif,athena,gtk,msw])
 XE_MERGED_ARG([dragndrop],
 	AS_HELP_STRING([--with-dragndrop],[Compile in the generic drag and drop API. This is automatically added if one of the drag and drop
-                        protocols is found (currently CDE, OffiX, MSWindows,
-                        and GTK).
+                        protocols is found (currently CDE, MSWindows, and GTK).
                         *WARNING*  The Drag'n'drop support is under development
                                    and is considered experimental.]),
 	[], [])
 XE_MERGED_ARG([cde],
 	AS_HELP_STRING([--with-cde],[Compile in support for CDE drag and drop.]),
 	[], [])
-XE_MERGED_ARG([offix],
-	AS_HELP_STRING([--with-offix],[Compile in support for OffiX drag and drop.
-                        *WARNING*  If you compile in OffiX, you may not be
-                                   able to use multiple X displays success-
-                                   fully.  If the two servers are from
-                                   different vendors, the results may be
-                                   unpredictable.]),
-	[], [])
 XE_MERGED_ARG([external-widget],
 	AS_HELP_STRING([--enable-external-widget],[Support XEmacs server for text widgets in other applications.]),
 	[], [])
@@ -3252,7 +3243,7 @@
   dnl if test "$with_tty" = "no" ; then
   dnl   AC_MSG_ERROR([No window system support and no TTY support - Unable to proceed.])
   dnl fi
-  for feature in with_tooltalk with_cde with_offix with_wmcommand with_xim enable_sound_nas
+  for feature in with_tooltalk with_cde with_wmcommand with_xim enable_sound_nas
   do
     if eval "test -n \"\$${feature}\" -a \"\$${feature}\" != \"no\"" ; then
        AC_MSG_WARN([--$feature ignored:  Not valid without X support])
@@ -3488,35 +3479,12 @@
   need_motif=yes    # CDE requires Motif
 fi
 
-dnl Always compile OffiX unless --without-offix is given, no
-dnl X11 support is compiled in, or dragndrop support is disabled
-dnl Because OffiX support currently loses when more than one display
-dnl is in use, we now disable it by default -slb 07/10/1998.
-test "$window_system" != "x11" && with_offix=no
-if test "$with_dragndrop" = no; then
-  if test "$with_offix" = "yes" ; then
-    AC_MSG_WARN([--with-offix forced to `no'; no generic Drag'n'Drop support])
-  fi
-  with_offix=no
-fi
-if test "$with_cde" = yes; then
-  if test "$with_offix" = "yes" ; then
-    AC_MSG_WARN([--with-offix forced to `no'; CDE already found])
-  fi
-  with_offix=no
-fi
-test -z "$with_offix" && with_offix=no
-if test "$with_offix" = "yes"; then
-  AC_DEFINE(HAVE_OFFIX_DND)
-  XE_APPEND(offix.o, dnd_objs)
-  XE_APPEND(OffiX, dragndrop_proto)
-fi
 if test "$with_gtk" = "yes"; then
    XE_APPEND(GTK, dragndrop_proto)
 fi
 
 dnl Autodetect Drag'n'Drop support
-dnl always included if CDE, Offix, or MSWindows are defined
+dnl always included if CDE or MSWindows is defined
 if test "$with_dragndrop" != "no" ; then
   AC_MSG_CHECKING(if drag and drop API is needed)
   if test -n "$dragndrop_proto" ; then

--- a/lib-src/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/lib-src/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,3 +1,8 @@
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* Makefile.in.in: Remove rules for building yow.
+	* yow.c: Removed.
+
 2009-12-18  Jerry James  <james@xemacs.org>
 
 	* Makefile.in.in: Don't install rcs-checkin.

--- a/lib-src/Makefile.in.in	Sat Dec 19 18:10:20 2009 +0000
+++ b/lib-src/Makefile.in.in	Thu Dec 31 15:47:03 2009 +0000
@@ -118,7 +118,7 @@
  fakemail\
 #endif
  profile make-docfile digest-doc\
- sorted-doc movemail cvtmail yow hexl mmencode
+ sorted-doc movemail cvtmail hexl mmencode
 
 GEN_SCRIPTS = rcs2log vcdiff gzip-el.sh
 PKG_SCRIPTS = add-big-package.sh
@@ -363,9 +363,6 @@
 fakemail: ${srcdir}/fakemail.c ../src/config.h
 	$(CC) $(cflags) ${srcdir}/fakemail.c $(ldflags) -o $@
 
-yow: ${srcdir}/yow.c ../src/paths.h
-	$(CC) $(cflags) ${srcdir}/yow.c $(ldflags) -o $@
-
 i: ${srcdir}/i.c
 	$(CC) $(cflags) ${srcdir}/i.c $(ldflags) -o $@
 

--- a/lib-src/yow.c	Sat Dec 19 18:10:20 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,176 +0,0 @@
-/*
- * yow.c
- * 
- * Print a quotation from Zippy the Pinhead.
- * Qux <Kaufman-David@Yale> March 6, 1986
- * 
- * With dynamic memory allocation.
- */
-
-/* Synched up with: FSF 19.28. */
-
-#include <config.h>
-
-#include <stdio.h>
-#include <ctype.h>
-#include <../src/paths.h>      /* For PATH_DATA.  */
-
-#if __STDC__ || defined(STDC_HEADERS)
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <time.h> /* for time() */
-#endif
-
-#define BUFSIZE  80
-#define SEP      '\0'
-
-#ifndef YOW_FILE
-#define YOW_FILE "yow.lines"
-#endif
-
-void yow (FILE *fp);
-void setup_yow (FILE *fp);
-
-#ifdef WIN32_NATIVE
-#define rootrelativepath(rel) \
-({\
-    static char res[BUFSIZE], *p;\
-    strcpy (res, argv[0]);\
-    p = res + strlen (res);\
-    while (p != res && *p != '/' && *p != '\\' && *p != ':') p--;\
-    strcpy (p + 1, "../");\
-    strcpy (p + 4, rel);\
-    &res;})
-#endif
-
-int
-main (int argc, char *argv[])
-{
-  FILE *fp;
-  char file[BUFSIZ];
-
-  if (argc > 2 && !strcmp (argv[1], "-f"))
-    strcpy (file, argv[2]);
-  else
-#ifdef PATH_DATA
-#ifdef vms
-    sprintf (file, "%s%s", PATH_DATA, YOW_FILE);
-#else
-    sprintf (file, "%s/%s", PATH_DATA, YOW_FILE);
-#endif
-#else /* !PATH_DATA */
-  {
-    fprintf (stderr,
-     "%s: the location of the \"%s\" file was not supplied at compile-time.\n\
-        You must supply it with the -f command-line option.\n",
-             argv[0], YOW_FILE);
-    exit (1);
-  }
-#endif
-
-  if ((fp = fopen(file, "r")) == NULL) {
-    perror(file);
-    exit(1);
-  }
-
-  /* initialize random seed */
-  srand((int) (getpid() + time((time_t *) 0)));
-
-  setup_yow(fp);
-  yow(fp);
-  fclose(fp);
-  return 0;
-}
-
-static long len = -1;
-static long header_len;
-
-#define AVG_LEN 40		/* average length of a quotation */
-
-/* Sets len and header_len */
-void
-setup_yow (FILE *fp)
-{
-  int c;
-
-  /* Get length of file */
-  /* Because the header (stuff before the first SEP) can be very long,
-   * thus biasing our search in favor of the first quotation in the file,
-   * we explicitly skip that. */
-  while ((c = getc(fp)) != SEP) {
-    if (c == EOF) {
-      fprintf(stderr, "File contains no separators.\n");
-      exit(2);
-    }
-  }
-  header_len = ftell(fp);
-  if (header_len > AVG_LEN)
-    header_len -= AVG_LEN;	/* allow the first quotation to appear */
-	
-  if (fseek(fp, 0L, 2) == -1) {
-    perror("fseek 1");
-    exit(1);
-  }
-  len = ftell(fp) - header_len;
-}
-
-
-/* go to a random place in the file and print the quotation there */
-void
-yow (FILE *fp)
-{
-  long offset;
-  int c, i = 0;
-  char *buf;
-  int bufsize;
-
-  offset = rand() % len + header_len;
-  if (fseek(fp, offset, 0) == -1) {
-    perror("fseek 2");
-    exit(1);
-  }
-
-  /* Read until SEP, read next line, print it.
-     (Note that we will never print anything before the first separator.)
-     If we hit EOF looking for the first SEP, just recurse. */
-  while ((c = getc(fp)) != SEP)
-    if (c == EOF) {
-      yow(fp);
-      return;
-    }
-
-  /* Skip leading whitespace, then read in a quotation.
-     If we hit EOF before we find a non-whitespace char, recurse. */
-  while (isspace(c = getc(fp)))
-    ;
-  if (c == EOF) {
-    yow(fp);
-    return;
-  }
-
-  bufsize = BUFSIZE;
-  buf = (char *) malloc(bufsize);
-  if (buf == (char *)0) {
-    fprintf(stderr, "can't allocate any memory\n");
-    exit (3);
-  }
-
-  buf[i++] = c;
-  while ((c = getc(fp)) != SEP && c != EOF) {
-    buf[i++] = c;
-	
-    if (i == bufsize-1) {
-      /* Yow! Is this quotation too long yet? */
-      bufsize *= 2;
-      buf = (char *)realloc(buf, bufsize);
-      if (buf == (char *)0) {
-	fprintf(stderr, "can't allocate more memory\n");
-	exit (3);
-      }
-    }
-  }
-  buf[i++] = 0;
-  printf("%s\n", buf);
-}
-

--- a/lisp/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,7 +1,38 @@
+2009-12-31  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* list-mode.el (next-list-mode-item, switch-to-completions): Use
+	next-single-char-property-change,
+	previous-single-char-property-change now
+	next-single-property-change no longer pays attention to extents
+	not created using the text property functions. Fix for issue 546,
+	bug dates from changeset 8c96bdabcaf9.
+
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* dragdrop.el (offix-start-drag): Remove.
+	(offix-start-drag-region): Remove.
+	* mouse.el (mouse-begin-drag-n-drop): Remove OffiX support.
+
+2009-12-21  Adrian Aichner  <adrian@xemacs.org>
+
+	* package-get.el (package-get-download-sites): Remove
+	dk.xemacs.org from list of package download sites.
+	* package-get.el (package-get-pre-release-download-sites): Ditto.
+
+2009-12-21  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* mule/arabic.el (arabic-iso8859-6): 
+	Move the creation of this character set to this (dumped) file,
+	since it's needed for input on X11. 
+	* mule/iso-with-esc.el: 
+	Remove arabic-iso8859-6 and its Unicode map from this file.
+	* unicode.el (load-unicode-tables): 
+	Load arabic-iso8859-6 on startup again.
+
 2009-12-19  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* cl-macs.el (cl-do-arglist):
-	* cl-compat.el (keyword-of): 
+	* cl-compat.el (keyword-of):
 	Remove support in our generated code for emacs versions where
 	keywords are not self-quoting.
 
@@ -141,6 +172,19 @@
 	calls to it. Keep the information about the bytecode's numeric
 	value, we want that for disassembling code.
 
+2009-11-08  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* cl-extra.el (cl-string-vector-equalp)
+	(cl-bit-vector-vector-equalp, cl-vector-array-equalp)
+	(cl-hash-table-contents-equalp): New functions, to implement
+	equalp treating arrays with identical contents as equivalent, as
+	specified by Common Lisp. 
+	(equalp): Revise this function to implement array equivalence,
+	and the hash-table equalp behaviour specified by CL.
+	* cl-macs.el (equalp): Add a compiler macro for this function,
+	used when one of the arguments is constant, and as such, its type
+	is known at compile time. 
+
 2009-11-01  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* cl-extra.el (equalp): 

--- a/lisp/cl-extra.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/cl-extra.el	Thu Dec 31 15:47:03 2009 +0000
@@ -89,35 +89,128 @@
 
 ;;; Predicates.
 
+;; I'd actually prefer not to have this inline, the space
+;; vs. amount-it's-called trade-off isn't reasonable, but that would
+;; introduce bytecode problems with the compiler macro in cl-macs.el.
+(defsubst cl-string-vector-equalp (cl-string cl-vector)
+  "Helper function for `equalp', which see."
+;  (check-argument-type #'stringp cl-string)
+;  (check-argument-type #'vector cl-vector)
+  (let ((cl-i (length cl-string))
+	cl-char cl-other)
+    (when (= cl-i (length cl-vector))
+      (while (and (>= (setq cl-i (1- cl-i)) 0)
+		  (or (eq (setq cl-char (aref cl-string cl-i))
+			  (setq cl-other (aref cl-vector cl-i)))
+		      (and (characterp cl-other) ; Note we want to call this
+					         ; as rarely as possible, it
+					         ; doesn't have a bytecode.
+			   (eq (downcase cl-char) (downcase cl-other))))))
+      (< cl-i 0))))
+
+;; See comment on cl-string-vector-equalp above.
+(defsubst cl-bit-vector-vector-equalp (cl-bit-vector cl-vector)
+  "Helper function for `equalp', which see."
+;  (check-argument-type #'bit-vector-p cl-bit-vector)
+;  (check-argument-type #'vectorp cl-vector)
+  (let ((cl-i (length cl-bit-vector))
+	cl-other)
+    (when (= cl-i (length cl-vector))
+      (while (and (>= (setq cl-i (1- cl-i)) 0)
+		  (numberp (setq cl-other (aref cl-vector cl-i)))
+		  ;; Differs from clisp here. 
+		  (= (aref cl-bit-vector cl-i) cl-other)))
+      (< cl-i 0))))
+
+;; These two helper functions call equalp recursively, the two above have no
+;; need to.
+(defsubst cl-vector-array-equalp (cl-vector cl-array)
+  "Helper function for `equalp', which see."
+;  (check-argument-type #'vector cl-vector)
+;  (check-argument-type #'arrayp cl-array)
+  (let ((cl-i (length cl-vector)))
+    (when (= cl-i (length cl-array))
+      (while (and (>= (setq cl-i (1- cl-i)) 0)
+		  (equalp (aref cl-vector cl-i) (aref cl-array cl-i))))
+      (< cl-i 0))))
+
+(defsubst cl-hash-table-contents-equalp (cl-hash-table-1 cl-hash-table-2)
+  "Helper function for `equalp', which see."
+  (symbol-macrolet
+      ;; If someone has gone and fished the uninterned symbol out of this
+      ;; function's constants vector, and subsequently stored it as a value
+      ;; in a hash table, it's their own damn fault when
+      ;; `cl-hash-table-contents-equalp' gives the wrong answer.
+      ((equalp-default '#:equalp-default))
+    (loop
+      for x-key being the hash-key in cl-hash-table-1
+      using (hash-value x-value)
+      with y-value = nil
+      always (and (not (eq equalp-default
+			   (setq y-value (gethash x-key cl-hash-table-2
+						  equalp-default))))
+		  (equalp y-value x-value)))))
+
 (defun equalp (x y)
   "Return t if two Lisp objects have similar structures and contents.
+
 This is like `equal', except that it accepts numerically equal
-numbers of different types (float vs. integer), and also compares
-strings case-insensitively."
-  (cond ((eq x y) t)
+numbers of different types (float, integer, bignum, bigfloat), and also
+compares strings and characters case-insensitively.
+
+Arrays (that is, strings, bit-vectors, and vectors) of the same length and
+with contents that are `equalp' are themselves `equalp'.
+
+Two hash tables are `equalp' if they have the same test (see
+`hash-table-test'), if they have the same number of entries, and if, for
+each entry in one hash table, its key is equivalent to a key in the other
+hash table using the hash table test, and its value is `equalp' to the other
+hash table's value for that key."
+  (cond ((eq x y))
 	((stringp x)
-	 ;; XEmacs change: avoid downcase
-	 (and (stringp y)
-	      (eq t (compare-strings x nil nil y nil nil t))))
-	;; XEmacs addition: compare characters
-	((characterp x)
-	 (and (characterp y)
-	      (or (char-equal x y)
-		  (char-equal (downcase x) (downcase y)))))
+	 (if (stringp y)
+	     (eq t (compare-strings x nil nil y nil nil t))
+	   (if (vectorp y)
+	       (cl-string-vector-equalp x y)
+	     ;; bit-vectors and strings are only equalp if they're
+	     ;; zero-length:
+	     (and (equal "" x) (equal #* y)))))
 	((numberp x)
 	 (and (numberp y) (= x y)))
 	((consp x)
 	 (while (and (consp x) (consp y) (equalp (car x) (car y)))
 	   (setq x (cdr x) y (cdr y)))
 	 (and (not (consp x)) (equalp x y)))
-	((vectorp x)
-	 (and (vectorp y) (= (length x) (length y))
-	      (let ((i (length x)))
-		(while (and (>= (setq i (1- i)) 0)
-			    (equalp (aref x i) (aref y i))))
-		(< i 0))))
-	(t (equal x y))))
-
+	(t
+	 ;; From here on, the type tests don't (yet) have bytecodes. 
+	 (let ((x-type (type-of x)))
+	   (cond ((eq 'vector x-type)
+		  (if (stringp y)
+		      (cl-string-vector-equalp y x)
+		    (if (vectorp y)
+			(cl-vector-array-equalp x y)
+		      (if (bit-vector-p y)
+			  (cl-bit-vector-vector-equalp y x)))))
+		 ((eq 'character x-type)
+		  (and (characterp y)
+		       ;; If the characters are actually identical, the
+		       ;; first eq test will have caught them above; we only
+		       ;; need to check them case-insensitively here.
+		       (eq (downcase x) (downcase y))))
+		 ((eq 'hash-table x-type)
+		  (and (hash-table-p y)
+		       (eq (hash-table-test x) (hash-table-test y))
+		       (= (hash-table-count x) (hash-table-count y))
+		       (cl-hash-table-contents-equalp x y)))
+		 ((eq 'bit-vector x-type)
+		  (if (bit-vector-p y)
+		      (equal x y)
+		    (if (vectorp y)
+			(cl-bit-vector-vector-equalp x y)
+		      ;; bit-vectors and strings are only equalp if they're
+		      ;; zero-length:
+		      (and (equal "" y) (equal #* x)))))
+		 (t (equal x y)))))))
 
 ;;; Control structures.
 

--- a/lisp/cl-macs.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/cl-macs.el	Thu Dec 31 15:47:03 2009 +0000
@@ -3350,6 +3350,117 @@
       (regexp-quote string)
     form))
 
+(define-compiler-macro equalp (&whole form x y) 
+  "Expand calls to `equalp' where X or Y is a constant expression.
+
+Much of the processing that `equalp' does is dependent on the types of both
+of its arguments, and with type information for one of them, we can
+eliminate much of the body of the function at compile time.
+
+Where both X and Y are constant expressions, `equalp' is evaluated at
+compile time by byte-optimize.el--this compiler macro passes FORM through to
+the byte optimizer in those cases."
+  ;; Cases where both arguments are constant are handled in
+  ;; byte-optimize.el, we only need to handle those cases where one is
+  ;; constant here.
+  (let* ((equalp-sym (eval-when-compile (gensym)))
+	(let-form '(progn))
+	(check-bit-vector t)
+	(check-string t)
+	(original-y y)
+	equalp-temp checked)
+  (macrolet
+      ((unordered-check (check)
+	 `(prog1
+	     (setq checked
+		   (or ,check
+		       (prog1 ,(sublis '((x . y) (y . x)) check :test #'eq)
+			 (setq equalp-temp x x y y equalp-temp))))
+	   (when checked
+	     (unless (symbolp y)
+	       (setq let-form `(let ((,equalp-sym ,y))) y equalp-sym))))))
+    ;; In the bodies of the below clauses, x is always a constant expression
+    ;; of the type we're interested in, and y is always a symbol that refers
+    ;; to the result non-constant side of the comparison. 
+    (cond ((unordered-check (and (arrayp x) (not (cl-const-expr-p y))))
+	   ;; Strings and other arrays. A vector containing the same
+	   ;; character elements as a given string is equalp to that string;
+	   ;; a bit-vector can only be equalp to a string if both are
+	   ;; zero-length.
+	   (cond
+	    ((member x '("" #* []))
+	     ;; No need to protect against multiple evaluation here:
+	     `(and (member ,original-y '("" #* [])) t))
+	    ((stringp x)
+	     `(,@let-form
+	       (if (stringp ,y)
+		   (eq t (compare-strings ,x nil nil
+					  ,y nil nil t))
+		 (if (vectorp ,y) 
+		     (cl-string-vector-equalp ,x ,y)))))
+	    ((bit-vector-p x)
+	     `(,@let-form
+	       (if (bit-vector-p ,y)
+		   ;; No need to call equalp on each element here:
+		   (equal ,x ,y)
+		 (if (vectorp ,y) 
+		     (cl-bit-vector-vector-equalp ,x ,y)))))
+	    (t
+	     (loop
+	       for elt across x
+	       ;; We may not need to check the other argument if it's a
+	       ;; string or bit vector, depending on the contents of x:
+	       always (progn
+			(unless (characterp elt) (setq check-string nil))
+			(unless (and (numberp elt) (or (= elt 0) (= elt 1)))
+			  (setq check-bit-vector nil))
+			(or check-string check-bit-vector)))
+	     `(,@let-form
+	       (cond
+		,@(if check-string
+		      `(((stringp ,y) 
+			 (cl-string-vector-equalp ,y ,x))))
+		,@(if check-bit-vector 
+		      `(((bit-vector-p ,y)
+			 (cl-bit-vector-vector-equalp ,y ,x))))
+		((vectorp ,y)
+		 (cl-vector-array-equalp ,x ,y)))))))
+	  ((unordered-check (and (characterp x) (not (cl-const-expr-p y))))
+	   `(,@let-form
+	     (or (eq ,x ,y)
+		  ;; eq has a bytecode, char-equal doesn't.
+		 (and (characterp ,y)
+		      (eq (downcase ,x) (downcase ,y))))))
+	  ((unordered-check (and (numberp x) (not (cl-const-expr-p y))))
+	   `(,@let-form
+	     (and (numberp ,y)
+		  (= ,x ,y))))
+	  ((unordered-check (and (hash-table-p x) (not (cl-const-expr-p y))))
+	   ;; Hash tables; follow the CL spec.
+	   `(,@let-form
+	     (and (hash-table-p ,y)
+		  (eq ',(hash-table-test x) (hash-table-test ,y))
+		  (= ,(hash-table-count x) (hash-table-count ,y))
+		  (cl-hash-table-contents-equalp ,x ,y))))
+	  ((unordered-check
+	    ;; Symbols; eq. 
+	    (and (not (cl-const-expr-p y))
+		 (or (memq x '(nil t))
+		     (and (eq (car-safe x) 'quote) (symbolp (second x))))))
+	   (cons 'eq (cdr form)))
+	  ((unordered-check
+	    ;; Compare conses at runtime, there's no real upside to
+	    ;; unrolling the function -> they fall through to the next
+	    ;; clause in this function.
+	    (and (cl-const-expr-p x) (not (consp x))
+		 (not (cl-const-expr-p y))))
+	   ;; All other types; use equal.
+	   (cons 'equal (cdr form)))
+	  ;; Neither side is a constant expression, do all our evaluation at
+	  ;; runtime (or both are, and equalp will be called from
+	  ;; byte-optimize.el).
+	  (t form)))))
+
 (mapc
  #'(lambda (y)
      (put (car y) 'side-effect-free t)

--- a/lisp/dragdrop.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/dragdrop.el	Thu Dec 31 15:47:03 2009 +0000
@@ -400,29 +400,6 @@
 	       event nil (list (buffer-substring-no-properties begin end)))
     (error "CDE functionality not compiled in.")))
 
-;; the OffiX drag stuff will soon move also (perhaps mouse.el)
-;; if the drag event is done
-(defun offix-start-drag (event data &optional type)
-  "Implement the OffiX drag operation.
-Calls the internal function offix-start-drag-internal to do the actual work.
-If type is not given, DndText is assumed."
-  ;; Oliver Graf <ograf@fga.de>
-  (interactive "esi")
-  (if (featurep 'offix)
-      (funcall (intern "offix-start-drag-internal") event data type)
-    (error "OffiX functionality not compiled in.")))
-
-(defun offix-start-drag-region (event begin end)
-  "Implement the OffiX drag operation for a region.
-Calls the internal function offix-start-drag-internal to do the actual work.
-This always assumes DndText as type."
-  ;; Oliver Graf <ograf@fga.de>
-  (interactive "_er")
-  (if (featurep 'offix)
-      (funcall (intern "offix-start-drag-internal")
-	       event (buffer-substring-no-properties begin end))
-    (error "OffiX functionality not compiled in.")))
-
 (defun gtk-start-drag (event data &optional type)
   (interactive "esi")
   (if (featurep 'gtk)

--- a/lisp/list-mode.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/list-mode.el	Thu Dec 31 15:47:03 2009 +0000
@@ -174,8 +174,9 @@
       (if extent (goto-char (extent-end-position extent)))
       ;; Move to start of next one.
       (or (extent-at (point) (current-buffer) 'list-mode-item)
-	  (goto-char (next-single-property-change (point) 'list-mode-item
-						  nil end))))
+	  (goto-char (next-single-char-property-change (point)
+						       'list-mode-item
+						       nil end))))
     (setq n (1- n)))
   (while (and (< n 0) (not (bobp)))
     (let ((extent (extent-at (point) (current-buffer) 'list-mode-item))
@@ -186,7 +187,7 @@
       (if (setq extent (extent-at (point) (current-buffer) 'list-mode-item
 				  nil 'before))
 	  (goto-char (extent-start-position extent))
-	(goto-char (previous-single-property-change
+	(goto-char (previous-single-char-property-change
 		    (point) 'list-mode-item nil end))
 	(if (setq extent (extent-at (point) (current-buffer) 'list-mode-item
 				    nil 'before))
@@ -648,7 +649,7 @@
   (if (not (get-buffer-window "*Completions*"))
       nil
     (select-window (get-buffer-window "*Completions*"))
-    (goto-char (next-single-property-change (point-min) 'list-mode-item nil
-					    (point-max)))))
+    (goto-char (next-single-char-property-change (point-min) 'list-mode-item
+						 nil (point-max)))))
 
 ;;; list-mode.el ends here

--- a/lisp/mouse.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/mouse.el	Thu Dec 31 15:47:03 2009 +0000
@@ -231,15 +231,7 @@
 Returns whether a drag was begun."
   ;; #### barely implemented.
   (when (click-inside-selection-p event)
-    (cond ((featurep 'offix)
-	   (declare-fboundp
-	    (offix-start-drag-region
-	     event
-	     (extent-start-position zmacs-region-extent)
-	     (extent-end-position zmacs-region-extent)))
-	   t)
-	  ((featurep 'cde)
-	   ;; should also work with CDE
+    (cond ((featurep 'cde)
 	   (declare-fboundp
 	    (cde-start-drag-region event
 				   (extent-start-position zmacs-region-extent)

--- a/lisp/mule/arabic.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/mule/arabic.el	Thu Dec 31 15:47:03 2009 +0000
@@ -28,8 +28,34 @@
 
 ;;; Code:
 
-;; See iso-with-esc.el for commentary on the ISO standard Arabic character
-;; set.
+;; ISO 8859-6 is such a useless character set that it seems a waste of
+;; codespace to dump it. Let me count the ways: 
+;; 
+;; 1. It doesn't support Persian or Urdu, let alone Sinhalese, despite
+;;    plenty of unallocated code points.
+;;
+;; 2. It doesn't encode all the vowel diacritics (the Harakaat) despite that
+;;    they are necessary, even for the Arabs, for basic things like
+;;    dictionary entries, children's books, and occasional disambiguation.
+;;
+;; 3. The Arabs don't use it, they use Windows-1256, which also supports
+;;    Persian, at least, as well as the French characters necessary in
+;;    Lebanon and North Africa.
+
+;; But; it's necessary for input on X11.
+
+(make-charset
+ 'arabic-iso8859-6 
+ "Right-Hand Part of Latin/Arabic Alphabet (ISO/IEC 8859-6): ISO-IR-127"
+ '(dimension 1
+   registry "ISO8859-6"
+   chars 96
+   columns 1
+   direction r2l
+   final ?G
+   graphic 1
+   short-name "RHP of ISO8859/6"
+   long-name "RHP of Arabic (ISO 8859-6): ISO-IR-127"))
 
 (make-coding-system
  'iso-8859-6 'fixed-width "ISO 8859-6 (Arabic)"

--- a/lisp/mule/iso-with-esc.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/mule/iso-with-esc.el	Thu Dec 31 15:47:03 2009 +0000
@@ -120,89 +120,6 @@
    safe-charsets (ascii greek-iso8859-7)
    mnemonic "Grk"))
 
-;; ISO 8859-6 is such a useless character set that it seems a waste of
-;; codespace to dump it. Let me count the ways: 
-;; 
-;; 1. It doesn't support Persian or Urdu, let alone Sinhalese, despite
-;;    plenty of unallocated code points.
-;;
-;; 2. It doesn't encode all the vowel diacritics (the Harakaat) despite that
-;;    they are necessary, even for the Arabs, for basic things like
-;;    dictionary entries, children's books, and occasional disambiguation.
-;;
-;; 3. The Arabs don't use it, they use Windows-1256, which also supports
-;;    Persian, at least, as well as the French characters necessary in
-;;    Lebanon and North Africa.
-
-(make-charset
- 'arabic-iso8859-6 
- "Right-Hand Part of Latin/Arabic Alphabet (ISO/IEC 8859-6): ISO-IR-127"
- '(dimension 1
-   registry "ISO8859-6"
-   chars 96
-   columns 1
-   direction r2l
-   final ?G
-   graphic 1
-   short-name "RHP of ISO8859/6"
-   long-name "RHP of Arabic (ISO 8859-6): ISO-IR-127"))
-
-(loop
-  for (iso8859-6 unicode)
-  in '((#xA0 #x00A0) ;; NO-BREAK SPACE
-       (#xA4 #x00A4) ;; CURRENCY SIGN
-       (#xAC #x060C) ;; ARABIC COMMA
-       (#xAD #x00AD) ;; SOFT HYPHEN
-       (#xBB #x061B) ;; ARABIC SEMICOLON
-       (#xBF #x061F) ;; ARABIC QUESTION MARK
-       (#xC1 #x0621) ;; ARABIC LETTER HAMZA
-       (#xC2 #x0622) ;; ARABIC LETTER ALEF WITH MADDA ABOVE
-       (#xC3 #x0623) ;; ARABIC LETTER ALEF WITH HAMZA ABOVE
-       (#xC4 #x0624) ;; ARABIC LETTER WAW WITH HAMZA ABOVE
-       (#xC5 #x0625) ;; ARABIC LETTER ALEF WITH HAMZA BELOW
-       (#xC6 #x0626) ;; ARABIC LETTER YEH WITH HAMZA ABOVE
-       (#xC7 #x0627) ;; ARABIC LETTER ALEF
-       (#xC8 #x0628) ;; ARABIC LETTER BEH
-       (#xC9 #x0629) ;; ARABIC LETTER TEH MARBUTA
-       (#xCA #x062A) ;; ARABIC LETTER TEH
-       (#xCB #x062B) ;; ARABIC LETTER THEH
-       (#xCC #x062C) ;; ARABIC LETTER JEEM
-       (#xCD #x062D) ;; ARABIC LETTER HAH
-       (#xCE #x062E) ;; ARABIC LETTER KHAH
-       (#xCF #x062F) ;; ARABIC LETTER DAL
-       (#xD0 #x0630) ;; ARABIC LETTER THAL
-       (#xD1 #x0631) ;; ARABIC LETTER REH
-       (#xD2 #x0632) ;; ARABIC LETTER ZAIN
-       (#xD3 #x0633) ;; ARABIC LETTER SEEN
-       (#xD4 #x0634) ;; ARABIC LETTER SHEEN
-       (#xD5 #x0635) ;; ARABIC LETTER SAD
-       (#xD6 #x0636) ;; ARABIC LETTER DAD
-       (#xD7 #x0637) ;; ARABIC LETTER TAH
-       (#xD8 #x0638) ;; ARABIC LETTER ZAH
-       (#xD9 #x0639) ;; ARABIC LETTER AIN
-       (#xDA #x063A) ;; ARABIC LETTER GHAIN
-       (#xE0 #x0640) ;; ARABIC TATWEEL
-       (#xE1 #x0641) ;; ARABIC LETTER FEH
-       (#xE2 #x0642) ;; ARABIC LETTER QAF
-       (#xE3 #x0643) ;; ARABIC LETTER KAF
-       (#xE4 #x0644) ;; ARABIC LETTER LAM
-       (#xE5 #x0645) ;; ARABIC LETTER MEEM
-       (#xE6 #x0646) ;; ARABIC LETTER NOON
-       (#xE7 #x0647) ;; ARABIC LETTER HEH
-       (#xE8 #x0648) ;; ARABIC LETTER WAW
-       (#xE9 #x0649) ;; ARABIC LETTER ALEF MAKSURA
-       (#xEA #x064A) ;; ARABIC LETTER YEH
-       (#xEB #x064B) ;; ARABIC FATHATAN
-       (#xEC #x064C) ;; ARABIC DAMMATAN
-       (#xED #x064D) ;; ARABIC KASRATAN
-       (#xEE #x064E) ;; ARABIC FATHA
-       (#xEF #x064F) ;; ARABIC DAMMA
-       (#xF0 #x0650) ;; ARABIC KASRA
-       (#xF1 #x0651) ;; ARABIC SHADDA
-       (#xF2 #x0652));; ARABIC SUKUN
-  do (set-unicode-conversion (make-char 'arabic-iso8859-6 iso8859-6)
-                             unicode))
-
 ;;;###autoload
 (make-coding-system
  'arabic-iso-8bit-with-esc 'iso2022  ;; GNU's iso-8859-6 is

--- a/lisp/package-get.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/package-get.el	Thu Dec 31 15:47:03 2009 +0000
@@ -227,7 +227,6 @@
 ;     ("Chile (cl.xemacs.org)" "ftp.cl.xemacs.org" "packages")
     ("China (ftp.cn.xemacs.org)" "ftp.cn.xemacs.org" "pub/xemacs/packages")
     ("Czech Republic (cz.xemacs.org)" "ftp.cz.xemacs.org" "MIRRORS/ftp.xemacs.org/pub/xemacs/packages")
-    ("Denmark (dk.xemacs.org)" "ftp.dk.xemacs.org" "xemacs/packages")
     ("Finland (fi.xemacs.org)" "ftp.fi.xemacs.org" "pub/mirrors/ftp.xemacs.org/pub/tux/xemacs/packages")
     ("France (fr.xemacs.org)" "ftp.fr.xemacs.org" "pub/xemacs/packages")
     ("France (mirror.cict.fr)" "mirror.cict.fr" "xemacs/packages")
@@ -302,8 +301,6 @@
      "pub/xemacs/beta/experimental/packages")
     ("Czech Republic Pre-Releases (cz.xemacs.org)" "ftp.cz.xemacs.org"
      "MIRRORS/ftp.xemacs.org/pub/xemacs/xemacs-21.5/experimental/packages")
-    ("Denmark Pre-Releases (dk.xemacs.org)" "ftp.dk.xemacs.org"
-     "xemacs/beta/experimental/packages")
     ("Finland Pre-Releases (fi.xemacs.org)" "ftp.fi.xemacs.org"
      "pub/mirrors/ftp.xemacs.org/pub/tux/xemacs/beta/experimental/packages")
     ("France Pre-Releases (fr.xemacs.org)" "ftp.fr.xemacs.org"

--- a/lisp/unicode.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/lisp/unicode.el	Thu Dec 31 15:47:03 2009 +0000
@@ -73,6 +73,7 @@
 	    ("8859-3.TXT" latin-iso8859-3 #xA0 #xFF #x-80)
 	    ("8859-4.TXT" latin-iso8859-4 #xA0 #xFF #x-80)
 	    ("8859-5.TXT" cyrillic-iso8859-5 #xA0 #xFF #x-80)
+	    ("8859-6.TXT" arabic-iso8859-6 #xA0 #xFF #x-80)
 	    ("8859-7.TXT" greek-iso8859-7 #xA0 #xFF #x-80)
 	    ("8859-8.TXT" hebrew-iso8859-8 #xA0 #xFF #x-80)
 	    ("8859-9.TXT" latin-iso8859-9 #xA0 #xFF #x-80)

--- a/man/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/man/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,3 +1,11 @@
+2009-12-21  Jerry James  <james@xemacs.rg>
+
+	* internals/internals.texi (A Summary of the Various XEmacs Modules):
+	Remove references to OffiX support files.
+	* lispref/dragndrop.texi (Drag and Drop): Remove reference to OffiX.
+	(Supported Protocols): Ditto.
+	(OffiX DND): Remove.
+
 2009-12-10  Jerry James  <james@xemacs.org>
 
 	* lispref/processes.texi (Functions that Create Subprocesses): Refer
@@ -25,6 +33,11 @@
 	* xemacs-faq.texi (Q1.2.2: What versions of Unix does XEmacs run on?):
 	Ditto.
 
+2009-11-08  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* lispref/objects.texi (Equality Predicates): 
+	Document #'equalp here, as well as #'equal and #'eq. 
+
 2009-10-05  Jerry James  <james@xemacs.org>
 
 	* beta.texi (Building XEmacs from a full distribution): Remove

--- a/man/internals/internals.texi	Sat Dec 19 18:10:20 2009 +0000
+++ b/man/internals/internals.texi	Thu Dec 31 15:47:03 2009 +0000
@@ -3107,10 +3107,6 @@
 @item @file{objects-x.h} @tab @ref{Modules for other Display-Related Lisp Objects}.
 @item @file{objects.c} @tab @ref{Modules for other Display-Related Lisp Objects}.
 @item @file{objects.h} @tab @ref{Modules for other Display-Related Lisp Objects}.
-@item @file{offix-cursors.h} @tab
-@item @file{offix-types.h} @tab
-@item @file{offix.c} @tab
-@item @file{offix.h} @tab
 @item @file{opaque.c} @tab @ref{Modules for Other Aspects of the Lisp Interpreter and Object System}.
 @item @file{opaque.h} @tab @ref{Modules for Other Aspects of the Lisp Interpreter and Object System}.
 @item @file{paths.h.in} @tab

--- a/man/lispref/dragndrop.texi	Sat Dec 19 18:10:20 2009 +0000
+++ b/man/lispref/dragndrop.texi	Thu Dec 31 15:47:03 2009 +0000
@@ -12,9 +12,9 @@
 interface may change! The current implementation is considered experimental.
 
   Drag'n'drop is a way to transfer information between multiple applications.
-To do this several GUIs define their own protocols. Examples are OffiX, CDE,
-Motif, KDE, MSWindows, GNOME, and many more. To catch all these protocols,
-XEmacs provides a generic API.
+To do this several GUIs define their own protocols. Examples are CDE, Motif,
+KDE, MSWindows, GNOME, and many more. To catch all these protocols, XEmacs
+provides a generic API.
 
 One prime idea behind the API is to use a data interface that is
 transparent for all systems. The author thinks that this is best
@@ -35,36 +35,11 @@
 protocols. Some of these only support limited options available in the API.
 
 @menu
-* OffiX DND::           A generic X based protocol.
 * CDE dt::              Common Desktop Environment used on suns.
 * MSWindows OLE::       Mr. Gates way of live.
 * Loose ends::          The other protocols.
 @end menu
 
-@node OffiX DND
-@subsection OffiX DND
-@cindex OffiX DND
-
-@emph{WARNING}: If you compile in OffiX, you may not be able to use
-multiple X displays successfully.  If the two servers are from
-different vendors, the results may be unpredictable.
-
-The OffiX Drag'n'Drop protocol is part of a X API/Widget library created by
-Cesar Crusius. It is based on X-Atoms and ClientMessage events, and works with
-any X platform supporting them.
-
-OffiX is supported if 'offix is member of the variable dragdrop-protocols, or
-the feature 'offix is defined.
-
-Unfortunately it uses it's own data types. Examples are: File, Files,
-Exe, Link, URL, MIME. The API tries to choose the right type for the data that
-is dragged from XEmacs (well, not yet...).
-
-XEmacs supports both MIME and URL drags and drops using this API. No application
-interaction is possible while dragging is in progress.
-
-For information about the OffiX project have a look at http://leb.net/~offix/
-
 @node CDE dt
 @subsection CDE dt
 @cindex CDE dt
@@ -90,7 +65,7 @@
 @subsection Loose ends
 
 The following protocols will be supported soon: Xdnd, Motif, Xde (if I
-get some specs), KDE OffiX (if KDE can find XEmacs windows).
+get some specs).
 
 In particular Xdnd will be one of the protocols that can benefit from
 the XEmacs API, cause it also uses MIME types to encode dragged data.

--- a/man/lispref/objects.texi	Sat Dec 19 18:10:20 2009 +0000
+++ b/man/lispref/objects.texi	Thu Dec 31 15:47:03 2009 +0000
@@ -2424,3 +2424,56 @@
 
   The test for equality is implemented recursively, and circular lists may
 therefore cause infinite recursion (leading to an error).
+
+@defun equalp object1 object2
+This function is like @code{equal}, but compares characters and strings
+case-insensitively; numbers are compared using @code{=}; arrays (that
+is, strings, bit-vectors and vectors) are regarded as being
+@code{equalp} if their contents are @code{equalp}; and
+@code{hash-tables} are @code{equalp} if their values are @code{equalp}
+and they would otherwise be @code{equal}.
+
+@code{equalp} is recursive with vectors, lists and hash-tables, but not
+with other complex types.  For types without a defined @code{equalp}
+behavior, @code{equalp} behaves as @code{equal} does. 
+
+@example
+@group
+(equalp "asdf" "ASDF")
+     @result{} t
+@end group
+@group
+(equalp "asdf" [?a ?s ?D ?F])
+     @result{} t
+@end group
+@group
+(equalp "asdf" [?a ?s ?D ?F ?g])
+     @result{} nil
+@end group
+@group
+(equalp "" (bit-vector))
+     @result{} t
+@end group
+@group
+(equalp #s(hash-table) (make-hash-table))
+     @result{} t
+@end group
+@group
+(equalp #s(hash-table data (t "hi there"))
+	(let ((ht (make-hash-table)))
+	  (puthash t "HI THERE" ht)
+	  ht))
+     @result{} t
+@group
+@end group
+(equalp #s(hash-table test eq data (1.0 "hi there"))
+	(let ((ht (make-hash-table :test 'eql)))
+	  (puthash 1.0 "HI THERE" ht)
+	  ht))
+     @result{} nil
+@end group
+@end example
+@end defun
+
+@code{equalp} can also provoke an error if handed a circular structure,
+as with @code{equal}. 

--- a/nt/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/nt/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,3 +1,7 @@
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* xemacs.dsp: Remove references to OffiX files.
+
 2009-12-15  Jerry James  <james@xemacs.org>
 
 	* xemacs.mak: Remove build dependency for lib-src/wakeup.  Thanks to

--- a/nt/xemacs.dsp	Sat Dec 19 18:10:20 2009 +0000
+++ b/nt/xemacs.dsp	Thu Dec 31 15:47:03 2009 +0000
@@ -919,22 +919,6 @@
 # End Source File
 # Begin Source File
 
-SOURCE="..\src\offix-cursors.h"
-# End Source File
-# Begin Source File
-
-SOURCE="..\src\offix-types.h"
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\offix.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\offix.h
-# End Source File
-# Begin Source File
-
 SOURCE=..\src\opaque.c
 # End Source File
 # Begin Source File

--- a/src/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,8 +1,36 @@
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* config.h.in: Remove OffiX support.
+	* device-x.c: Ditto.
+	* dragdrop.c: Ditto.
+	(vars_of_dragrop): Ditto
+	* event-Xt.c: Ditto.
+	(x_event_to_emacs_event): Ditto.
+	* frame.c (vars_of_frame): Ditto
+	* frame-x.c: Ditto.
+	(Foffix_start_drag_internal): Remove.
+	(syms_of_frame_x): Remove OffiX support..
+	* Makefile.in.in: Ditto.
+	* event-gtk.c: Don't include OffiX headers.
+	* offix.c: Remove.
+	* offic.h: Remove.
+	* offix-cursors.h: Remove.
+	* offix-types.h: Remove.
+	* text.h (Qoffix_dnd_encoding): Remove, twice.
+	* depend: Regenerate.
+
+2009-11-27  Adrian Aichner  <adrian@xemacs.org>
+
+	* nt.c (mswindows_getdcwd): Check first whether drive is valid
+	with _getdrives() to avoid crash in _wgetdcwd(...) when linking
+	against msvcrt8.  This fix was taken from the Mozilla project
+	which experienced the same problem.
+
 2009-12-19  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* symbols.c (reject_constant_symbols): 
 	Indicate that accepting attempted modification of keywords is a
-	temporary thing. 
+	temporary thing.
 
 2009-12-18  Jerry James  <james@xemacs.org>
 

--- a/src/Makefile.in.in	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/Makefile.in.in	Thu Dec 31 15:47:03 2009 +0000
@@ -353,9 +353,9 @@
 
 # endif /* EXTERNAL_WIDGET */
 
-# if defined (HAVE_OFFIX_DND) || defined (HAVE_CDE)
+# if defined (HAVE_CDE)
 dnd_objs = @dnd_objs@
-# endif /* HAVE_OFFIX_DND || HAVE_CDE */
+# endif /* HAVE_CDE */
 
 X11_objs =  EmacsFrame.o EmacsShell.o TopLevelEmacsShell.o TransientEmacsShell.o EmacsManager.o $(external_widget_objs) $(dnd_objs)
 #endif /* HAVE_X_WINDOWS */

--- a/src/config.h.in	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/config.h.in	Thu Dec 31 15:47:03 2009 +0000
@@ -659,9 +659,6 @@
    Requires libDtSvc, which typically must be present at runtime.  */
 #undef HAVE_CDE
 
-/* Compile in support for OffiX Drag and Drop? */
-#undef HAVE_OFFIX_DND
-
 /* Compile in generic Drag'n'Drop API */
 #undef HAVE_DRAGNDROP
 

--- a/src/depend	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/depend	Thu Dec 31 15:47:03 2009 +0000
@@ -42,9 +42,9 @@
 balloon-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h balloon_help.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dumper.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h specifier.h symeval.h symsinit.h text.h vdb.h xintrinsic.h
 balloon_help.o: $(CONFIG_H) balloon_help.h compiler.h xintrinsic.h
 console-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dumper.h elhash.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h process.h redisplay.h specifier.h symeval.h symsinit.h text.h vdb.h xintrinsic.h
-device-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dumper.h elhash.h events.h faces.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs-x.h glyphs.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h objects-x.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysdep.h sysdll.h sysfile.h systime.h text.h vdb.h window-impl.h window.h winslots.h xgccache.h xintrinsic.h xintrinsicp.h
+device-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dumper.h elhash.h events.h faces.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs-x.h glyphs.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h objects-x.h objects.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysdep.h sysdll.h sysfile.h systime.h text.h vdb.h window-impl.h window.h winslots.h xgccache.h xintrinsic.h xintrinsicp.h
 dialog-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h buffer.h bufslots.h casetab.h charset.h chartab.h commands.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h dumper.h events.h frame-impl.h frame.h frameslots.h gc.h general-slots.h gui.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h opaque.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h systime.h text.h vdb.h window.h xintrinsic.h
-frame-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h EmacsManager.h EmacsShell.h ExternalShell.h buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h events.h extents.h faces.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs-x.h glyphs.h gutter.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h objects-impl.h objects-x-impl.h objects-x.h objects.h offix-types.h offix.h redisplay.h scrollbar-x.h scrollbar.h specifier.h symeval.h symsinit.h systime.h text.h vdb.h window-impl.h window.h winslots.h xintrinsic.h xintrinsicp.h xmotif.h xmprimitivep.h
+frame-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h EmacsManager.h EmacsShell.h ExternalShell.h buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h events.h extents.h faces.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs-x.h glyphs.h gutter.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h objects-impl.h objects-x-impl.h objects-x.h objects.h redisplay.h scrollbar-x.h scrollbar.h specifier.h symeval.h symsinit.h systime.h text.h vdb.h window-impl.h window.h winslots.h xintrinsic.h xintrinsicp.h xmotif.h xmprimitivep.h
 glyphs-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h bitmaps.h buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dumper.h faces.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs-x.h glyphs.h gui.h imgproc.h insdel.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h objects-impl.h objects-x-impl.h objects-x.h objects.h opaque.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysfile.h sysproc.h syssignal.h systime.h text.h vdb.h window-impl.h window.h winslots.h xintrinsic.h xmotif.h
 gui-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dumper.h events.h frame.h gc.h general-slots.h glyphs.h gui.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h menubar.h number-gmp.h number-mp.h number.h opaque.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h systime.h text.h vdb.h window-impl.h window.h winslots.h xintrinsic.h xmotif.h
 intl-x.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h compiler.h console-x.h console.h dumper.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h symeval.h symsinit.h text.h vdb.h xintrinsic.h
@@ -70,7 +70,7 @@
 dialog-gtk.o: $(CONFIG_H) $(LISP_H) buffer.h bufslots.h casetab.h charset.h chartab.h commands.h compiler.h conslots.h console-gtk-impl.h console-gtk.h console-impl.h console.h dumper.h events.h frame.h gc.h general-slots.h gui.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h opaque.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h systime.h text.h vdb.h window.h
 emacs-marshals.o: hash.h
 emacs-widget-accessors.o: 
-event-gtk.o: $(CONFIG_H) $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h commands.h compiler.h conslots.h console-gtk-impl.h console-gtk.h console-impl.h console-tty.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h elhash.h event-gtk.h event-xlike-inc.c events.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h gtk-xemacs.h gui.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h menubar.h number-gmp.h number-mp.h number.h objects-gtk.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysproc.h syssignal.h systime.h systty.h text.h vdb.h window.h xintrinsic.h
+event-gtk.o: $(CONFIG_H) $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h commands.h compiler.h conslots.h console-gtk-impl.h console-gtk.h console-impl.h console-tty.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h elhash.h event-gtk.h event-xlike-inc.c events.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h gtk-xemacs.h gui.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h menubar.h number-gmp.h number-mp.h number.h objects-gtk.h objects.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysproc.h syssignal.h systime.h systty.h text.h vdb.h window.h
 frame-gtk.o: $(CONFIG_H) $(LISP_H) buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-gtk-impl.h console-gtk.h console-impl.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h elhash.h events.h extents.h faces.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs-gtk.h glyphs.h gtk-xemacs.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h objects-gtk-impl.h objects-gtk.h objects-impl.h objects.h redisplay.h scrollbar-gtk.h scrollbar.h specifier.h symeval.h symsinit.h sysdll.h systime.h text.h ui-gtk.h vdb.h window-impl.h window.h winslots.h
 gccache-gtk.o: $(CONFIG_H) $(LISP_H) compiler.h dumper.h gc.h gccache-gtk.h general-slots.h hash.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h symeval.h symsinit.h text.h vdb.h
 glade.o: bytecode.h
@@ -138,7 +138,7 @@
 emodules.o: $(CONFIG_H) $(LISP_H) buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h compiler.h console.h dumper.h emodules.h file-coding.h frame.h gc.h general-slots.h insdel.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h redisplay.h scrollbar.h symeval.h symsinit.h sysdep.h sysdll.h text.h vdb.h window.h
 esd.o: $(CONFIG_H) $(LISP_H) buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h dumper.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h miscplay.h number-gmp.h number-mp.h number.h sound.h symeval.h symsinit.h sysfile.h text.h vdb.h
 eval.o: $(CONFIG_H) $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h charset.h chartab.h commands.h compiler.h conslots.h console-impl.h console.h device.h dumper.h frame.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h opaque.h profile.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h text.h vdb.h window.h
-event-Xt.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h Emacs.ad.h EmacsFrame.h blocktype.h charset.h coding-system-slots.h compiler.h conslots.h console-impl.h console-tty.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h elhash.h event-xlike-inc.c events.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h objects-x.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysproc.h syssignal.h systime.h systty.h text.h vdb.h window-impl.h window.h winslots.h xintrinsic.h xintrinsicp.h xmotif.h
+event-Xt.o: $(CONFIG_H) $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h Emacs.ad.h EmacsFrame.h blocktype.h charset.h coding-system-slots.h compiler.h conslots.h console-impl.h console-tty.h console-x-impl.h console-x.h console.h device-impl.h device.h devslots.h dragdrop.h dumper.h elhash.h event-xlike-inc.c events.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h objects-x.h objects.h process.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysproc.h syssignal.h systime.h systty.h text.h vdb.h window-impl.h window.h winslots.h xintrinsic.h xintrinsicp.h xmotif.h
 event-stream.o: $(CONFIG_H) $(LISP_H) backtrace.h blocktype.h buffer.h bufslots.h casetab.h charset.h chartab.h coding-system-slots.h commands.h compiler.h conslots.h console-impl.h console.h device-impl.h device.h devslots.h dumper.h elhash.h events.h file-coding.h frame-impl.h frame.h frameslots.h gc.h general-slots.h gui.h insdel.h keymap.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h macros.h mc-alloc.h menubar.h number-gmp.h number-mp.h number.h process.h profile.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h sysdep.h sysfile.h syssignal.h systime.h text.h vdb.h window-impl.h window.h winslots.h
 event-unixoid.o: $(CONFIG_H) $(LISP_H) compiler.h conslots.h console-impl.h console-stream-impl.h console-stream.h console-tty-impl.h console-tty.h console.h device-impl.h device.h devslots.h dumper.h events.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h process.h specifier.h symeval.h symsinit.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h text.h vdb.h
 events.o: $(CONFIG_H) $(LISP_H) buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-tty-impl.h console-tty.h console.h device.h dumper.h events.h extents.h frame-impl.h frame.h frameslots.h gc.h general-slots.h glyphs.h keymap.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h systime.h systty.h text.h toolbar.h vdb.h window-impl.h window.h winslots.h
@@ -200,7 +200,6 @@
 number-mp.o: $(CONFIG_H) $(LISP_H) compiler.h dumper.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h symeval.h symsinit.h text.h vdb.h
 number.o: $(CONFIG_H) $(LISP_H) compiler.h dumper.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h symeval.h symsinit.h text.h vdb.h
 objects.o: $(CONFIG_H) $(LISP_H) buffer.h bufslots.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-tty.h console.h device-impl.h device.h devslots.h dumper.h elhash.h faces.h frame.h gc.h general-slots.h glyphs.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h objects-impl.h objects.h redisplay.h scrollbar.h specifier.h symeval.h symsinit.h systty.h text.h vdb.h window-impl.h window.h winslots.h
-offix.o: offix-cursors.h offix-types.h offix.h xintrinsic.h
 opaque.o: $(CONFIG_H) $(LISP_H) compiler.h dumper.h gc.h general-slots.h lisp-disunion.h lisp-union.h lisp.h lrecord.h mc-alloc.h number-gmp.h number-mp.h number.h opaque.h symeval.h symsinit.h text.h vdb.h
 print.o: $(CONFIG_H) $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h charset.h chartab.h compiler.h conslots.h console-impl.h console-msw.h console-stream-impl.h console-stream.h console-tty-impl.h console-tty.h console.h device-impl.h device.h devslots.h dumper.h extents.h frame.h gc.h general-slots.h insdel.h intl-auto-encap-win32.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h opaque.h redisplay.h specifier.h symeval.h symsinit.h sysfile.h systty.h syswindows.h text.h vdb.h
 process-nt.o: $(CONFIG_H) $(LISP_H) compiler.h console-msw.h console.h dumper.h events.h gc.h general-slots.h hash.h intl-auto-encap-win32.h lisp-disunion.h lisp-union.h lisp.h lrecord.h lstream.h mc-alloc.h number-gmp.h number-mp.h number.h process-slots.h process.h procimpl.h symeval.h symsinit.h sysfile.h sysproc.h syssignal.h systime.h syswindows.h text.h vdb.h

--- a/src/device-x.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/device-x.c	Thu Dec 31 15:47:03 2009 +0000
@@ -61,10 +61,6 @@
 #include "sysdll.h"
 #endif /* HAVE_SHLIB and LWLIB_USES_ATHENA and not HAVE_ATHENA_3D */
 
-#ifdef HAVE_OFFIX_DND
-#include "offix.h"
-#endif
-
 Lisp_Object Vx_app_defaults_directory;
 #ifdef MULE
 Lisp_Object Qget_coding_system_from_locale;
@@ -910,11 +906,6 @@
   }
 #endif /* HAVE_WMCOMMAND */
 
-
-#ifdef HAVE_OFFIX_DND
-  DndInitialize (app_shell);
-#endif
-
   Vx_initial_argv_list = make_arg_list (argc, argv);
   free_argc_argv (argv);
 

--- a/src/dragdrop.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/dragdrop.c	Thu Dec 31 15:47:03 2009 +0000
@@ -26,8 +26,6 @@
 
 /* A short introduction to the new Drag'n'Drop Model:
 
-   Currently only drops from OffiX are implemented.
-
    A drop generates a extended misc-user-event, as defined in events.[ch].
    This event contains the same as a eval and a button event.
    The function of a drop is set to 'dragdrop-drop-dispatch' which will be
@@ -137,9 +135,6 @@
 #ifdef HAVE_CDE
   Vdragdrop_protocols = Fcons (intern ("cde"), Vdragdrop_protocols);
 #endif
-#ifdef HAVE_OFFIX_DND
-  Vdragdrop_protocols = Fcons (intern ("offix"), Vdragdrop_protocols);
-#endif
 #ifdef HAVE_GTK
   Vdragdrop_protocols = Fcons (Qgtk, Vdragdrop_protocols);
 #endif

--- a/src/event-Xt.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/event-Xt.c	Thu Dec 31 15:47:03 2009 +0000
@@ -63,10 +63,6 @@
 #include "dragdrop.h"
 #endif
 
-#if defined (HAVE_OFFIX_DND)
-#include "offix.h"
-#endif
-
 #ifdef WIN32_ANY
 extern int mswindows_is_blocking;
 #endif
@@ -1317,135 +1313,7 @@
            passed as the timestamp of the TAKE_FOCUS, which the ICCCM
            explicitly prohibits. */
         XClientMessageEvent *ev = &x_event->xclient;
-#ifdef HAVE_OFFIX_DND
-	if (DndIsDropMessage (x_event))
-	  {
-	    unsigned int state;
-	    int modifiers = 0;
-	    int button = 0;
-	    struct frame *frame = x_any_window_to_frame (d, ev->window);
-	    Extbyte *data;
-	    unsigned long size, dtype;
-	    Lisp_Object l_type = Qnil, l_data = Qnil;
-	    Lisp_Object l_dndlist = Qnil, l_item = Qnil;
-	    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-
-	    if (! frame)
-	      return 0;	/* not for us */
-
-	    GCPRO4 (l_type, l_data, l_dndlist, l_item);
-	    set_event_type (emacs_event, misc_user_event);
-	    SET_EVENT_CHANNEL (emacs_event, wrap_frame (frame));
-	    SET_EVENT_TIMESTAMP (emacs_event,
-				 DEVICE_X_LAST_SERVER_TIMESTAMP (d));
-	    state=DndDragButtons (x_event);
-
-	    if (state & ShiftMask)	modifiers |= XEMACS_MOD_SHIFT;
-	    if (state & ControlMask)	modifiers |= XEMACS_MOD_CONTROL;
-	    if (state & xd->MetaMask)	modifiers |= XEMACS_MOD_META;
-	    if (state & xd->SuperMask)	modifiers |= XEMACS_MOD_SUPER;
-	    if (state & xd->HyperMask)	modifiers |= XEMACS_MOD_HYPER;
-	    if (state & xd->AltMask)	modifiers |= XEMACS_MOD_ALT;
-	    if (state & Button1Mask)	modifiers |= XEMACS_MOD_BUTTON1;
-	    if (state & Button2Mask)	modifiers |= XEMACS_MOD_BUTTON2;
-	    if (state & Button3Mask)	modifiers |= XEMACS_MOD_BUTTON3;
-	    if (state & Button4Mask)	modifiers |= XEMACS_MOD_BUTTON4;
-	    if (state & Button5Mask)	modifiers |= XEMACS_MOD_BUTTON5;
-
-	    if (state & Button5Mask)    button = Button5;
-	    if (state & Button4Mask)    button = Button4;
-	    if (state & Button3Mask)    button = Button3;
-	    if (state & Button2Mask)    button = Button2;
-	    if (state & Button1Mask)    button = Button1;
-
-	    SET_EVENT_MISC_USER_MODIFIERS (emacs_event, modifiers);
-	    SET_EVENT_MISC_USER_BUTTON (emacs_event, button);
-
-	    DndDropCoordinates (FRAME_X_TEXT_WIDGET (frame), x_event,
-				&(EVENT_MISC_USER_X (emacs_event)),
-				&(EVENT_MISC_USER_Y (emacs_event)));
-	    DndGetData (x_event, &data, &size);
-
-	    dtype = DndDataType (x_event);
-	    switch (dtype)
-	      {
-	      case DndFiles: /* null terminated strings, end null */
-		{
-		  int len;
-		  Ibyte *hurl = NULL;
-
-		  while (*data)
-		    {
-		      Ibyte *dataint;
-		      len = strlen (data);
-		      EXTERNAL_TO_C_STRING (data, dataint, Qfile_name);
-		      hurl = dnd_url_hexify_string (dataint,
-						    (const Ibyte *) "file:");
-		      l_item = build_intstring (hurl);
-		      l_dndlist = Fcons (l_item, l_dndlist);
-		      data += len + 1;
-		      xfree (hurl, Ibyte *);
-		    }
-		  l_type = Qdragdrop_URL;
-		}
-		break;
-	      case DndText:
-		l_type = Qdragdrop_MIME;
-		l_dndlist = list1 (list3 (list1 (build_string ("text/plain")),
-					  build_string ("8bit"),
-					  build_ext_string (data,
-							    Qctext)));
-		break;
-	      case DndMIME:
-		/* we have to parse this in some way to extract
-		   content-type and params (in the tm way) and
-		   content encoding.
-		   OR: if data is string, let tm do the job
-		       if data is list[2], give the first two
-		       to tm...
-		*/
-		l_type = Qdragdrop_MIME;
-		l_dndlist = list1 (build_ext_string (data, Qbinary));
-		break;
-	      case DndFile:
-	      case DndDir:
-	      case DndLink:
-	      case DndExe:
-		{
-		  Ibyte *dataint, *hurl;
-		  EXTERNAL_TO_C_STRING (data, dataint, Qfile_name);
-		  hurl = dnd_url_hexify_string (dataint, "file:");
-		  l_dndlist = list1 (build_intstring (hurl));
-		  xfree (hurl, Ibyte *);
-		}
-		break;
-	      case DndURL:
-		/* as it is a real URL it should already be escaped
-		   and escaping again will break them (cause % is unsave) */
-		l_dndlist = list1 (build_ext_string (data,
-						     Qfile_name));
-		l_type = Qdragdrop_URL;
-		break;
-	      default: /* Unknown, RawData and any other type */
-		l_dndlist = list1 (list3 (list1 (build_string
-						 ("application/octet-stream")),
-					  build_string ("8bit"),
-					  make_ext_string (data, size,
-							   Qbinary)));
-		l_type = Qdragdrop_MIME;
-		break;
-	      }
-
-	    SET_EVENT_MISC_USER_FUNCTION (emacs_event,
-					  Qdragdrop_drop_dispatch);
-	    SET_EVENT_MISC_USER_OBJECT (emacs_event,
-					Fcons (l_type, l_dndlist));
-
-	    UNGCPRO;
-
-	    break;
-	  }
-#endif /* HAVE_OFFIX_DND */
+
         if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d)
             && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d)
             && (Atom) (ev->data.l[1]) == 0)

--- a/src/event-gtk.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/event-gtk.c	Thu Dec 31 15:47:03 2009 +0000
@@ -62,10 +62,6 @@
 # include "menubar.h"
 #endif
 
-#if defined (HAVE_OFFIX_DND)
-#include "offix.h"
-#endif
-
 #include <gdk/gdkx.h>
 
 #include "event-gtk.h"

--- a/src/frame-x.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/frame-x.c	Thu Dec 31 15:47:03 2009 +0000
@@ -60,10 +60,6 @@
 #include "dragdrop.h"
 #endif
 
-#ifdef HAVE_OFFIX_DND
-#include "offix.h"
-#endif
-
 /* Default properties to use when creating frames.  */
 Lisp_Object Vdefault_x_frame_plist;
 
@@ -1002,7 +998,7 @@
   frame_title_format_already_set = 1;
 }
 
-#if defined (HAVE_CDE) || defined (HAVE_OFFIX_DND)
+#if defined (HAVE_CDE)
 
 static Extbyte *
 start_drag_internal_1 (Lisp_Object event, Lisp_Object data,
@@ -1095,7 +1091,7 @@
   return dnd_data;
 }
 
-#endif /* defined (HAVE_CDE) || defined (HAVE_OFFIX_DND) */
+#endif /* defined (HAVE_CDE) */
 
 #ifdef HAVE_CDE
 #include <Dt/Dt.h>
@@ -1333,46 +1329,6 @@
 }
 #endif /* HAVE_CDE */
 
-#ifdef HAVE_OFFIX_DND
-
-DEFUN ("offix-start-drag-internal", Foffix_start_drag_internal, 2, 3, 0, /*
-Start a OffiX drag from a buffer.
-First arg is the event that started the drag,
-second arg should be some string, and the third
-is the type of the data (this should be an int).
-The type defaults to DndText (4).
-*/
-       (event, data, dtyp))
-{
-  Extbyte *dnd_data;
-  XEvent x_event;
-  Bytecount dnd_len;
-  Widget wid;
-  int num_items;
-  int dnd_type = DndText;
-
-  if (!NILP (dtyp))
-    {
-      CHECK_INT (dtyp);
-      dnd_type = XINT (dtyp);
-    }
-
-  dnd_data = start_drag_internal_1 (event, data, Qoffix_dnd_encoding,
-				    &x_event, dnd_type == DndFiles,
-				    &wid, &dnd_len, &num_items);
-
-  DndSetData (dnd_type, (UExtbyte *) dnd_data, dnd_len);
-  xfree (dnd_data, Extbyte *);
-
-  /* the next thing blocks everything... */
-  if (DndHandleDragging (wid, &x_event))
-    return Qt;
-
-  return Qnil;
-}
-
-#endif /* HAVE_OFFIX_DND */
-
 
 /************************************************************************/
 /*				widget creation				*/
@@ -2811,9 +2767,6 @@
 #ifdef HAVE_CDE
   DEFSUBR (Fcde_start_drag_internal);
 #endif
-#ifdef HAVE_OFFIX_DND
-  DEFSUBR (Foffix_start_drag_internal);
-#endif
 }
 
 void

--- a/src/frame.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/frame.c	Thu Dec 31 15:47:03 2009 +0000
@@ -3751,10 +3751,6 @@
   Fprovide (intern ("cde"));
 #endif
 
-#ifdef HAVE_OFFIX_DND
-  Fprovide (intern ("offix"));
-#endif
-
 #if 0 /* FSFmacs stupidity */
   xxDEFVAR_LISP ("emacs-iconified", &Vemacs_iconified /*
 Non-nil if all of emacs is iconified and frame updates are not needed.

--- a/src/nt.c	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/nt.c	Thu Dec 31 15:47:03 2009 +0000
@@ -1815,7 +1815,27 @@
 {
   Extbyte *cwdext;
   Ibyte *cwd;
-
+  /* Following comment and two-liner fix comes from
+     https://bugzilla.mozilla.org/show_bug.cgi?id=419326 which
+     apparently fell prey to this feature of msvcrt8 as well. */
+  /* We need to worry about IPH, for details read bug 419326.
+   * _getdrives - http://msdn2.microsoft.com/en-us/library/xdhk0xd2.aspx 
+   * uses a bitmask, bit 0 is 'a:'
+   * _chdrive - http://msdn2.microsoft.com/en-us/library/0d1409hb.aspx
+   * _getdcwd - http://msdn2.microsoft.com/en-us/library/7t2zk3s4.aspx
+   * take an int, 1 is 'a:'.
+   *
+   * Because of this, we need to do some math. Subtract 1 to convert from
+   * _chdrive/_getdcwd format to _getdrives drive numbering.
+   * Shift left x bits to convert from integer indexing to bitfield indexing.
+   * And of course, we need to find out if the drive is in the bitmask.
+   *
+   * If we're really unlucky, we can still lose, but only if the user
+   * manages to eject the drive between our call to _getdrives() and
+   * our *calls* to _wgetdcwd.
+   */
+  if (!((1 << (drivelet - 1)) & _getdrives()))
+    return NULL;
   if (XEUNICODE_P)
     cwdext = (Extbyte *) _wgetdcwd (drivelet, NULL, 0);
   else

--- a/src/offix-cursors.h	Sat Dec 19 18:10:20 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,346 +0,0 @@
-#define app_width 42
-#define app_height 32
-#define app_x_hot 1
-#define app_y_hot 1
-static unsigned char app_bits[] = {
-   0x00, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x02, 0x40, 0x00, 0x80, 0x01, 0x00,
-   0x06, 0x40, 0x00, 0x80, 0x02, 0x00, 0x0e, 0x40, 0x00, 0x80, 0x04, 0x00,
-   0x1e, 0x40, 0x00, 0x80, 0x08, 0x00, 0x3e, 0x40, 0x00, 0x80, 0x10, 0x00,
-   0x7e, 0x40, 0x00, 0x80, 0x20, 0x00, 0xfe, 0x40, 0x00, 0x80, 0x7f, 0x00,
-   0xfe, 0x41, 0x00, 0x00, 0x60, 0x00, 0x3e, 0x40, 0xfe, 0xff, 0x67, 0x00,
-   0x36, 0x40, 0xaa, 0xaa, 0x6e, 0x00, 0x62, 0x40, 0x56, 0x55, 0x6d, 0x00,
-   0x60, 0x40, 0xfe, 0xff, 0x6f, 0x00, 0xc0, 0x40, 0x02, 0x00, 0x6c, 0x00,
-   0xc0, 0x40, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x40, 0x02, 0x00, 0x6c, 0x00,
-   0x00, 0x40, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x40, 0x02, 0x00, 0x6c, 0x00,
-   0x00, 0x40, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x40, 0x02, 0x00, 0x6c, 0x00,
-   0x00, 0x40, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x40, 0x02, 0x00, 0x6c, 0x00,
-   0x00, 0x40, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x40, 0x02, 0x00, 0x6c, 0x00,
-   0x00, 0x40, 0x02, 0x00, 0x6c, 0x00, 0x00, 0x40, 0xfe, 0xff, 0x6f, 0x00,
-   0x00, 0x40, 0xfc, 0xff, 0x6f, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define app_mask_width 42
-#define app_mask_height 32
-#define app_mask_x_hot 1
-#define app_mask_y_hot 1
-static unsigned char app_mask_bits[] = {
-   0x03, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x07, 0xc0, 0xff, 0xff, 0x01, 0x00,
-   0x0f, 0xc0, 0xff, 0xff, 0x03, 0x00, 0x1f, 0xc0, 0xff, 0xff, 0x07, 0x00,
-   0x3f, 0xc0, 0xff, 0xff, 0x0f, 0x00, 0x7f, 0xc0, 0xff, 0xff, 0x1f, 0x00,
-   0xff, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00,
-   0x7f, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xf7, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0xf3, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00, 0xc0, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define cursor_width 10
-#define cursor_height 16
-#define cursor_x_hot 0
-#define cursor_y_hot 0
-#if 0 /* unused */
-static unsigned char cursor_bits[] = {
-   0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x1e, 0x00, 0x3e, 0x00,
-   0x7e, 0x00, 0xfe, 0x00, 0xfe, 0x01, 0x3e, 0x00, 0x36, 0x00, 0x62, 0x00,
-   0x60, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00};
-#endif /* unused */
-#define dir_width 42
-#define dir_height 24
-#define dir_x_hot 1
-#define dir_y_hot 1
-static unsigned char dir_bits[] = {
-   0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x02, 0x80, 0x00, 0x02, 0x00, 0x00,
-   0x06, 0x40, 0x00, 0x04, 0x00, 0x00, 0x0e, 0x20, 0x00, 0x08, 0x00, 0x00,
-   0x1e, 0xf0, 0xff, 0xff, 0xff, 0x03, 0x3e, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x7e, 0x10, 0x00, 0x00, 0x00, 0x02, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0xfe, 0x11, 0x00, 0x00, 0x00, 0x02, 0x3e, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x36, 0x10, 0x00, 0x00, 0x00, 0x02, 0x62, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x60, 0x10, 0x00, 0x00, 0x00, 0x02, 0xc0, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0xc0, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02,
-   0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x03};
-#define dir_mask_width 42
-#define dir_mask_height 24
-#define dir_mask_x_hot 1
-#define dir_mask_y_hot 1
-static unsigned char dir_mask_bits[] = {
-   0x03, 0x00, 0xff, 0x01, 0x00, 0x00, 0x07, 0x80, 0xff, 0x03, 0x00, 0x00,
-   0x0f, 0xc0, 0xff, 0x07, 0x00, 0x00, 0x1f, 0xe0, 0xff, 0x0f, 0x00, 0x00,
-   0x3f, 0xf0, 0xff, 0xff, 0xff, 0x03, 0x7f, 0xf0, 0xff, 0xff, 0xff, 0x03,
-   0xff, 0xf0, 0xff, 0xff, 0xff, 0x03, 0xff, 0xf1, 0xff, 0xff, 0xff, 0x03,
-   0xff, 0xf3, 0xff, 0xff, 0xff, 0x03, 0xff, 0xf3, 0xff, 0xff, 0xff, 0x03,
-   0x7f, 0xf0, 0xff, 0xff, 0xff, 0x03, 0xf7, 0xf0, 0xff, 0xff, 0xff, 0x03,
-   0xf3, 0xf0, 0xff, 0xff, 0xff, 0x03, 0xe0, 0xf1, 0xff, 0xff, 0xff, 0x03,
-   0xe0, 0xf1, 0xff, 0xff, 0xff, 0x03, 0xc0, 0xf0, 0xff, 0xff, 0xff, 0x03,
-   0x00, 0xf0, 0xff, 0xff, 0xff, 0x03, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x03,
-   0x00, 0xf0, 0xff, 0xff, 0xff, 0x03, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x03,
-   0x00, 0xf0, 0xff, 0xff, 0xff, 0x03, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x03,
-   0x00, 0xf0, 0xff, 0xff, 0xff, 0x03, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x03};
-#define file_width 42
-#define file_height 32
-#define file_x_hot 1
-#define file_y_hot 1
-static unsigned char file_bits[] = {
-   0x00, 0xc0, 0xff, 0xff, 0x07, 0x00, 0x02, 0x40, 0x00, 0x00, 0x0a, 0x00,
-   0x06, 0x40, 0x00, 0x00, 0x12, 0x00, 0x0e, 0x40, 0x00, 0x00, 0x22, 0x00,
-   0x1e, 0x40, 0x00, 0x00, 0x3e, 0x00, 0x3e, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x7e, 0x40, 0x00, 0x00, 0x20, 0x00, 0xfe, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0xfe, 0x41, 0x00, 0x00, 0x20, 0x00, 0x3e, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x36, 0x40, 0x00, 0x00, 0x20, 0x00, 0x62, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x60, 0x40, 0x00, 0x00, 0x20, 0x00, 0xc0, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0xc0, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-#define file_mask_width 42
-#define file_mask_height 32
-#define file_mask_x_hot 1
-#define file_mask_y_hot 1
-static unsigned char file_mask_bits[] = {
-   0x03, 0xc0, 0xff, 0xff, 0x07, 0x00, 0x07, 0xc0, 0xff, 0xff, 0x0f, 0x00,
-   0x0f, 0xc0, 0xff, 0xff, 0x1f, 0x00, 0x1f, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x3f, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x7f, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0xff, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xc1, 0xff, 0xff, 0x3f, 0x00,
-   0xff, 0xc3, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xc3, 0xff, 0xff, 0x3f, 0x00,
-   0x7f, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0xf7, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0xf3, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0xe0, 0xc1, 0xff, 0xff, 0x3f, 0x00,
-   0xe0, 0xc1, 0xff, 0xff, 0x3f, 0x00, 0xc0, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-#define files_width 42
-#define files_height 32
-#define files_x_hot 1
-#define files_y_hot 1
-static unsigned char files_bits[] = {
-   0x00, 0xf8, 0xff, 0xff, 0x01, 0x00, 0x02, 0x08, 0x00, 0x80, 0x02, 0x00,
-   0x06, 0x08, 0x00, 0x80, 0x04, 0x00, 0x0e, 0x08, 0x00, 0x80, 0x08, 0x00,
-   0x1e, 0x08, 0x00, 0x80, 0x1f, 0x00, 0x3e, 0x08, 0x00, 0x00, 0x28, 0x00,
-   0x7e, 0x08, 0x00, 0x00, 0x78, 0x00, 0xfe, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0xfe, 0x09, 0x00, 0x00, 0xe8, 0x00, 0x3e, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x36, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x62, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x60, 0x08, 0x00, 0x00, 0xa8, 0x00, 0xc0, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0xc0, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x00, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x00, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x00, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x00, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x00, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x08, 0x00, 0x00, 0xa8, 0x00,
-   0x00, 0x08, 0x00, 0x00, 0xa8, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xaf, 0x00,
-   0x00, 0x10, 0x00, 0x00, 0xa0, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xbf, 0x00,
-   0x00, 0x20, 0x00, 0x00, 0x80, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0x00};
-#define files_mask_width 42
-#define files_mask_height 32
-#define files_mask_x_hot 1
-#define files_mask_y_hot 1
-static unsigned char files_mask_bits[] = {
-   0x03, 0xf8, 0xff, 0xff, 0x01, 0x00, 0x07, 0xf8, 0xff, 0xff, 0x03, 0x00,
-   0x0f, 0xf8, 0xff, 0xff, 0x07, 0x00, 0x1f, 0xf8, 0xff, 0xff, 0x0f, 0x00,
-   0x3f, 0xf8, 0xff, 0xff, 0x1f, 0x00, 0x7f, 0xf8, 0xff, 0xff, 0x3f, 0x00,
-   0xff, 0xf8, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xf9, 0xff, 0xff, 0xff, 0x00,
-   0xff, 0xfb, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfb, 0xff, 0xff, 0xff, 0x00,
-   0x7f, 0xf8, 0xff, 0xff, 0xff, 0x00, 0xf7, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0xf3, 0xf8, 0xff, 0xff, 0xff, 0x00, 0xe0, 0xf9, 0xff, 0xff, 0xff, 0x00,
-   0xe0, 0xf9, 0xff, 0xff, 0xff, 0x00, 0xc0, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf8, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf8, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf8, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf8, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf8, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf8, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0xe0, 0xff, 0xff, 0xff, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0x00};
-#define grey_width 42
-#define grey_height 32
-#define grey_x_hot 1
-#define grey_y_hot 1
-static unsigned char grey_bits[] = {
-   0x00, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x02, 0x40, 0x55, 0xd5, 0x01, 0x00,
-   0x06, 0xc0, 0xaa, 0xaa, 0x03, 0x00, 0x0e, 0x40, 0x55, 0xd5, 0x07, 0x00,
-   0x1e, 0xc0, 0xaa, 0xaa, 0x0f, 0x00, 0x3e, 0x40, 0x55, 0xd5, 0x1f, 0x00,
-   0x7e, 0xc0, 0xaa, 0xaa, 0x3f, 0x00, 0xfe, 0x40, 0x55, 0xd5, 0x7f, 0x00,
-   0xfe, 0xc1, 0xaa, 0xaa, 0x7f, 0x00, 0x3e, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x36, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x72, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x60, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0xc0, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0xc0, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xaa, 0xaa, 0x6a, 0x00, 0x00, 0x40, 0x55, 0x55, 0x75, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define grey_mask_width 42
-#define grey_mask_height 32
-#define grey_mask_x_hot 1
-#define grey_mask_y_hot 1
-static unsigned char grey_mask_bits[] = {
-   0x03, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x07, 0xc0, 0xff, 0xff, 0x01, 0x00,
-   0x0f, 0xc0, 0xff, 0xff, 0x03, 0x00, 0x1f, 0xc0, 0xff, 0xff, 0x07, 0x00,
-   0x3f, 0xc0, 0xff, 0xff, 0x0f, 0x00, 0x7f, 0xc0, 0xff, 0xff, 0x1f, 0x00,
-   0xff, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00,
-   0x7f, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0xf3, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00, 0xc0, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define link_width 42
-#define link_height 32
-#define link_x_hot 1
-#define link_y_hot 1
-static unsigned char link_bits[] = {
-   0x00, 0xc0, 0xff, 0xff, 0x01, 0x00, 0x02, 0x40, 0x00, 0x00, 0x03, 0x00,
-   0x06, 0x40, 0x00, 0x00, 0x05, 0x00, 0x0e, 0x40, 0x00, 0x00, 0x09, 0x00,
-   0x1e, 0x40, 0x00, 0x00, 0x11, 0x00, 0x3e, 0x40, 0x00, 0x00, 0x21, 0x00,
-   0x7e, 0x40, 0x00, 0x00, 0x7f, 0x00, 0xfe, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0xfe, 0x41, 0x00, 0x00, 0x60, 0x00, 0x3e, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x36, 0xc0, 0xc3, 0x1f, 0x7e, 0x00, 0x62, 0x40, 0xa5, 0x2a, 0x75, 0x00,
-   0x60, 0xc0, 0xdb, 0xdf, 0x7e, 0x00, 0xc0, 0x40, 0xff, 0xf8, 0x67, 0x00,
-   0xc0, 0xc0, 0x55, 0xad, 0x6a, 0x00, 0x00, 0xc0, 0xaa, 0x55, 0x6d, 0x00,
-   0x00, 0x40, 0xff, 0xf8, 0x67, 0x00, 0x00, 0xc0, 0xdb, 0xdf, 0x7e, 0x00,
-   0x00, 0x40, 0xa5, 0x2a, 0x75, 0x00, 0x00, 0xc0, 0xc3, 0x1f, 0x7e, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x60, 0x00, 0x00, 0x40, 0x88, 0x52, 0x62, 0x00,
-   0x00, 0x40, 0x88, 0x56, 0x61, 0x00, 0x00, 0x40, 0x88, 0xda, 0x60, 0x00,
-   0x00, 0x40, 0x88, 0x52, 0x61, 0x00, 0x00, 0x40, 0xb8, 0x52, 0x62, 0x00,
-   0x00, 0x40, 0x00, 0x00, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define link_mask_width 42
-#define link_mask_height 32
-#define link_mask_x_hot 1
-#define link_mask_y_hot 1
-static unsigned char link_mask_bits[] = {
-   0x03, 0xc0, 0xff, 0xff, 0x01, 0x00, 0x07, 0xc0, 0xff, 0xff, 0x03, 0x00,
-   0x0f, 0xc0, 0xff, 0xff, 0x07, 0x00, 0x1f, 0xc0, 0xff, 0xff, 0x0f, 0x00,
-   0x3f, 0xc0, 0xff, 0xff, 0x1f, 0x00, 0x7f, 0xc0, 0xff, 0xff, 0x3f, 0x00,
-   0xff, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00,
-   0x7f, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xf7, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0xf3, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00, 0xc0, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define mime_width 30
-#define mime_height 20
-#define mime_x_hot 1
-#define mime_y_hot 1
-static unsigned char mime_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, 0x06, 0x00, 0x80, 0x01,
-   0x0e, 0x00, 0x00, 0x00, 0x1e, 0xb0, 0x99, 0x01, 0x3e, 0x70, 0xb7, 0x01,
-   0x7e, 0x30, 0xb3, 0x01, 0xfe, 0x30, 0xb3, 0x01, 0xfe, 0x31, 0xb3, 0x01,
-   0x3e, 0x30, 0xb3, 0x01, 0x36, 0x30, 0xb3, 0x01, 0x62, 0x00, 0x00, 0x00,
-   0x60, 0xb0, 0x19, 0x0f, 0xc0, 0x70, 0xb7, 0x19, 0xc0, 0x30, 0xb3, 0x19,
-   0x00, 0x30, 0xb3, 0x1f, 0x00, 0x30, 0xb3, 0x01, 0x00, 0x30, 0xb3, 0x11,
-   0x00, 0x30, 0x33, 0x0f, 0x00, 0x00, 0x00, 0x00};
-#define mime_mask_width 30
-#define mime_mask_height 20
-static unsigned char mime_mask_bits[] = {
-   0x03, 0x00, 0x80, 0x01, 0x07, 0x00, 0xc0, 0x03, 0x0f, 0x00, 0xc0, 0x03,
-   0x1f, 0xb8, 0x99, 0x01, 0x3f, 0xf8, 0xff, 0x03, 0x7f, 0xf8, 0xff, 0x03,
-   0xff, 0xf8, 0xff, 0x03, 0xff, 0xf9, 0xff, 0x03, 0xff, 0xfb, 0xff, 0x03,
-   0xff, 0xf9, 0xff, 0x03, 0x7f, 0xf8, 0xff, 0x03, 0xf7, 0xf8, 0xff, 0x0f,
-   0xf3, 0xf8, 0xff, 0x1f, 0xe0, 0xf9, 0xff, 0x3f, 0xe0, 0xf9, 0xff, 0x3f,
-   0xc0, 0xf8, 0xff, 0x3f, 0x00, 0xf8, 0xff, 0x3f, 0x00, 0xf8, 0xff, 0x3f,
-   0x00, 0xf8, 0xff, 0x1f, 0x00, 0xf8, 0xff, 0x0f};
-#define text_width 42
-#define text_height 32
-#define text_x_hot 1
-#define text_y_hot 1
-static unsigned char text_bits[] = {
-   0x00, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x02, 0x40, 0x00, 0x80, 0x01, 0x00,
-   0x06, 0x40, 0x00, 0x80, 0x02, 0x00, 0x0e, 0x40, 0xde, 0xbd, 0x04, 0x00,
-   0x1e, 0x40, 0x00, 0x80, 0x08, 0x00, 0x3e, 0x40, 0x00, 0x80, 0x10, 0x00,
-   0x7e, 0x40, 0xb8, 0xef, 0x20, 0x00, 0xfe, 0x40, 0x00, 0x80, 0x7f, 0x00,
-   0xfe, 0x41, 0xfe, 0xf6, 0x64, 0x00, 0x3e, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x36, 0x40, 0xf6, 0xce, 0x67, 0x00, 0x62, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x60, 0x40, 0xba, 0xfb, 0x60, 0x00, 0xc0, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0xc0, 0x40, 0x00, 0x00, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0x14, 0x3b, 0x63, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0xf4, 0xba, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0x74, 0x07, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0xff, 0xf6, 0x67, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0xf7, 0x7d, 0x66, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0xdf, 0xef, 0x63, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0x40, 0x00, 0x06, 0x60, 0x00, 0x00, 0x40, 0x00, 0x00, 0x60, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define text_mask_width 42
-#define text_mask_height 32
-#define text_mask_x_hot 1
-#define text_mask_y_hot 1
-static unsigned char text_mask_bits[] = {
-   0x03, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x07, 0xc0, 0xff, 0xff, 0x01, 0x00,
-   0x0f, 0xc0, 0xff, 0xff, 0x03, 0x00, 0x1f, 0xc0, 0xff, 0xff, 0x07, 0x00,
-   0x3f, 0xc0, 0xff, 0xff, 0x0f, 0x00, 0x7f, 0xc0, 0xff, 0xff, 0x1f, 0x00,
-   0xff, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xc3, 0xff, 0xff, 0x7f, 0x00,
-   0x7f, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xf7, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0xf3, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00,
-   0xe0, 0xc1, 0xff, 0xff, 0x7f, 0x00, 0xc0, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
-   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x7f, 0x00};
-#define url_width 33
-#define url_height 23
-#define url_x_hot 1
-#define url_y_hot 1
-static unsigned char url_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0xf8, 0x03, 0x00, 0x06, 0x00,
-   0xee, 0x0e, 0x00, 0x0e, 0x00, 0x77, 0x1c, 0x00, 0x1e, 0x80, 0x1f, 0x38,
-   0x00, 0x3e, 0xc0, 0x0f, 0x6c, 0x00, 0x7e, 0xe0, 0x07, 0xf4, 0x00, 0xfe,
-   0xe0, 0x05, 0xfe, 0x00, 0xfe, 0xf1, 0x00, 0xfe, 0x01, 0x3e, 0xd0, 0x00,
-   0xfc, 0x01, 0x36, 0xb0, 0x01, 0xfc, 0x01, 0x62, 0x10, 0x0f, 0xe8, 0x01,
-   0x60, 0x30, 0x1f, 0xf0, 0x01, 0xc0, 0x10, 0x3f, 0xfa, 0x01, 0xc0, 0x10,
-   0x3e, 0xfd, 0x01, 0x00, 0x60, 0xbc, 0xfe, 0x00, 0x00, 0xa0, 0x1c, 0xff,
-   0x00, 0x00, 0xc0, 0xcd, 0x7f, 0x00, 0x00, 0x80, 0xff, 0x3f, 0x00, 0x00,
-   0x00, 0xff, 0x1f, 0x00, 0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0xf8,
-   0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-#define url_mask_width 33
-#define url_mask_height 23
-static unsigned char url_mask_bits[] = {
-   0x03, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0xf8, 0x03, 0x00, 0x0f, 0x00,
-   0xfe, 0x0f, 0x00, 0x1f, 0x00, 0xff, 0x1f, 0x00, 0x3f, 0x80, 0xff, 0x3f,
-   0x00, 0x7f, 0xc0, 0xff, 0x7f, 0x00, 0xff, 0xe0, 0xff, 0xff, 0x00, 0xff,
-   0xe1, 0xff, 0xff, 0x00, 0xff, 0xf3, 0xff, 0xff, 0x01, 0xff, 0xf1, 0xff,
-   0xff, 0x01, 0x7f, 0xf0, 0xff, 0xff, 0x01, 0xf7, 0xf0, 0xff, 0xff, 0x01,
-   0xf3, 0xf0, 0xff, 0xff, 0x01, 0xe0, 0xf1, 0xff, 0xff, 0x01, 0xe0, 0xf1,
-   0xff, 0xff, 0x01, 0xc0, 0xe0, 0xff, 0xff, 0x00, 0x00, 0xe0, 0xff, 0xff,
-   0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x80, 0xff, 0x3f, 0x00, 0x00,
-   0x00, 0xff, 0x1f, 0x00, 0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0xf8,
-   0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

--- a/src/offix-types.h	Sat Dec 19 18:10:20 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-/*
-Copyright (C) 1996 César Crusius
-
-This file is part of the DND Library.  This library is free
-software; you can redistribute it and/or modify it under the terms of
-the GNU Library General Public License as published by the Free
-Software Foundation; either version 2 of the License, or (at your
-option) any later version.  This library is distributed in the hope
-that it will be useful, but WITHOUT ANY WARRANTY; without even the
-implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the GNU Library General Public License for more details.
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef INCLUDED_offix_types_h_
-#define INCLUDED_offix_types_h_
-
-#define DndNotDnd	-1
-#define DndUnknown	0
-#define DndRawData	1
-#define DndFile		2
-#define	DndFiles	3
-#define	DndText		4
-#define DndDir		5
-#define DndLink		6
-#define DndExe		7
-#define DndURL          8
-#define DndMIME         9
-
-#define DndEND		10
-
-#endif /* INCLUDED_offix_types_h_ */

--- a/src/offix.c	Sat Dec 19 18:10:20 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,451 +0,0 @@
-/*
-This is a modified DND 1.0 library which does not depend on Xt
-event handling.
-Modifications Copyright (c) 1997 Oliver Graf <ograf@fga.de>
-
-Original DND lib
-Copyright (C) 1996 César Crusius
-
-This file is part of the DND Library.  This library is free
-software; you can redistribute it and/or modify it under the terms of
-the GNU Library General Public License as published by the Free
-Software Foundation; either version 2 of the License, or (at your
-option) any later version.  This library is distributed in the hope
-that it will be useful, but WITHOUT ANY WARRANTY; without even the
-implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the GNU Library General Public License for more details.
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-/* #define DEBUG */
-
-#include "offix.h"
-#include <X11/cursorfont.h>
-#include <X11/Xatom.h>
-#include <X11/Xmu/WinUtil.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <limits.h>
-
-/* Local variables */
-static Display		*dpy;		/* current display		*/
-static int		DragPrecision;	/* minimum dx,dy to start drag	*/
-static int		Dragging;	/* Drag state flag		*/
-static int		DataOK;		/* Non-zero if data registered	*/
-static Atom		DndProtocol;	/* ClientMessage identifier	*/
-static Atom		DndSelection;	/* For the data transfers	*/
-static Atom             OldDndProtocol; /* Version 0 atom               */
-static Atom             OldDndSelection;/* Version 0 atom               */
-static Atom		WM_STATE;	/* Needed for icon stuff	*/
-static Window		Target;		/* Drop window			*/
-static Widget		MainWidget;	/* Main widget of application	*/
-static int		DataType;	/* Current drag data type	*/
-static int		RootFlag;	/* Non-zero if dropped on root	*/
-static XColor	        Black,White;    /* For the cursors              */
-
-/*=========================================================================
- * Data for the standard Dnd cursors
- *=========================================================================*/
-#include "offix-cursors.h"
-
-/*=============================================================== CursorData
- * CursorData contains all the data for the cursors bitmaps
- *==========================================================================*/
-typedef struct
-{
-  int	Width,Height;
-  unsigned char	*ImageData,*MaskData;
-  int	HotSpotX,HotSpotY;
-  Pixmap	ImagePixmap,MaskPixmap;
-  Cursor	CursorID;
-} CursorData;
-
-static CursorData DndCursor[DndEND]={
-  { 0,0,NULL,NULL,0,0,0 },
-  { grey_width,	grey_height,grey_bits,grey_mask_bits,
-    grey_x_hot,grey_y_hot},
-  { file_width,file_height,file_bits,file_mask_bits,
-    file_x_hot,file_y_hot},
-  { files_width,files_height,files_bits,files_mask_bits,
-    files_x_hot,files_y_hot},
-  { text_width,text_height,text_bits,text_mask_bits,
-    text_x_hot,text_y_hot },
-  { dir_width,dir_height,dir_bits,dir_mask_bits,
-    dir_x_hot,dir_y_hot },
-  { link_width,link_height,link_bits,link_mask_bits,
-    link_x_hot,link_y_hot},
-  { app_width,app_height,app_bits,app_mask_bits,
-    app_x_hot,app_y_hot },
-  { url_width,url_height,url_bits,url_mask_bits,
-    url_x_hot,url_y_hot },
-  { mime_width,mime_height,mime_bits,mime_mask_bits,
-    mime_x_hot,mime_y_hot }
-};
-
-/* Local prototypes */
-int DndIsDragging(void);
-void DndStartAction(Widget widget,
-		    XtPointer data,
-		    XEvent *event,
-		    Boolean *p);
-void DndPropertyHandler(Widget widget,
-			XtPointer data,
-			XEvent *event,
-			Boolean *p);
-
-/*======================================================== DndHandleDragging
- * Takes care of the drag and drop process. Wait until the pointer had moved
- * a little. Then takes control over the pointer until the buttons are
- * released. After that send a Drag And Drop ClientMessage event. Returns
- * non-zero if a drop did take place.
- *===========================================================================*/
-int
-DndHandleDragging(Widget widget,XEvent *event)
-{
-  XEvent Event;
-  Window root	= RootWindowOfScreen(XtScreenOfObject(widget));
-  XtAppContext app= XtWidgetToApplicationContext(widget);
-  Window  DispatchWindow;
-  int DropX,DropY;
-
-  if(Dragging) return 0;
-
-  XUngrabPointer(dpy,CurrentTime);
-  /* Take control over the pointer */
-  XGrabPointer(dpy,root,False,
-	       ButtonMotionMask|ButtonPressMask|ButtonReleaseMask,
-	       GrabModeSync,GrabModeAsync,root,
-	       DndCursor[DataType].CursorID,
-	       CurrentTime);
-
-  /* Wait for button release */
-  Dragging=1; RootFlag=0;
-  while(Dragging)
-    {
-      XAllowEvents(dpy,SyncPointer,CurrentTime);
-      XtAppNextEvent(app,&Event);
-      switch(Event.type)
-	{
-	case ButtonRelease:
-	  if(Event.xbutton.subwindow)
-	    RootFlag=0;
-	  else
-	    RootFlag=1;
-	  Dragging=0;
-	  break;
-	default:
-	  XtDispatchEvent(&Event);
-	  break;
-	}
-    }
-  DataOK=0;
-  /* Now release the pointer */
-  XUngrabPointer(dpy,CurrentTime);
-  /* Try to guess if the drop occurred in the root window */
-  if(!RootFlag)
-    {
-      Target=XmuClientWindow(dpy,Event.xbutton.subwindow);
-      if (Target==Event.xbutton.subwindow)
-	DispatchWindow=Target;
-      else
-	DispatchWindow=PointerWindow;
-    }
-  else
-    Target=DispatchWindow=XtWindow(MainWidget);
-
-  /* Now build the event structure */
-  DropX=Event.xbutton.x_root;
-  DropY=Event.xbutton.y_root;
-  Event.xclient.type		= ClientMessage;
-  Event.xclient.display		= dpy;
-  Event.xclient.message_type	= DndProtocol;
-  Event.xclient.format		= 32;
-  Event.xclient.window		= Target;
-  Event.xclient.data.l[0]      	= DataType;
-  Event.xclient.data.l[1]      	= (long)event->xbutton.state;
-  Event.xclient.data.l[2]      	= (long)XtWindow(widget);
-  Event.xclient.data.l[3]      	= DropX + 65536L*(long)DropY;
-  Event.xclient.data.l[4]      	= 1;
-
-  /* Send the drop message */
-  XSendEvent(dpy,DispatchWindow,True,NoEventMask,&Event);
-  /* Send an old style version of the message just in case */
-  Event.xclient.message_type = OldDndProtocol;
-  XSendEvent(dpy,DispatchWindow,True,NoEventMask,&Event);
-
-#ifdef DEBUG
-  fprintf(stderr,"ClientMessage sent to 0x%x(0x%x).\n",
-	  DispatchWindow,Target);
-  fprintf(stderr,"The drop coordinates are (%d,%d).\n",DropX,DropY);
-#endif
-
-  return 1;
-}
-
-/*=============================================================== DndIsIcon
- * Return non-zero if the application is iconic (widget=toplevel)
- *========================================================================*/
-int
-DndIsIcon(Widget widget)
-{
-    Atom JunkAtom;
-    int JunkInt;
-    unsigned long WinState,JunkLong;
-    unsigned char *Property;
-
-    XGetWindowProperty(dpy,XtWindow(widget),WM_STATE,
-		       0L,2L,False,AnyPropertyType,
-		       &JunkAtom,&JunkInt,&WinState,&JunkLong,
-		       &Property);
-    WinState=(unsigned long)(*((long*)Property));
-    return (WinState==3);
-}
-
-/*============================================================ DndInitialize
- * Must be called anywhere before the top level widget creation and the
- * main loop. Initialize global variables and bind the DndDispatch function
- * to the top level widget. Creates the cursors to be used in drag actions.
- *=========================================================================*/
-void
-DndInitialize(Widget shell)
-{
-    int	 screen,i;
-    Colormap colormap;
-    Window	 root;
-
-    dpy	= XtDisplayOfObject(shell);
-    screen	= DefaultScreen(dpy);
-    colormap= DefaultColormap(dpy,screen);
-    root	= DefaultRootWindow(dpy);
-
-
-    Black.pixel=BlackPixel(dpy,screen);
-    White.pixel=WhitePixel(dpy,screen);
-    XQueryColor(dpy,colormap,&Black);
-    XQueryColor(dpy,colormap,&White);
-
-    for(i=1;i!=DndEND;i++)
-    {
-	DndCursor[i].ImagePixmap=
-	    XCreateBitmapFromData(dpy,root,
-				  (char *) DndCursor[i].ImageData,
-				  DndCursor[i].Width,
-				  DndCursor[i].Height);
-	DndCursor[i].MaskPixmap=
-	    XCreateBitmapFromData(dpy,root,
-				  (char *) DndCursor[i].MaskData,
-				  DndCursor[i].Width,
-				  DndCursor[i].Height);
-	DndCursor[i].CursorID=
-	    XCreatePixmapCursor(dpy,DndCursor[i].ImagePixmap,
-				DndCursor[i].MaskPixmap,
-				&Black,&White,
-				DndCursor[i].HotSpotX,
-				DndCursor[i].HotSpotY);
-    }
-
-    DndCursor[0].CursorID=XCreateFontCursor(dpy,XC_question_arrow);
-
-    /* These two are for older versions */
-    OldDndProtocol=XInternAtom(dpy,"DndProtocol",FALSE);
-    OldDndSelection=XInternAtom(dpy,"DndSelection",FALSE);
-    /* Now the correct stuff */
-    DndProtocol=XInternAtom(dpy,"_DND_PROTOCOL",FALSE);
-    DndSelection=XInternAtom(dpy,"_DND_SELECTION",FALSE);
-
-    WM_STATE=XInternAtom(dpy,"WM_STATE",True);
-    Dragging=0;
-    DragPrecision=10;
-    RootFlag=0;
-    MainWidget=shell;
-}
-
-int
-DndIsDragging(void)
-{
-  return Dragging;
-}
-
-/*================================================================= DndSetData
- * Updates the selection data.
- *===========================================================================*/
-void
-DndSetData(int Type,unsigned char *Data,unsigned long Size)
-{
-  Window root = DefaultRootWindow(dpy);
-  int AuxSize;
-  unsigned char *AuxData;
-  unsigned long BackSize=Size;
-
-  if (DataOK) return;
-
-  /* Set the data type -- allow any type */
-  DataType = Type;
-
-  /* Set the data */
-  AuxData = Data;
-  AuxSize = ( Size <= INT_MAX ? (int)Size : INT_MAX );
-  XChangeProperty(dpy,root,DndSelection,XA_STRING,8,
-		  PropModeReplace,Data,AuxSize);
-  for(Size-=(unsigned long)AuxSize;Size;Size-=(unsigned long)AuxSize)
-    {
-      Data+=AuxSize;
-      AuxSize = ( (Size<=(INT_MAX)) ? (int)Size : (INT_MAX) );
-	XChangeProperty(dpy,root,DndSelection,XA_STRING,8,
-			PropModeAppend,Data,AuxSize);
-    }
-
-  /* Set the data for old DND version */
-  Size = BackSize;
-  AuxData = Data;
-  AuxSize = ( Size <= INT_MAX ? (int)Size : INT_MAX );
-  XChangeProperty(dpy,root,OldDndSelection,XA_STRING,8,
-		  PropModeReplace,Data,AuxSize);
-  for(Size-=(unsigned long)AuxSize;Size;Size-=(unsigned long)AuxSize)
-    {
-      Data+=AuxSize;
-      AuxSize = ( (Size<=(INT_MAX)) ? (int)Size : (INT_MAX) );
-      XChangeProperty(dpy,root,OldDndSelection,XA_STRING,8,
-		      PropModeAppend,Data,AuxSize);
-    }
-
-  /* Everything is now ok */
-  DataOK=1;
-}
-
-/*================================================================== DndGetData
- * Return a pointer to the current data. See HOWTO for more details.
- *===========================================================================*/
-void
-DndGetData(XEvent *event, unsigned char **Data,unsigned long *Size)
-{
-  Window root	= DefaultRootWindow(dpy);
-
-  Atom ActualType,ActualDndSelection;
-  int	ActualFormat;
-  unsigned long RemainingBytes;
-
-  ActualDndSelection=(DndProtocolVersion(event) == 0L ?
-		      OldDndSelection :
-		      DndSelection );
-
-  XGetWindowProperty(dpy,root,ActualDndSelection,
-		     0L,1000000L,
-		     FALSE,AnyPropertyType,
-		     &ActualType,&ActualFormat,
-		     Size,&RemainingBytes,
-		     Data);
-}
-
-/*================================== DndDataType DndDragButtons DndSourceWidget
- *
- * Return information about the Dnd event received. If a non-dnd event is
- * passed, the function DndDataType returns DndNotDnd, and the others
- * return zero.
- *===========================================================================*/
-int
-DndDataType(XEvent *event)
-{
-  int Type;
-
-  if(!DndIsDropMessage(event)) return DndNotDnd;
-  Type=(int)(event->xclient.data.l[0]);
-  if(Type>=DndEND) Type=DndUnknown;
-  return Type;
-}
-
-int
-DndDragButtons(XEvent *event)
-{
-  if(!DndIsDropMessage(event)) return 0;
-  return (int)(event->xclient.data.l[1]);
-}
-
-Window
-DndSourceWindow(XEvent *event)
-{
-  if(!DndIsDropMessage(event)) return 0;
-  if(DndProtocolVersion(event)<__DragAndDropH__)
-    /* We will try to do something about it, but nothing is certain */
-    return XtWindow((Widget)(event->xclient.data.l[2]));
-  return (Window)(event->xclient.data.l[2]);
-}
-
-void
-DndDropRootCoordinates(XEvent *event,int *x,int *y)
-{
-  if(!DndIsDropMessage(event))
-    {
-      *x=0; *y=0;
-      return;
-    }
-
-  /* If it is an old protocol version we try to get the coordinates
-     using the current pointer position. Of course, the pointer may have
-     moved since the drop, but there's nothing we can do about it.
-  */
-  if(DndProtocolVersion(event)<1L)
-    {
-      Window root_return,child_return;
-      int win_x_return,win_y_return;
-      unsigned int mask_return;
-
-      XQueryPointer(dpy,DefaultRootWindow(dpy),
-		    &root_return,&child_return,x,y,
-		    &win_x_return,&win_y_return,&mask_return);
-      return;
-    }
-  /* Thanks god you are using a decent protocol version */
-  *x=(int)((long)(event->xclient.data.l[3]) & 0xffff);
-  *y=(int)((long)(event->xclient.data.l[3])/65536);
-}
-
-void
-DndDropCoordinates(Widget widget,XEvent *event,int *x,int *y)
-{
-  int root_x,root_y;
-  Window child_return;
-
-  DndDropRootCoordinates(event,&root_x,&root_y);
-  XTranslateCoordinates(dpy,DefaultRootWindow(dpy),
-			XtWindow(widget),
-			root_x,root_y,
-			x,y,
-			&child_return);
-}
-
-long
-DndProtocolVersion(XEvent *event)
-{
-  if(!DndIsDropMessage(event)) return -1L;
-  return event->xclient.data.l[4];
-}
-
-int
-DndIsDropMessage(XEvent *event)
-{
-  if(event->xclient.type != ClientMessage) return 0;
-  if(event->xclient.message_type == OldDndProtocol &&
-     event->xclient.data.l[4]==0) return 1;
-  if(event->xclient.message_type == DndProtocol) return 1;
-  return 0;
-}
-
-void
-DndChangeCursor(int Type,int width,int height,char *image,char *mask,
-		int hot_x,int hot_y)
-{
-  DndCursor[Type].ImagePixmap=
-    XCreateBitmapFromData(dpy,DefaultRootWindow(dpy),
-			  image,width,height);
-  DndCursor[Type].MaskPixmap=
-    XCreateBitmapFromData(dpy,DefaultRootWindow(dpy),
-			  mask,width,height);
-  DndCursor[Type].CursorID=
-    XCreatePixmapCursor(dpy,DndCursor[Type].ImagePixmap,
-			DndCursor[Type].MaskPixmap,
-			&Black,&White,
-			hot_x,hot_y);
-}

--- a/src/offix.h	Sat Dec 19 18:10:20 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,68 +0,0 @@
-/*
-This is a modified DND 1.0 library which does not depend on Xt
-event handling.
-Modifications Copyright (c) 1997 Oliver Graf <ograf@fga.de>
-
-Original DND lib
-Copyright (C) 1996 César Crusius
-
-This file is part of the DND Library.  This library is free
-software; you can redistribute it and/or modify it under the terms of
-the GNU Library General Public License as published by the Free
-Software Foundation; either version 2 of the License, or (at your
-option) any later version.  This library is distributed in the hope
-that it will be useful, but WITHOUT ANY WARRANTY; without even the
-implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the GNU Library General Public License for more details.
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __DragAndDropH__
-#define __DragAndDropH__ 1L
-
-/* The standard DND types are defined here */
-#include "offix-types.h"
-
-/* Xt stuff is defined here */
-#include "xintrinsic.h"
-
-void DndInitialize(Widget shell);
-
-int
-DndHandleDragging(Widget widget,
-		  XEvent* event);
-
-void DndSetData(int Type, unsigned char *Data, unsigned long Size);
-void DndGetData(XEvent *event, unsigned char **Data, unsigned long *Size);
-
-int		DndIsIcon(Widget widget);
-int		DndDataType(XEvent *event);
-int		DndDragButtons(XEvent *event);
-Window          DndSourceWindow(XEvent *event);
-
-void
-DndDropCoordinates(Widget widget,
-		   XEvent *event,
-		   int *x,
-		   int *y);
-void
-DndDropRootCoordinates(XEvent *event,
-		       int *x,
-		       int *y);
-
-long
-DndProtocolVersion(XEvent *event);
-
-int
-DndIsDropMessage(XEvent *event);
-
-void
-DndChangeCursor(int Type,
-		int width,int height,
-		char *image,char *mask,
-		int hot_x,int hot_y);
-#endif
-
-

--- a/src/text.h	Sat Dec 19 18:10:20 2009 +0000
+++ b/src/text.h	Thu Dec 31 15:47:03 2009 +0000
@@ -3111,7 +3111,6 @@
 /* !!#### Verify these! */
 #define Qxt_widget_arg_encoding Qnative
 #define Qdt_dnd_encoding Qnative
-#define Qoffix_dnd_encoding Qnative
 
 /* RedHat 6.2 contains a locale called "Francais" with the C-cedilla
    encoded in ISO2022! */
@@ -3119,9 +3118,6 @@
 
 #define Qstrerror_encoding Qnative
 
-/* Encoding for strings coming from Offix drag-n-drop */
-#define Qoffix_dnd_encoding Qnative
-
 /* !!#### This exists to remind us that our hexify routine is totally
    un-Muleized. */
 #define Qdnd_hexify_encoding Qascii

--- a/tests/ChangeLog	Sat Dec 19 18:10:20 2009 +0000
+++ b/tests/ChangeLog	Thu Dec 31 15:47:03 2009 +0000
@@ -1,3 +1,18 @@
+2009-12-31  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* automated/lisp-tests.el: 
+	Test much of the functionality of equalp; add a pointer to Paul
+	Dietz' ANSI test suite for this function, converted to Emacs
+	Lisp. Not including the tests themselves in XEmacs because who
+	owns the copyright on the files is unclear and the GCL people
+	didn't respond to my queries. 
+
+2009-12-21  Jerry James  <james@xemacs.org>
+
+	* Dnd/README: Remove references to OffiX drag-and-drop.
+	* Dnd/droptest.el (start-drag): Remove OffiX support.
+	(start-region-drag): Ditto.
+
 2009-12-18  Jerry James  <james@xemacs.org>
 
 	* glyph-test.el: Add copyright and GPL v2 or later header with

--- a/tests/Dnd/README	Sat Dec 19 18:10:20 2009 +0000
+++ b/tests/Dnd/README	Thu Dec 31 15:47:03 2009 +0000
@@ -9,14 +9,8 @@
 3) Try to do some internal DnD by using the sources and targets
    in the new buffer
 4) Do some external DnD:
-   4a) OffiX: use files and editor of OffiX
-              drag something from files or editor into XEmacs
-              drag something from XEmacs to xv (only with OffiX patch,
-              editor or files -- files can only move and copy within
-              itself, cause OffiX is not quite the right thing to do)
-   4b) CDE: use dtfile and dtpad instead, but here everything should
-            work.
-   4c) MSWindows: well, explorer should do. But only file data
+   4a) CDE: use dtfile and dtpad
+   4b) MSWindows: well, explorer should do. But only file data
                   should work, and I don't know if the test
                   already handles this.
 

--- a/tests/Dnd/droptest.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/tests/Dnd/droptest.el	Thu Dec 31 15:47:03 2009 +0000
@@ -13,11 +13,7 @@
 
 (defun start-drag (event what &optional typ)
   ;; short drag interface, until the real one is implemented
-  (cond ((featurep 'offix)
-	 (if (numberp typ)
-	     (offix-start-drag event what typ)
-	   (offix-start-drag event what)))
-	((featurep 'cde)
+  (cond ((featurep 'cde)
 	 (if (not typ)
 	     (funcall (intern "cde-start-drag-internal") event nil (list what))
 	   (funcall (intern "cde-start-drag-internal") event t what)))
@@ -27,16 +23,11 @@
   (interactive "_e")
   (if (click-inside-extent-p event zmacs-region-extent)
       ;; okay, this is a drag
-      (cond ((featurep 'offix)
-	     (offix-start-drag-region event
-				      (extent-start-position zmacs-region-extent)
-				      (extent-end-position zmacs-region-extent)))
-	    ((featurep 'cde)
-	     ;; should also work with CDE
+      (cond ((featurep 'cde)
 	     (cde-start-drag-region event
 				    (extent-start-position zmacs-region-extent)
 				    (extent-end-position zmacs-region-extent)))
-	    (t (error "No offix or CDE support compiled in")))))
+	    (t (error "No CDE support compiled in")))))
 
 (defun make-drop-targets ()
   (let ((buf (get-buffer-create "*DND misc-user extent test buffer*"))

--- a/tests/automated/lisp-tests.el	Sat Dec 19 18:10:20 2009 +0000
+++ b/tests/automated/lisp-tests.el	Thu Dec 31 15:47:03 2009 +0000
@@ -2085,14 +2085,81 @@
         (* three one-four-one-five-nine)))
    "checking letf handles #'values in a basic sense"))
 
-(Assert (equalp "hi there" "Hi There")
-	"checking equalp isn't case-sensitive")
-(Assert (equalp 99 99.0)
-	"checking equalp compares numerical values of different types")
-(Assert (null (equalp 99 ?c))
-	"checking equalp does not convert characters to numbers")
-;; Fixed in Hg d0ea57eb3de4.
-(Assert (null (equalp "hi there" [hi there]))
-	"checking equalp doesn't error with string and non-string")
+;; #'equalp tests.
+(let ((string-variable "aBcDeeFgH\u00Edj")
+      (eacute-character ?\u00E9)
+      (Eacute-character ?\u00c9)
+      (+base-chars+ (loop
+		       with res = (make-string 96 ?\x20)
+		       for int-char from #x20 to #x7f
+		       for char being each element in-ref res
+		       do (setf char (int-to-char int-char))
+		       finally return res)))
+  (Assert (equalp "hi there" "Hi There")
+	  "checking equalp isn't case-sensitive")
+  (Assert (equalp 99 99.0)
+	  "checking equalp compares numerical values of different types")
+  (Assert (null (equalp 99 ?c))
+	  "checking equalp does not convert characters to numbers")
+  ;; Fixed in Hg d0ea57eb3de4.
+  (Assert (null (equalp "hi there" [hi there]))
+	  "checking equalp doesn't error with string and non-string")
+  (Assert (eq t (equalp "ABCDEEFGH\u00CDJ" string-variable))
+	  "checking #'equalp is case-insensitive with an upcased constant") 
+  (Assert (eq t (equalp "abcdeefgh\xedj" string-variable))
+	  "checking #'equalp is case-insensitive with a downcased constant")
+  (Assert (eq t (equalp string-variable string-variable))
+	  "checking #'equalp works when handed the same string twice")
+  (Assert (eq t (equalp string-variable "aBcDeeFgH\u00Edj"))
+	  "check #'equalp is case-insensitive with a variable-cased constant")
+  (Assert (eq t (equalp "" (bit-vector))) 
+	  "check empty string and empty bit-vector are #'equalp.")
+  (Assert (eq t (equalp (string) (bit-vector))) 
+	  "check empty string and empty bit-vector are #'equalp, no constants")
+  (Assert (eq t (equalp "hi there" (vector ?h ?i ?\  ?t ?h ?e ?r ?e)))
+	  "check string and vector with same contents #'equalp")
+  (Assert (eq t (equalp (string ?h ?i ?\  ?t ?h ?e ?r ?e)
+			(vector ?h ?i ?\  ?t ?h ?e ?r ?e)))
+	  "check string and vector with same contents #'equalp, no constants")
+  (Assert (eq t (equalp [?h ?i ?\  ?t ?h ?e ?r ?e]
+			(string ?h ?i ?\  ?t ?h ?e ?r ?e)))
+	  "check string and vector with same contents #'equalp, vector constant")
+  (Assert (eq t (equalp [0 1.0 0.0 0 1]
+			(bit-vector 0 1 0 0 1)))
+	  "check vector and bit-vector with same contents #'equalp,\
+ vector constant")
+  (Assert (eq t (equalp #*01001
+			(vector 0 1.0 0.0 0 1)))
+	  "check vector and bit-vector with same contents #'equalp,\
+ bit-vector constant")
+  (Assert (eq t (equalp ?\u00E9 Eacute-character))
+	  "checking characters are case-insensitive, one constant")
+  (Assert (eq nil (equalp ?\u00E9 (aref (format "%c" ?a) 0)))
+	  "checking distinct characters are not equalp, one constant")
+  (Assert (eq t (equalp t (and)))
+	  "checking symbols are correctly #'equalp")
+  (Assert (eq nil (equalp t (or nil '#:t)))
+	  "checking distinct symbols with the same name are not #'equalp")
+  (Assert (eq t (equalp #s(char-table type generic data (?\u0080 "hi-there"))
+			(let ((aragh (make-char-table 'generic)))
+			  (put-char-table ?\u0080 "hi-there" aragh)
+			  aragh)))
+	  "checking #'equalp succeeds correctly, char-tables")
+  (Assert (eq nil (equalp #s(char-table type generic data (?\u0080 "hi-there"))
+			  (let ((aragh (make-char-table 'generic)))
+			    (put-char-table ?\u0080 "HI-THERE" aragh)
+			    aragh)))
+	  "checking #'equalp fails correctly, char-tables"))
+
+;; There are more tests available for equalp here: 
+;;
+;; http://www.parhasard.net/xemacs/equalp-tests.el
+;;
+;; They are taken from Paul Dietz' GCL ANSI test suite, licensed under the
+;; LGPL and part of GNU Common Lisp; the GCL people didn't respond to
+;; several requests for information on who owned the copyright for the
+;; files, so I haven't included the tests with XEmacs. Anyone doing XEmacs
+;; development on equalp should still run them, though. Aidan Kehoe, Thu Dec
+;; 31 14:53:52 GMT 2009. 
 
 ;;; end of lisp-tests.el