Merged in changes from CVS HEAD

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-71
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-72
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-73
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-74
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-75
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-76
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-77
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-78
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-79
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-80
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-81
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-82
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-83
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-84
   Add lisp/emacs-lisp/macroexp.el

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-85
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-86
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-87
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-88
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-89
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-90
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-91
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-92
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-93
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-94
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-95
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-96
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-97
   Update from CVS


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-77

32 files changed, 2798 insertions, 1070 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 76d63cab844..179b7a16a48 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,285 @@
+2004-02-16  Stephen Eglen  <stephen@gnu.org>
+
+        * fringe.c (init_fringe_bitmap): Define j in MAC_OS code.
+
+2004-02-15  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * data.c (Fbyteorder): 
+        * fringe.c (Fdefine_fringe_bitmap): 
+        * xdisp.c (handle_single_display_prop): 
+        * xselect.c (x_handle_dnd_message): Lisp_Object/int mixup.
+
+2004-02-16  Jason Rumney  <jasonr@gnu.org>
+
+        * w32term.c (w32_draw_fringe_bitmap): Handle overlay fringe bitmaps.
+
+2004-02-15  Steven Tamm  <steventamm@mac.com>
+
+        * macterm.c (Vmac_emulate_three_button_mouse): New variable for
+        controlling emulation of a three button mouse with option and
+        command keys.
+        (Qreverse, mac_get_enumlated_btn): Handle the emulation
+        (mac_event_to_emacs_modifiers, XTread_socket): Ditto
+
+2004-02-15  Kim F. Storm  <storm@cua.dk>
+
+        * buffer.c (syms_of_buffer): Doc fix for indicate-buffer-boundaries.
+
+        * fringe.c (init_fringe_bitmap) [MAC_OS, WORDS_BIG_ENDIAN]:
+        Perform byte-swapping.
+
+2004-02-14  Kim F. Storm  <storm@cua.dk>
+
+        * dispextern.h (struct draw_fringe_bitmap_params): Change member
+        bits from char to short to facilitate wider bitmaps.
+        (struct redisplay_interface): Fix prototype of define_fringe_bitmap
+        member.
+
+        * fringe.c (struct fringe_bitmap): Change member bits from char to
+        short to facilitate 16 bits wide bitmaps.  Modify all standard
+        bitmaps accordingly.
+        (BYTES_PER_BITMAP_ROW, STANDARD_BITMAP_HEIGHT): New macros.
+        (FRBITS): Use STANDARD_BITMAP_HEIGHT instead of just sizeof.
+        (draw_fringe_bitmap): Ditto.
+        (init_fringe_bitmap) [MAC_OS]: Don't bitswap.
+        (init_fringe_bitmap) [HAVE_X_WINDOWS]: Enhance bitswapping to
+        handle up to 16 bits wide bitmaps.
+        (Fdefine_fringe_bitmap): Doc fix.  Handle wider bitmaps.
+        (Ffringe_bitmaps_at_pos): Add missing arg declarations.
+
+        * macterm.c (mac_draw_bitmap): Handle 16 bits wide bitmaps directly.
+        (x_draw_fringe_bitmap): Use enhanced mac_draw_bitmap, so we no longer
+        need to call mac_create_bitmap_from_bitmap_data and mac_free_bitmap.
+
+        * w32term.c (w32_define_fringe_bitmap): Bitmaps are now 16 bits wide,
+        so it is no longer necessary to expand them here.
+
+        * xterm.c (x_draw_fringe_bitmap): Handle wider bitmaps (max 16 bits).
+
+2004-02-12  Kim F. Storm  <storm@cua.dk>
+
+        * window.c (Fwindow_fringes): Doc fix.
+
+2004-02-10  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xselect.c (x_get_foreign_selection): Add new optional parameter
+        time_stamp.
+        (Fx_get_selection_internal): Ditto, pass time_stamp to
+        x_get_foreign_selection.
+
+        * data.c (Fbyteorder): New function.
+
+2004-02-09  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * atimer.c: Move include stdio.h to same place as in other files.
+
+        * region-cache.c: Ditto.
+
+        * sysdep.c: Ditto.
+
+        * xfaces.c: Ditto.
+
+2004-02-09  Sam Steingold  <sds@gnu.org>
+
+        * w32term.c (w32_draw_fringe_bitmap): Fixed a typo in the last patch.
+
+2004-02-09  Kim F. Storm  <storm@cua.dk>
+
+        * fringe.c: New file.  Move original fringe related declarations
+        and code from dispextern.h and xdisp.c here.
+        Rework code to support user defined fringe bitmaps, redefining
+        standard bitmaps, ability to overlay user defined bitmap with
+        overlay arrow bitmap, and add faces to bitmaps.
+        (Voverflow_newline_into_fringe): Declare here.
+        (enum fringe_bitmap_align): New enum.
+        (..._bits): All bitmaps are now defined without bitswapping; that
+        is now done in init_fringe_once (if necessary).
+        (standard_bitmaps): New array with specifications for the
+        standard fringe bitmaps.
+        (fringe_faces): New array.
+        (valid_fringe_bitmap_id_p): New function.
+        (draw_fringe_bitmap_1): Rename from draw_fringe_bitmap.
+        (draw_fringe_bitmap): New function which draws fringe bitmap,
+        possibly overlaying bitmap with cursor in right fringe or the
+        overlay arrow in the left fringe.
+        (update_window_fringes): Do not handle overlay arrow here.
+        Compare and copy fringe bitmap faces.
+        (init_fringe_bitmap): New function.
+        (Fdefine_fringe_bitmap, Fdestroy_fringe_bitmap): New DEFUNs to
+        define and destroy user defined fringe bitmaps.
+        (Fset_fringe_bitmap_face): New DEFUN to set face for a fringe bitmap.
+        (Ffringe_bitmaps_at_pos): New DEFUN to read current fringe bitmaps.
+        (syms_of_fringe): New function.  Defsubr new DEFUNs.
+        DEFVAR_LISP Voverflow_newline_into_fringe.
+        (init_fringe_once, init_fringe): New functions.
+        (w32_init_fringe, w32_reset_fringes) [WINDOWS_NT]: New functions.
+
+        * Makefile.in (obj): Add fringe.o.
+        (fringe.o): New dependencies.
+
+        * dispextern.h (FRINGE_ID_BITS): New definition for number of
+        bits allocated to hold a fringe number.  Increase number of bits
+        from 4 to 8 to allow user defined fringe bitmaps.
+        (struct glyph_row, struct it): New members left_user_fringe_bitmap,
+        left_user_fringe_face_id, right_user_fringe_bitmap,
+        right_user_fringe_face_id.
+        (enum fringe_bitmap_type, struct fringe_bitmap, fringe_bitmaps):
+        Move to new file fringe.c.
+        (MAX_FRINGE_BITMAPS): Define here.
+        (struct draw_fringe_bitmap_params): New members bits, cursor_p,
+        and overlay_p.  Change member which to int.
+        (struct redisplay_interface): New members define_fringe_bitmap
+        and destroy_fringe_bitmap.
+        (valid_fringe_bitmap_id_p): Add prototype.
+        (w32_init_fringe, w32_reset_fringes) [WINDOWS_NT]: Add prototypes.
+
+        * dispnew.c (row_equal_p): Compare fringe bitmap faces and overlay
+        arrows.
+        (update_frame): Do flush_display if force_flush_display_p to
+        ensure display (specifically fringes) are updated in a timely
+        manner when resizing the frame by dragging the mouse.
+        (update_window_line): Update row if overlay arrow changed.
+        (scrolling_window): Redraw fringe bitmaps if fringe bitmap faces
+        or overlay arrow changed.
+
+        * emacs.c (main) [HAVE_WINDOW_SYSTEM]: Call init_fringe_once,
+        syms_of_fringe, and init_fringe.
+
+        * frame.h (struct frame): New member force_flush_display_p.
+
+        * lisp.h (syms_of_fringe, init_fringe, init_fringe_once):
+        Add prototypes.
+
+        * macterm.c (mac_draw_bitmap): Add overlay_p arg.
+        (x_draw_fringe_bitmap):  Handle overlayed fringe bitmaps;
+        thanks to YAMAMOTO Mitsuharu for advice on how to do this.
+        Use cursor color for displaying cursor in fringe.
+        (x_redisplay_interface): Add null handlers for
+        define_fringe_bitmap and destroy_fringe_bitmap functions.
+
+        * w32term.c (w32_draw_fringe_bitmap): Copy unadapted code from
+        xterm.c to handle overlayed fringe bitmaps and to use cursor color
+        for displaying cursor in fringe.
+        (w32_define_fringe_bitmap, w32_destroy_fringe_bitmap): New W32
+        specific functions to define and destroy fringe bitmaps in fringe_bmp.
+        (w32_redisplay_interface): Add them to redisplay_interface.
+        (w32_term_init): Call w32_init_fringe instead of explicitly
+        defining fringe bitmaps in fringe_bmp array.
+        (x_delete_display): Call w32_reset_fringes instead of explicitly
+        destroying fringe bitmaps in fringe_bmp array.
+
+        * xdisp.c (Voverflow_newline_into_fringe, syms_of_xdisp)
+        (left_bits, right_bits, up_arrow_bits, down_arrow_bits)
+        (continued_bits, continuation_bits, ov_bits, first_line_bits)
+        (last_line_bits, filled_box_cursor_bits, hollow_box_cursor_bits)
+        (bar_cursor_bits, hbar_cursor_bits, zv_bits, hollow_square_bits)
+        (fringe_bitmaps, draw_fringe_bitmap, draw_row_fringe_bitmaps)
+        (draw_window_fringes, compute_fringe_widths, update_window_fringes):
+        Move fringe handling vars and code to new file fringe.c.
+        (handle_display_prop): Handle left-fringe and right-fringe
+        display properties; store user fringe bitmaps in iterator.
+        (move_it_in_display_line_to): Handle cursor in fringe at eob.
+        (clear_garbaged_frames): Set force_flush_display_p if resized.
+        (redisplay_window): Redraw fringe bitmaps if not just_this_one_p.
+        (display_line): Handle cursor in fringe at eob.
+        (display_line): Set row user fringe bitmaps from iterator.
+
+        * xterm.c (x_draw_fringe_bitmap): Handle overlayed fringe bitmaps.
+        Use cursor color for displaying cursor in fringe.
+        (x_redisplay_interface): Add null handlers for
+        define_fringe_bitmap and destroy_fringe_bitmap functions.
+
+2004-02-07  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * macfns.c (Fx_change_window_property): Make doc string and
+        parameters same as for X version.
+
+        * w32fns.c (Fx_change_window_property): Ditto.
+
+2004-02-07  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (hscroll_window_tree): Position cursor near to right
+        margin in hscrolled window when jumping to end of line (rather
+        than centering cursor).
+
+        * process.c (wait_reading_process_input): Don't do adaptive read
+        buffering if waiting for a specific process.
+
+2004-02-05  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * minibuf.c (Fminibufferp, Fread_from_minibuffer)
+        (Fread_minibuffer, Feval_minibuffer)
+        (Fread_string, Fread_no_blanks_input)
+        (Fcompleting_read): Doc fixes.
+        (syms_of_minibuf): Doc fixes for minibuffer-completion-table and
+        completion-regexp-list.  Define Qcase_fold_search and staticpro it.
+        (read_minibuf): Fix initial comment.
+        (Ftry_completion, Fall_completions, Ftest_completion): Bind
+        case-fold-serach to the value of completion-ignore-case when
+        checking completion-regexp-list.
+        (Fdisplay_completion_list): Make it handle arguments that are
+        symbols.  Doc fix.
+
+2004-02-05  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xterm.h: Add declaration of free_frame_menubar.
+
+        * xfns.c (x_create_bitmap_mask): Removed unused variable depth.
+        (x_set_menu_bar_lines): Added ! defined USE_GTK for olines.
+        (Fx_change_window_property): Add declaration of parameters type and
+        format.  Remove unused variable cons.
+
+        * xselect.c: Include stdio,h.
+
+2004-02-05  Kenichi Handa  <handa@m17n.org>
+
+        * fns.c (Fset_char_table_range): Fix previous change.
+
+        * buffer.c (Fset_buffer_multibyte): Fix docstring.
+
+2004-02-04  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * editfns.c (Fchar_after, Fchar_before): Doc fixes.
+
+2004-02-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keymap.c (Vmouse_events): Rename from Vmenu_events.
+        (syms_of_keymap): Add mouse-[45], header-line, and mode-line to it.
+
+2004-02-04  Kenichi Handa  <handa@m17n.org>
+
+        * fns.c (Fset_char_table_range): Handle charsets ascii,
+        eight-bit-control, and eight-bit-graphic correctly.
+
+2004-02-03  Jason Rumney  <jasonr@gnu.org>
+
+        * w32select.c (Fw32_set_clipboard_data): Make coding iso2022 safe.
+
+        * w32fns.c (x_to_w32_font): Likewise.
+
+2004-02-03  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xterm.h: Add x_handle_dnd_message, x_check_property_data,
+        x_fill_property_data, x_property_data_to_lisp and check_x_display_info.
+
+        * xterm.c (handle_one_xevent): Call x_handle_dnd_message for
+        ClientMessages.
+
+        * xselect.c: Include termhooks.h and X11/Xproto.h
+        (x_check_property_data, x_fill_property_data)
+        (x_property_data_to_lisp, mouse_position_for_drop)
+        (Fx_get_atom_name, x_handle_dnd_message): New functions for DND support.
+        (Fx_send_client_event): Move here from xfns.c.
+        (syms_of_xselect): Add Sx_get_atom_name and Sx_send_client_message.
+
+        * xfns.c (x-send-client-message): Move to xselect.c
+        (Fx_change_window_property): Add optional arguments TYPE, FORMAT and
+        OUTER_P.
+        (Fx_window_property): Add optional arguments TYPE, SOURCE, DELETE_P,
+        VECTOR_RET_P.  Handle AnyPropertyType.  Call x_property_data_to_lisp
+        if vector_ret_p is true.
+        (syms_of_xfns): Sx_send_client_message moved to xselect.c.
+
 2004-02-02  Eli Zaretskii  <eliz@elta.co.il>
 
         * fileio.c (Fcopy_file): If NEWNAME is a directory, expand the
@@ -43,10 +325,9 @@
 
 2004-01-27  Steven Tamm <steventamm@mac.com>
 
-        * macterm.c (make_mac_frame, make_mac_terminal_frame): Move
-        setting of scroll bars from make_mac_frame to
-        make_mac_terminal_frame to prevent clobbering of
-        scroll-bar-mode.
+        * macterm.c (make_mac_frame, make_mac_terminal_frame):
+        Move setting of scroll bars from make_mac_frame to
+        make_mac_terminal_frame to prevent clobbering of scroll-bar-mode.
 
 2004-01-26  Richard M. Stallman  <rms@gnu.org>
 
diff --git a/src/Makefile.in b/src/Makefile.in
index 94579aed476..ac9cae31061 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -571,7 +571,7 @@ XMENU_OBJ = xmenu.o
 
 /* lastfile must follow all files
    whose initialized data areas should be dumped as pure by dump-emacs.  */
-obj=    dispnew.o frame.o scroll.o xdisp.o $(XMENU_OBJ) window.o \
+obj=    dispnew.o frame.o scroll.o xdisp.o fringe.o $(XMENU_OBJ) window.o \
         charset.o coding.o category.o ccl.o \
         cm.o term.o xfaces.o $(XOBJ) \
         emacs.o keyboard.o macros.o keymap.o sysdep.o \
@@ -1075,6 +1075,7 @@ filemode.o: filemode.c  $(config_h)
 frame.o: frame.c xterm.h window.h frame.h termhooks.h commands.h keyboard.h \
    blockinput.h atimer.h systime.h buffer.h charset.h fontset.h \
    msdos.h dosfns.h dispextern.h $(config_h)
+fringe.o: fringe.c dispextern.h frame.h window.h buffer.h $(config_h)
 fontset.o: dispextern.h fontset.h fontset.c ccl.h buffer.h charset.h frame.h \
    keyboard.h termhooks.h $(config_h)
 getloadavg.o: getloadavg.c $(config_h)
diff --git a/src/atimer.c b/src/atimer.c
index 6b0e0777886..2ddc7427f56 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -19,13 +19,13 @@ the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include <config.h>
-#include <lisp.h>
 #include <signal.h>
+#include <stdio.h>
+#include <lisp.h>
 #include <syssignal.h>
 #include <systime.h>
 #include <blockinput.h>
 #include <atimer.h>
-#include <stdio.h>
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
diff --git a/src/buffer.c b/src/buffer.c
index fa5a9c85c2d..ad1dde93da7 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -2081,7 +2081,9 @@ DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte, Sset_buffer_multibyte,
 If FLAG is t, this makes the buffer a multibyte buffer.
 If FLAG is nil, this makes the buffer a single-byte buffer.
 The buffer contents remain unchanged as a sequence of bytes
-but the contents viewed as characters do change.  */)
+but the contents viewed as characters do change.
+If the multibyte flag was really changed, undo information of the
+current buffer is cleared.  */)
      (flag)
      Lisp_Object flag;
 {
@@ -5637,10 +5639,20 @@ window-systems.  */);
   DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
                      &current_buffer->indicate_buffer_boundaries, Qnil,
                      doc: /* *Visually indicate buffer boundaries and scrolling.
-If non-nil, the first and last line of the buffer are marked in the left and
-right fringe of a window on window-systems.
-In addition, if value is t, the top and bottom line of the window are marked
-with up and down arrow bitmaps in the right fringe if window can be scrolled.  */);
+If non-nil, the first and last line of the buffer are marked in the fringe
+of a window on window-systems with angle bitmaps, or if the window can be
+scrolled, the top and bottom line of the window are marked with up and down
+arrow bitmaps.
+If value is `left' or `right', both angle and arrow bitmaps are displayed in
+the left or right fringe, resp.  Any other non-nil value causes the
+bitmap on the top line to be displayed in the left fringe, and the
+bitmap on the bottom line in the right fringe.
+If value is a cons (ANGLES . ARROWS), the car specifies the position
+of the angle bitmaps, and the cdr specifies the position of the arrow
+bitmaps.  For example, (t . right) places the top angle bitmap in left
+fringe, the bottom angle bitmap in right fringe, and both arrow
+bitmaps in right fringe.  To show just the angle bitmaps in the left
+fringe, but no arrow bitmaps, use (left . nil).  */);
 
   DEFVAR_PER_BUFFER ("scroll-up-aggressively",
                      &current_buffer->scroll_up_aggressively, Qnil,
diff --git a/src/data.c b/src/data.c
index c4e3937f3fa..bff2baaed27 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2879,6 +2879,20 @@ DEFUN ("lognot", Flognot, Slognot, 1, 1, 0,
   XSETINT (number, ~XINT (number));
   return number;
 }
+
+DEFUN ("byteorder", Fbyteorder, Sbyteorder, 0, 0, 0,
+       doc: /* Return the byteorder for the machine.
+Returns 66 (ASCII uppercase B) for big endian machines or 108 (ASCII
+lowercase l) for small endian machines.  */)
+     ()
+{
+  unsigned i = 0x04030201;
+  int order = *(char *)&i == 4 ? 66 : 108;
+
+  return make_number (order);
+}
+
+
 
 void
 syms_of_data ()
@@ -3281,6 +3295,7 @@ syms_of_data ()
   defsubr (&Sadd1);
   defsubr (&Ssub1);
   defsubr (&Slognot);
+  defsubr (&Sbyteorder);
   defsubr (&Ssubr_arity);
 
   XSYMBOL (Qwholenump)->function = XSYMBOL (Qnatnump)->function;
diff --git a/src/dispextern.h b/src/dispextern.h
index e157a2ff3e6..48893aa133d 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -126,6 +126,9 @@ enum window_part
   ON_RIGHT_MARGIN
 };
 
+/* Number of bits allocated to store fringe bitmap numbers.  */
+#define FRINGE_ID_BITS  8
+
 
 
 /***********************************************************************
@@ -710,10 +713,28 @@ struct glyph_row
   struct display_pos end;
 
   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
-  unsigned left_fringe_bitmap : 4;
+  unsigned left_user_fringe_bitmap : FRINGE_ID_BITS;
+
+  /* Face of the left fringe glyph.  */
+  unsigned left_user_fringe_face_id : FACE_ID_BITS;
+
+  /* Right fringe bitmap number (enum fringe_bitmap_type).  */
+  unsigned right_user_fringe_bitmap : FRINGE_ID_BITS;
+
+  /* Face of the right fringe glyph.  */
+  unsigned right_user_fringe_face_id : FACE_ID_BITS;
+
+  /* Left fringe bitmap number (enum fringe_bitmap_type).  */
+  unsigned left_fringe_bitmap : FRINGE_ID_BITS;
+
+  /* Face of the left fringe glyph.  */
+  unsigned left_fringe_face_id : FACE_ID_BITS;
 
   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
-  unsigned right_fringe_bitmap : 4;
+  unsigned right_fringe_bitmap : FRINGE_ID_BITS;
+
+  /* Face of the right fringe glyph.  */
+  unsigned right_fringe_face_id : FACE_ID_BITS;
 
   /* 1 means that we must draw the bitmaps of this row.  */
   unsigned redraw_fringe_bitmaps_p : 1;
@@ -1609,35 +1630,6 @@ extern int face_change_count;
                                Fringes
  ***********************************************************************/
 
-enum fringe_bitmap_type
-{
-  NO_FRINGE_BITMAP = 0,
-  LEFT_TRUNCATION_BITMAP,
-  RIGHT_TRUNCATION_BITMAP,
-  UP_ARROW_BITMAP,
-  DOWN_ARROW_BITMAP,
-  CONTINUED_LINE_BITMAP,
-  CONTINUATION_LINE_BITMAP,
-  OVERLAY_ARROW_BITMAP,
-  FIRST_LINE_BITMAP,
-  LAST_LINE_BITMAP,
-  FILLED_BOX_CURSOR_BITMAP,
-  HOLLOW_BOX_CURSOR_BITMAP,
-  BAR_CURSOR_BITMAP,
-  HBAR_CURSOR_BITMAP,
-  ZV_LINE_BITMAP,
-  HOLLOW_SQUARE_BITMAP,
-  MAX_FRINGE_BITMAPS
-};
-
-struct fringe_bitmap
-{
-  int width;
-  int height;
-  int period;
-  unsigned char *bits;
-};
-
 /* Structure used to describe where and how to draw a fringe bitmap.
    WHICH is the fringe bitmap to draw.  WD and H is the (adjusted)
    width and height of the bitmap, DH is the height adjustment (if
@@ -1648,14 +1640,17 @@ struct fringe_bitmap
 
 struct draw_fringe_bitmap_params
 {
-  enum fringe_bitmap_type which;
+  int which;  /* enum fringe_bitmap_type */
+  unsigned short *bits;
   int wd, h, dh;
   int x, y;
   int bx, nx, by, ny;
+  unsigned cursor_p : 1;
+  unsigned overlay_p : 1;
   struct face *face;
 };
 
-extern struct fringe_bitmap fringe_bitmaps[MAX_FRINGE_BITMAPS];
+#define MAX_FRINGE_BITMAPS (1<<FRINGE_ID_BITS)
 
 
 /***********************************************************************
@@ -2025,6 +2020,18 @@ struct it
   /* Horizontal matrix position reached in move_it_in_display_line.
      Only set there, not in display_line.  */
   int hpos;
+
+  /* Left fringe bitmap number (enum fringe_bitmap_type).  */
+  unsigned left_user_fringe_bitmap : FRINGE_ID_BITS;
+
+  /* Face of the left fringe glyph.  */
+  unsigned left_user_fringe_face_id : FACE_ID_BITS;
+
+  /* Right fringe bitmap number (enum fringe_bitmap_type).  */
+  unsigned right_user_fringe_bitmap : FRINGE_ID_BITS;
+
+  /* Face of the right fringe glyph.  */
+  unsigned right_user_fringe_face_id : FACE_ID_BITS;
 };
 
 
@@ -2181,6 +2188,11 @@ struct redisplay_interface
   void (*draw_fringe_bitmap) P_ ((struct window *w, struct glyph_row *row,
                                   struct draw_fringe_bitmap_params *p));
 
+  /* Define and destroy fringe bitmap no. WHICH.  */
+  void (*define_fringe_bitmap) P_ ((int which, unsigned short *bits,
+                                    int h, int wd));
+  void (*destroy_fringe_bitmap) P_ ((int which));
+
 /* Get metrics of character CHAR2B in FONT of type FONT_TYPE.
    Value is null if CHAR2B is not contained in the font.  */
   XCharStruct * (*per_char_metric) P_ ((XFontStruct *font, XChar2b *char2b,
@@ -2526,11 +2538,6 @@ void move_it_past_eol P_ ((struct it *));
 int in_display_vector_p P_ ((struct it *));
 int frame_mode_line_height P_ ((struct frame *));
 void highlight_trailing_whitespace P_ ((struct frame *, struct glyph_row *));
-void draw_fringe_bitmap P_ ((struct window *, struct glyph_row *, int));
-void draw_row_fringe_bitmaps P_ ((struct window *, struct glyph_row *));
-void draw_window_fringes P_ ((struct window *));
-int update_window_fringes P_ ((struct window *, int));
-void compute_fringe_widths P_ ((struct frame *, int));
 extern Lisp_Object Qtool_bar;
 extern Lisp_Object Vshow_trailing_whitespace;
 extern int mode_line_in_non_selected_windows;
@@ -2600,6 +2607,20 @@ extern int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
                                        XRectangle *));
 #endif
 
+/* Defined in fringe.c */
+
+int valid_fringe_bitmap_id_p (int);
+void draw_fringe_bitmap P_ ((struct window *, struct glyph_row *, int));
+void draw_row_fringe_bitmaps P_ ((struct window *, struct glyph_row *));
+void draw_window_fringes P_ ((struct window *));
+int update_window_fringes P_ ((struct window *, int));
+void compute_fringe_widths P_ ((struct frame *, int));
+
+#ifdef WINDOWS_NT
+void w32_init_fringe P_ ((void));
+void w32_reset_fringes P_ ((void));
+#endif
+
 /* Defined in sysdep.c */
 
 void get_tty_size P_ ((int, int *, int *));
diff --git a/src/dispnew.c b/src/dispnew.c
index 1bd54a589c4..aaf3c440f34 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1503,7 +1503,10 @@ row_equal_p (w, a, b, mouse_face_p)
       if (a->fill_line_p != b->fill_line_p
           || a->cursor_in_fringe_p != b->cursor_in_fringe_p
           || a->left_fringe_bitmap != b->left_fringe_bitmap
+          || a->left_fringe_face_id != b->left_fringe_face_id
           || a->right_fringe_bitmap != b->right_fringe_bitmap
+          || a->right_fringe_face_id != b->right_fringe_face_id
+          || a->overlay_arrow_p != b->overlay_arrow_p
           || a->exact_window_width_line_p != b->exact_window_width_line_p
           || a->overlapped_p != b->overlapped_p
           || (MATRIX_ROW_CONTINUATION_LINE_P (a)
@@ -3820,10 +3823,15 @@ update_frame (f, force_p, inhibit_hairy_id_p)
       paused_p = update_window_tree (root_window, force_p);
       update_end (f);
 
-#if 0 /* This flush is a performance bottleneck under X,
-         and it doesn't seem to be necessary anyway.  */
-      FRAME_RIF (f)->flush_display (f);
-#endif
+      /* This flush is a performance bottleneck under X,
+         and it doesn't seem to be necessary anyway (in general).
+         It is necessary when resizing the window with the mouse, or
+         at least the fringes are not redrawn in a timely manner.  ++kfs */
+      if (f->force_flush_display_p)
+        {
+          FRAME_RIF (f)->flush_display (f);
+          f->force_flush_display_p = 0;
+        }
     }
   else
     {
@@ -4524,6 +4532,7 @@ update_window_line (w, vpos, mouse_face_overwritten_p)
           || desired_row->y != current_row->y
           || desired_row->visible_height != current_row->visible_height
           || desired_row->cursor_in_fringe_p != current_row->cursor_in_fringe_p
+          || desired_row->overlay_arrow_p != current_row->overlay_arrow_p
           || current_row->redraw_fringe_bitmaps_p
           || desired_row->mode_line_p != current_row->mode_line_p
           || desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p
@@ -5032,7 +5041,10 @@ scrolling_window (w, header_line_p)
             to_overlapped_p = to->overlapped_p;
             if (!from->mode_line_p && !w->pseudo_window_p
                 && (to->left_fringe_bitmap != from->left_fringe_bitmap
-                    || to->right_fringe_bitmap != from->right_fringe_bitmap))
+                    || to->right_fringe_bitmap != from->right_fringe_bitmap
+                    || to->left_fringe_face_id != from->left_fringe_face_id
+                    || to->right_fringe_face_id != from->right_fringe_face_id
+                    || to->overlay_arrow_p != from->overlay_arrow_p))
               from->redraw_fringe_bitmaps_p = 1;
             assign_row (to, from);
             to->enabled_p = 1, from->enabled_p = 0;
diff --git a/src/editfns.c b/src/editfns.c
index d3039ca0273..9a1ce81f316 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1138,7 +1138,7 @@ DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
 
 DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
        doc: /* Return character in current buffer at position POS.
-POS is an integer or a marker.
+POS is an integer or a marker and defaults to point.
 If POS is out of range, the value is nil.  */)
      (pos)
      Lisp_Object pos;
@@ -1171,7 +1171,7 @@ If POS is out of range, the value is nil.  */)
 
 DEFUN ("char-before", Fchar_before, Schar_before, 0, 1, 0,
        doc: /* Return character in current buffer preceding position POS.
-POS is an integer or a marker.
+POS is an integer or a marker and defaults to point.
 If POS is out of range, the value is nil.  */)
      (pos)
      Lisp_Object pos;
diff --git a/src/emacs.c b/src/emacs.c
index 4f66e4bdb07..20c6295e2e2 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1236,6 +1236,9 @@ main (argc, argv
 
       init_window_once ();      /* Init the window system.  */
       init_fileio_once ();      /* Must precede any path manipulation.  */
+#ifdef HAVE_WINDOW_SYSTEM
+      init_fringe_once ();      /* Swap bitmaps if necessary. */
+#endif /* HAVE_WINDOW_SYSTEM */
     }
 
   init_alloc ();
@@ -1500,6 +1503,9 @@ main (argc, argv
 #endif /* WINDOWSNT */
       syms_of_window ();
       syms_of_xdisp ();
+#ifdef HAVE_WINDOW_SYSTEM
+      syms_of_fringe ();
+#endif /* HAVE_WINDOW_SYSTEM */
 #ifdef HAVE_X_WINDOWS
       syms_of_xterm ();
       syms_of_xfns ();
@@ -1581,6 +1587,9 @@ main (argc, argv
 #endif /* HAVE_X_WINDOWS */
   init_fns ();
   init_xdisp ();
+#ifdef HAVE_WINDOW_SYSTEM
+  init_fringe ();
+#endif /* HAVE_WINDOW_SYSTEM */
   init_macros ();
   init_editfns ();
   init_floatfns ();
diff --git a/src/fns.c b/src/fns.c
index 493d7ba2897..1d6767cebab 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2512,14 +2512,26 @@ character set, or a character code.  Return VALUE.  */)
   else if (SYMBOLP (range))
     {
       Lisp_Object charset_info;
+      int charset_id;
 
       charset_info = Fget (range, Qcharset);
-      CHECK_VECTOR (charset_info);
-
-      return Faset (char_table,
-                    make_number (XINT (XVECTOR (charset_info)->contents[0])
-                                 + 128),
-                    value);
+      if (! VECTORP (charset_info)
+          || ! NATNUMP (AREF (charset_info, 0))
+          || (charset_id = XINT (AREF (charset_info, 0)),
+              ! CHARSET_DEFINED_P (charset_id)))
+        error ("Invalid charset: %s", SDATA (SYMBOL_NAME (range)));
+
+      if (charset_id == CHARSET_ASCII)
+        for (i = 0; i < 128; i++)
+          XCHAR_TABLE (char_table)->contents[i] = value;
+      else if (charset_id == CHARSET_8_BIT_CONTROL)
+        for (i = 128; i < 160; i++)
+          XCHAR_TABLE (char_table)->contents[i] = value;
+      else if (charset_id == CHARSET_8_BIT_GRAPHIC)
+        for (i = 160; i < 256; i++)
+          XCHAR_TABLE (char_table)->contents[i] = value;
+      else
+        XCHAR_TABLE (char_table)->contents[charset_id + 128] = value;
     }
   else if (INTEGERP (range))
     Faset (char_table, range, value);
diff --git a/src/frame.h b/src/frame.h
index 14806b2bc04..5037ffd0553 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -438,6 +438,10 @@ struct frame
      Clear the frame in clear_garbaged_frames if set.  */
   unsigned resized_p : 1;
 
+  /* Set to non-zero in when we want for force a flush_display in
+     update_frame, usually after resizing the frame.  */
+  unsigned force_flush_display_p : 1;
+  
   /* All display backends seem to need these two pixel values. */
   unsigned long background_pixel;
   unsigned long foreground_pixel;
diff --git a/src/fringe.c b/src/fringe.c
new file mode 100644
index 00000000000..bd93b4cfce5
--- /dev/null
+++ b/src/fringe.c
@@ -0,0 +1,1362 @@
+/* Fringe handling (split from xdisp.c).
+   Copyright (C) 1985,86,87,88,93,94,95,97,98,99,2000,01,02,03,04
+   Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Emacs 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include <config.h>
+#include <stdio.h>
+
+#include "lisp.h"
+#include "frame.h"
+#include "window.h"
+#include "dispextern.h"
+#include "buffer.h"
+#include "blockinput.h"
+#include "termhooks.h"
+
+#ifdef HAVE_WINDOW_SYSTEM
+
+extern Lisp_Object Qtop, Qbottom, Qcenter;
+
+/* Non-nil means that newline may flow into the right fringe.  */
+
+Lisp_Object Voverflow_newline_into_fringe;
+
+
+enum fringe_bitmap_type
+{
+  NO_FRINGE_BITMAP = 0,
+  UNDEF_FRINGE_BITMAP,
+  LEFT_TRUNCATION_BITMAP,
+  RIGHT_TRUNCATION_BITMAP,
+  UP_ARROW_BITMAP,
+  DOWN_ARROW_BITMAP,
+  CONTINUED_LINE_BITMAP,
+  CONTINUATION_LINE_BITMAP,
+  OVERLAY_ARROW_BITMAP,
+  TOP_LEFT_ANGLE_BITMAP,
+  TOP_RIGHT_ANGLE_BITMAP,
+  BOTTOM_LEFT_ANGLE_BITMAP,
+  BOTTOM_RIGHT_ANGLE_BITMAP,
+  LEFT_BRACKET_BITMAP,
+  RIGHT_BRACKET_BITMAP,
+  FILLED_BOX_CURSOR_BITMAP,
+  HOLLOW_BOX_CURSOR_BITMAP,
+  HOLLOW_SQUARE_BITMAP,
+  BAR_CURSOR_BITMAP,
+  HBAR_CURSOR_BITMAP,
+  ZV_LINE_BITMAP,
+  MAX_STANDARD_FRINGE_BITMAPS
+};
+
+enum fringe_bitmap_align
+{
+  ALIGN_BITMAP_CENTER = 0,
+  ALIGN_BITMAP_TOP,
+  ALIGN_BITMAP_BOTTOM
+};
+
+struct fringe_bitmap
+{
+  unsigned short *bits;
+  unsigned height : 8;
+  unsigned width : 8;
+  unsigned period : 8;
+  unsigned align : 2;
+  unsigned dynamic : 1;
+};
+
+
+/***********************************************************************
+                               Fringe bitmaps
+ ***********************************************************************/
+
+/* Undefined bitmap.  A question mark.  */
+/*
+  ..xxxx..
+  .xxxxxx.
+  xx....xx
+  xx....xx
+  ....xx..
+  ...xx...
+  ...xx...
+  ........
+  ...xx...
+  ...xx...
+*/
+static unsigned short unknown_bits[] = {
+  0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
+
+/* An arrow like this: `<-'.  */
+/*
+  ...xx...
+  ..xx....
+  .xx.....
+  xxxxxx..
+  xxxxxx..
+  .xx.....
+  ..xx....
+  ...xx...
+*/
+static unsigned short left_arrow_bits[] = {
+   0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
+
+
+/* Right truncation arrow bitmap `->'.  */
+/*
+  ...xx...
+  ....xx..
+  .....xx.
+  ..xxxxxx
+  ..xxxxxx
+  .....xx.
+  ....xx..
+  ...xx...
+*/
+static unsigned short right_arrow_bits[] = {
+   0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
+
+
+/* Up arrow bitmap.  */
+/*
+  ...xx...
+  ..xxxx..
+  .xxxxxx.
+  xxxxxxxx
+  ...xx...
+  ...xx...
+  ...xx...
+  ...xx...
+*/
+static unsigned short up_arrow_bits[] = {
+   0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
+
+
+/* Down arrow bitmap.  */
+/*
+  ...xx...
+  ...xx...
+  ...xx...
+  ...xx...
+  xxxxxxxx
+  .xxxxxx.
+  ..xxxx..
+  ...xx...
+*/
+static unsigned short down_arrow_bits[] = {
+   0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
+
+/* Marker for continued lines.  */
+/*
+  ..xxxx..
+  ..xxxxx.
+  ......xx
+  ..x..xxx
+  ..xxxxxx
+  ..xxxxx.
+  ..xxxx..
+  ..xxxxx.
+*/
+static unsigned short continued_bits[] = {
+   0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
+
+/* Marker for continuation lines.  */
+/*
+  ..xxxx..
+  .xxxxx..
+  xx......
+  xxx..x..
+  xxxxxx..
+  .xxxxx..
+  ..xxxx..
+  .xxxxx..
+*/
+static unsigned short continuation_bits[] = {
+   0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
+
+/* Overlay arrow bitmap.  A triangular arrow.  */
+/*
+  xx......
+  xxxx....
+  xxxxx...
+  xxxxxx..
+  xxxxxx..
+  xxxxx...
+  xxxx....
+  xx......
+*/
+static unsigned short ov_bits[] = {
+   0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
+
+#if 0
+/* Reverse Overlay arrow bitmap.  A triangular arrow.  */
+/*
+  ......xx
+  ....xxxx
+  ...xxxxx
+  ..xxxxxx
+  ..xxxxxx
+  ...xxxxx
+  ....xxxx
+  ......xx
+*/
+static unsigned short rev_ov_bits[] = {
+   0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
+#endif
+
+/* First line bitmap.  An top-left angle.  */
+/*
+  xxxxxx..
+  xxxxxx..
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  ........
+*/
+static unsigned short top_left_angle_bits[] = {
+   0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00};
+
+/* First line bitmap.  An right-up angle.  */
+/*
+  ..xxxxxx
+  ..xxxxxx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ........
+*/
+static unsigned short top_right_angle_bits[] = {
+   0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
+
+/* Last line bitmap.  An left-down angle.  */
+/*
+  ........
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xxxxxx..
+  xxxxxx..
+*/
+static unsigned short bottom_left_angle_bits[] = {
+   0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
+
+/* Last line bitmap.  An right-down angle.  */
+/*
+  ........
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ..xxxxxx
+  ..xxxxxx
+*/
+static unsigned short bottom_right_angle_bits[] = {
+   0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
+
+/* First/last line bitmap.  An left bracket.  */
+/*
+  xxxxxx..
+  xxxxxx..
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xxxxxx..
+  xxxxxx..
+*/
+static unsigned short left_bracket_bits[] = {
+   0xfc, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
+
+/* First/last line bitmap.  An right bracket.  */
+/*
+  ..xxxxxx
+  ..xxxxxx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ..xxxxxx
+  ..xxxxxx
+*/
+static unsigned short right_bracket_bits[] = {
+  0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3f, 0x3f};
+
+/* Filled box cursor bitmap.  A filled box; max 13 pixels high.  */
+/*
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+  xxxxxxx.
+*/
+static unsigned short filled_box_cursor_bits[] = {
+   0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
+
+/* Hollow box cursor bitmap.  A hollow box; max 13 pixels high.  */
+/*
+  xxxxxxx.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  x.....x.
+  xxxxxxx.
+*/
+static unsigned short hollow_box_cursor_bits[] = {
+   0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
+
+/* Bar cursor bitmap.  A vertical bar; max 13 pixels high.  */
+/*
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+*/
+static unsigned short bar_cursor_bits[] = {
+   0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
+
+/* HBar cursor bitmap.  A horisontal bar; 2 pixels high.  */
+/*
+  xxxxxxx.
+  xxxxxxx.
+*/
+static unsigned short hbar_cursor_bits[] = {
+  0xfe, 0xfe};
+
+
+/* Bitmap drawn to indicate lines not displaying text if
+   `indicate-empty-lines' is non-nil.  */
+/*
+  ........
+  ..xxxx..
+  ........
+  ........
+  ..xxxx..
+  ........
+*/
+static unsigned short zv_bits[] = {
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
+
+/* Hollow square bitmap.  */
+/*
+  .xxxxxx.
+  .x....x.
+  .x....x.
+  .x....x.
+  .x....x.
+  .xxxxxx.
+*/
+static unsigned short hollow_square_bits[] = {
+   0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
+
+
+#define BYTES_PER_BITMAP_ROW  (sizeof (unsigned short))
+#define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
+#define FRBITS(bits)  bits, STANDARD_BITMAP_HEIGHT (bits)
+
+struct fringe_bitmap standard_bitmaps[MAX_STANDARD_FRINGE_BITMAPS] =
+{
+  { NULL, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
+  { FRBITS (unknown_bits),            8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (left_arrow_bits),         8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (right_arrow_bits),        8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (up_arrow_bits),           8, 0, ALIGN_BITMAP_TOP,    0 },
+  { FRBITS (down_arrow_bits),         8, 0, ALIGN_BITMAP_BOTTOM, 0 },
+  { FRBITS (continued_bits),          8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (continuation_bits),       8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (ov_bits),                 8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (top_left_angle_bits),     8, 0, ALIGN_BITMAP_TOP,    0 },
+  { FRBITS (top_right_angle_bits),    8, 0, ALIGN_BITMAP_TOP,    0 },
+  { FRBITS (bottom_left_angle_bits),  8, 0, ALIGN_BITMAP_BOTTOM, 0 },
+  { FRBITS (bottom_right_angle_bits), 8, 0, ALIGN_BITMAP_BOTTOM, 0 },
+  { FRBITS (left_bracket_bits),       8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (right_bracket_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (filled_box_cursor_bits),  8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (hollow_box_cursor_bits),  8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (hollow_square_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (bar_cursor_bits),         8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (hbar_cursor_bits),        8, 0, ALIGN_BITMAP_BOTTOM, 0 },
+  { FRBITS (zv_bits),                 8, 3, ALIGN_BITMAP_TOP,    0 },
+};
+
+static struct fringe_bitmap *fringe_bitmaps[MAX_FRINGE_BITMAPS];
+static unsigned fringe_faces[MAX_FRINGE_BITMAPS];
+
+static int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS;
+
+/* Return 1 if FRINGE_ID is a valid fringe bitmap id.  */
+
+int
+valid_fringe_bitmap_id_p (fringe_id)
+     int fringe_id;
+{
+  return (fringe_id >= NO_FRINGE_BITMAP
+          && fringe_id < max_used_fringe_bitmap
+          && (fringe_id < MAX_STANDARD_FRINGE_BITMAPS
+              || fringe_bitmaps[fringe_id] != NULL));
+}
+
+/* Draw the bitmap WHICH in one of the left or right fringes of
+   window W.  ROW is the glyph row for which to display the bitmap; it
+   determines the vertical position at which the bitmap has to be
+   drawn.
+   LEFT_P is 1 for left fringe, 0 for right fringe.
+*/
+
+void
+draw_fringe_bitmap_1 (w, row, left_p, overlay, which)
+     struct window *w;
+     struct glyph_row *row;
+     int left_p, overlay;
+     enum fringe_bitmap_type which;
+{
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+  struct draw_fringe_bitmap_params p;
+  struct fringe_bitmap *fb;
+  int period;
+  int face_id = DEFAULT_FACE_ID;
+
+  p.cursor_p = 0;
+  p.overlay_p = (overlay & 1) == 1;
+  p.cursor_p = (overlay & 2) == 2;
+
+  if (which != NO_FRINGE_BITMAP)
+    {
+    }
+  else if (left_p)
+    {
+      which = row->left_fringe_bitmap;
+      face_id = row->left_fringe_face_id;
+    }
+  else
+    {
+      which = row->right_fringe_bitmap;
+      face_id = row->right_fringe_face_id;
+    }
+
+  if (face_id == DEFAULT_FACE_ID)
+    face_id = fringe_faces[which];
+
+  fb = fringe_bitmaps[which];
+  if (fb == NULL)
+    fb = &standard_bitmaps[which < MAX_STANDARD_FRINGE_BITMAPS
+                           ? which : UNDEF_FRINGE_BITMAP];
+
+  period = fb->period;
+
+  /* Convert row to frame coordinates.  */
+  p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+
+  p.which = which;
+  p.bits = fb->bits;
+  p.wd = fb->width;
+
+  p.h = fb->height;
+  p.dh = (period > 0 ? (p.y % period) : 0);
+  p.h -= p.dh;
+  /* Clip bitmap if too high.  */
+  if (p.h > row->height)
+    p.h = row->height;
+
+  p.face = FACE_FROM_ID (f, face_id);
+
+  if (p.face == NULL)
+    {
+      /* Why does this happen?  ++kfs */
+      return;
+    }
+
+  PREPARE_FACE_FOR_DISPLAY (f, p.face);
+
+  /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
+     the fringe.  */
+  p.bx = -1;
+  if (left_p)
+    {
+      int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
+      int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+                                   ? LEFT_MARGIN_AREA
+                                   : TEXT_AREA));
+      if (p.wd > wd)
+        p.wd = wd;
+      p.x = x - p.wd - (wd - p.wd) / 2;
+
+      if (p.wd < wd || row->height > p.h)
+        {
+          /* If W has a vertical border to its left, don't draw over it.  */
+          wd -= ((!WINDOW_LEFTMOST_P (w)
+                  && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
+                 ? 1 : 0);
+          p.bx = x - wd;
+          p.nx = wd;
+        }
+    }
+  else
+    {
+      int x = window_box_right (w,
+                                (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+                                 ? RIGHT_MARGIN_AREA
+                                 : TEXT_AREA));
+      int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
+      if (p.wd > wd)
+        p.wd = wd;
+      p.x = x + (wd - p.wd) / 2;
+      /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
+         the fringe.  */
+      if (p.wd < wd || row->height > p.h)
+        {
+          p.bx = x;
+          p.nx = wd;
+        }
+    }
+
+  if (p.bx >= 0)
+    {
+      int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
+
+      p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
+      p.ny = row->visible_height;
+    }
+
+  /* Adjust y to the offset in the row to start drawing the bitmap.  */
+  switch (fb->align)
+    {
+    case ALIGN_BITMAP_CENTER:
+      p.y += (row->height - p.h) / 2;
+      break;
+    case ALIGN_BITMAP_BOTTOM:
+      p.h = fb->height;
+      p.y += (row->visible_height - p.h);
+      break;
+    case ALIGN_BITMAP_TOP:
+      break;
+    }
+
+  FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
+}
+
+void
+draw_fringe_bitmap (w, row, left_p)
+     struct window *w;
+     struct glyph_row *row;
+     int left_p;
+{
+  int overlay = 0;
+
+  if (!left_p && row->cursor_in_fringe_p)
+    {
+      int cursor = NO_FRINGE_BITMAP;
+
+      switch (w->phys_cursor_type)
+        {
+        case HOLLOW_BOX_CURSOR:
+          if (row->visible_height >= STANDARD_BITMAP_HEIGHT (hollow_box_cursor_bits))
+            cursor = HOLLOW_BOX_CURSOR_BITMAP;
+          else
+            cursor = HOLLOW_SQUARE_BITMAP;
+          break;
+        case FILLED_BOX_CURSOR:
+          cursor = FILLED_BOX_CURSOR_BITMAP;
+          break;
+        case BAR_CURSOR:
+          cursor = BAR_CURSOR_BITMAP;
+          break;
+        case HBAR_CURSOR:
+          cursor = HBAR_CURSOR_BITMAP;
+          break;
+        case NO_CURSOR:
+        default:
+          w->phys_cursor_on_p = 0;
+          row->cursor_in_fringe_p = 0;
+          break;
+        }
+      if (cursor != NO_FRINGE_BITMAP)
+        {
+          draw_fringe_bitmap_1 (w, row, 0, 2, cursor);
+          overlay = cursor == FILLED_BOX_CURSOR_BITMAP ? 3 : 1;
+        }
+    }
+
+  draw_fringe_bitmap_1 (w, row, left_p, overlay, NO_FRINGE_BITMAP);
+
+  if (left_p && row->overlay_arrow_p)
+    draw_fringe_bitmap_1 (w, row, 1, 1, OVERLAY_ARROW_BITMAP);
+}
+
+
+/* Draw fringe bitmaps for glyph row ROW on window W.  Call this
+   function with input blocked.  */
+
+void
+draw_row_fringe_bitmaps (w, row)
+     struct window *w;
+     struct glyph_row *row;
+{
+  xassert (interrupt_input_blocked);
+
+  /* If row is completely invisible, because of vscrolling, we
+     don't have to draw anything.  */
+  if (row->visible_height <= 0)
+    return;
+
+  if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
+    draw_fringe_bitmap (w, row, 1);
+
+  if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
+    draw_fringe_bitmap (w, row, 0);
+}
+
+/* Draw the fringes of window W.  Only fringes for rows marked for
+   update in redraw_fringe_bitmaps_p are drawn.  */
+
+void
+draw_window_fringes (w)
+     struct window *w;
+{
+  struct glyph_row *row;
+  int yb = window_text_bottom_y (w);
+  int nrows = w->current_matrix->nrows;
+  int y = 0, rn;
+
+  if (w->pseudo_window_p)
+    return;
+
+  for (y = 0, rn = 0, row = w->current_matrix->rows;
+       y < yb && rn < nrows;
+       y += row->height, ++row, ++rn)
+    {
+      if (!row->redraw_fringe_bitmaps_p)
+        continue;
+      draw_row_fringe_bitmaps (w, row);
+      row->redraw_fringe_bitmaps_p = 0;
+    }
+}
+
+
+/* Recalculate the bitmaps to show in the fringes of window W.
+   If FORCE_P is 0, only mark rows with modified bitmaps for update in
+   redraw_fringe_bitmaps_p; else mark all rows for update.  */
+
+int
+update_window_fringes (w, force_p)
+     struct window *w;
+     int force_p;
+{
+  struct glyph_row *row, *cur = 0;
+  int yb = window_text_bottom_y (w);
+  int rn, nrows = w->current_matrix->nrows;
+  int y;
+  int redraw_p = 0;
+  Lisp_Object ind;
+  int boundary_pos = 0, arrow_pos = 0;
+  int empty_pos = 0;
+
+  if (w->pseudo_window_p)
+    return 0;
+
+  if (!MINI_WINDOW_P (w)
+      && (ind = XBUFFER (w->buffer)->indicate_buffer_boundaries, !NILP (ind)))
+    {
+      int do_eob = 1, do_bob = 1;
+      Lisp_Object arrows;
+
+      if (CONSP (ind))
+        arrows = XCDR (ind), ind = XCAR (ind);
+      else
+        arrows = ind;
+
+      if (EQ (ind, Qleft))
+        boundary_pos = -1;
+      else if (EQ (ind, Qright))
+        boundary_pos = 1;
+
+      if (EQ (arrows, Qleft))
+        arrow_pos = -1;
+      else if (EQ (arrows, Qright))
+        arrow_pos = 1;
+
+      for (y = 0, rn = 0;
+           y < yb && rn < nrows;
+           y += row->height, ++rn)
+        {
+          unsigned indicate_bob_p, indicate_top_line_p;
+          unsigned indicate_eob_p, indicate_bottom_line_p;
+          
+          row = w->desired_matrix->rows + rn;
+          if (!row->enabled_p)
+            row = w->current_matrix->rows + rn;
+
+          indicate_bob_p = row->indicate_bob_p;
+          indicate_top_line_p = row->indicate_top_line_p;
+          indicate_eob_p = row->indicate_eob_p;
+          indicate_bottom_line_p = row->indicate_bottom_line_p;
+          
+          row->indicate_bob_p = row->indicate_top_line_p = 0;
+          row->indicate_eob_p = row->indicate_bottom_line_p = 0;
+
+          if (!NILP (ind)
+              && MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer)))
+            row->indicate_bob_p = do_bob, do_bob = 0;
+          else if (!NILP (arrows)
+                   && (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0) == rn)
+            row->indicate_top_line_p = 1;
+
+          if (!NILP (ind)
+              && MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer)))
+            row->indicate_eob_p = do_eob, do_eob = 0;
+          else if (!NILP (arrows)
+                   && y + row->height >= yb)
+            row->indicate_bottom_line_p = 1;
+
+          if (indicate_bob_p != row->indicate_bob_p
+              || indicate_top_line_p != row->indicate_top_line_p
+              || indicate_eob_p != row->indicate_eob_p
+              || indicate_bottom_line_p != row->indicate_bottom_line_p)
+            row->redraw_fringe_bitmaps_p = 1;
+        }
+    }
+
+  if (EQ (XBUFFER (w->buffer)->indicate_empty_lines, Qright))
+    empty_pos = 1;
+  else if (EQ (XBUFFER (w->buffer)->indicate_empty_lines, Qleft))
+    empty_pos = -1;
+
+  for (y = 0, rn = 0;
+       y < yb && rn < nrows;
+       y += row->height, rn++)
+    {
+      enum fringe_bitmap_type left, right;
+      unsigned left_face_id, right_face_id;
+
+      row = w->desired_matrix->rows + rn;
+      cur = w->current_matrix->rows + rn;
+      if (!row->enabled_p)
+        row = cur;
+
+      left_face_id = right_face_id = DEFAULT_FACE_ID;
+
+      /* Decide which bitmap to draw in the left fringe.  */
+      if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
+        left = NO_FRINGE_BITMAP;
+      else if (row->left_user_fringe_bitmap != NO_FRINGE_BITMAP)
+        {
+          left = row->left_user_fringe_bitmap;
+          left_face_id = row->left_user_fringe_face_id;
+        }
+#if 0  /* this is now done via an overlay */
+      else if (row->overlay_arrow_p)
+        left = OVERLAY_ARROW_BITMAP;
+#endif
+      else if (row->indicate_bob_p && boundary_pos <= 0)
+        left = ((row->indicate_eob_p && boundary_pos < 0)
+                ? LEFT_BRACKET_BITMAP : TOP_LEFT_ANGLE_BITMAP);
+      else if (row->indicate_eob_p && boundary_pos < 0)
+        left = BOTTOM_LEFT_ANGLE_BITMAP;
+      else if (row->truncated_on_left_p)
+        left = LEFT_TRUNCATION_BITMAP;
+      else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
+        left = CONTINUATION_LINE_BITMAP;
+      else if (row->indicate_empty_line_p && empty_pos <= 0)
+        left = ZV_LINE_BITMAP;
+      else if (row->indicate_top_line_p && arrow_pos <= 0)
+        left = UP_ARROW_BITMAP;
+      else if (row->indicate_bottom_line_p && arrow_pos < 0)
+        left = DOWN_ARROW_BITMAP;
+      else
+        left = NO_FRINGE_BITMAP;
+
+      /* Decide which bitmap to draw in the right fringe.  */
+      if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
+        right = NO_FRINGE_BITMAP;
+      else if (row->right_user_fringe_bitmap != NO_FRINGE_BITMAP)
+        {
+          right = row->right_user_fringe_bitmap;
+          right_face_id = row->right_user_fringe_face_id;
+        }
+      else if (row->indicate_bob_p && boundary_pos > 0)
+        right = ((row->indicate_eob_p && boundary_pos >= 0)
+                 ? RIGHT_BRACKET_BITMAP : TOP_RIGHT_ANGLE_BITMAP);
+      else if (row->indicate_eob_p && boundary_pos >= 0)
+        right = BOTTOM_RIGHT_ANGLE_BITMAP;
+      else if (row->truncated_on_right_p)
+        right = RIGHT_TRUNCATION_BITMAP;
+      else if (row->continued_p)
+        right = CONTINUED_LINE_BITMAP;
+      else if (row->indicate_top_line_p && arrow_pos > 0)
+        right = UP_ARROW_BITMAP;
+      else if (row->indicate_bottom_line_p && arrow_pos >= 0)
+        right = DOWN_ARROW_BITMAP;
+      else if (row->indicate_empty_line_p
+               && (empty_pos > 0
+                   || (WINDOW_LEFT_FRINGE_WIDTH (w) == 0 && empty_pos == 0)))
+        right = ZV_LINE_BITMAP;
+      else
+        right = NO_FRINGE_BITMAP;
+
+      if (force_p
+          || row->y != cur->y
+          || row->visible_height != cur->visible_height
+          || left != cur->left_fringe_bitmap
+          || right != cur->right_fringe_bitmap
+          || left_face_id != cur->left_fringe_face_id
+          || right_face_id != cur->right_fringe_face_id
+          || cur->redraw_fringe_bitmaps_p)
+        {
+          redraw_p = row->redraw_fringe_bitmaps_p = cur->redraw_fringe_bitmaps_p = 1;
+          cur->left_fringe_bitmap = left;
+          cur->right_fringe_bitmap = right;
+          cur->left_fringe_face_id = left_face_id;
+          cur->right_fringe_face_id = right_face_id;
+        }
+
+      if (row->overlay_arrow_p != cur->overlay_arrow_p)
+        {
+          redraw_p = row->redraw_fringe_bitmaps_p = cur->redraw_fringe_bitmaps_p = 1;
+          cur->overlay_arrow_p = row->overlay_arrow_p;
+        }
+
+      row->left_fringe_bitmap = left;
+      row->right_fringe_bitmap = right;
+      row->left_fringe_face_id = left_face_id;
+      row->right_fringe_face_id = right_face_id;
+    }
+
+  return redraw_p;
+}
+
+
+/* Compute actual fringe widths for frame F.  
+
+   If REDRAW is 1, redraw F if the fringe settings was actually
+   modified and F is visible.
+
+   Since the combined left and right fringe must occupy an integral
+   number of columns, we may need to add some pixels to each fringe.
+   Typically, we add an equal amount (+/- 1 pixel) to each fringe,
+   but a negative width value is taken literally (after negating it).
+
+   We never make the fringes narrower than specified.  It is planned
+   to make fringe bitmaps customizable and expandable, and at that
+   time, the user will typically specify the minimum number of pixels
+   needed for his bitmaps, so we shouldn't select anything less than
+   what is specified.
+*/
+
+void
+compute_fringe_widths (f, redraw)
+     struct frame *f;
+     int redraw;
+{
+  int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
+  int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
+  int o_cols = FRAME_FRINGE_COLS (f);
+
+  Lisp_Object left_fringe = Fassq (Qleft_fringe, f->param_alist);
+  Lisp_Object right_fringe = Fassq (Qright_fringe, f->param_alist);
+  int left_fringe_width, right_fringe_width;
+
+  if (!NILP (left_fringe))
+    left_fringe = Fcdr (left_fringe);
+  if (!NILP (right_fringe))
+    right_fringe = Fcdr (right_fringe);
+
+  left_fringe_width = ((NILP (left_fringe) || !INTEGERP (left_fringe)) ? 8 :
+                       XINT (left_fringe));
+  right_fringe_width = ((NILP (right_fringe) || !INTEGERP (right_fringe)) ? 8 :
+                        XINT (right_fringe));
+
+  if (left_fringe_width || right_fringe_width)
+    {
+      int left_wid = left_fringe_width >= 0 ? left_fringe_width : -left_fringe_width;
+      int right_wid = right_fringe_width >= 0 ? right_fringe_width : -right_fringe_width;
+      int conf_wid = left_wid + right_wid;
+      int font_wid = FRAME_COLUMN_WIDTH (f);
+      int cols = (left_wid + right_wid + font_wid-1) / font_wid;
+      int real_wid = cols * font_wid;
+      if (left_wid && right_wid)
+        {
+          if (left_fringe_width < 0)
+            {
+              /* Left fringe width is fixed, adjust right fringe if necessary */
+              FRAME_LEFT_FRINGE_WIDTH (f) = left_wid;
+              FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
+            }
+          else if (right_fringe_width < 0)
+            {
+              /* Right fringe width is fixed, adjust left fringe if necessary */
+              FRAME_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
+              FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid;
+            }
+          else
+            {
+              /* Adjust both fringes with an equal amount.
+                 Note that we are doing integer arithmetic here, so don't
+                 lose a pixel if the total width is an odd number.  */
+              int fill = real_wid - conf_wid;
+              FRAME_LEFT_FRINGE_WIDTH (f) = left_wid + fill/2;
+              FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
+            }
+        }
+      else if (left_fringe_width)
+        {
+          FRAME_LEFT_FRINGE_WIDTH (f) = real_wid;
+          FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
+        }
+      else
+        {
+          FRAME_LEFT_FRINGE_WIDTH (f) = 0;
+          FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
+        }
+      FRAME_FRINGE_COLS (f) = cols;
+    }
+  else
+    {
+      FRAME_LEFT_FRINGE_WIDTH (f) = 0;
+      FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
+      FRAME_FRINGE_COLS (f) = 0;
+    }
+
+  if (redraw && FRAME_VISIBLE_P (f))
+    if (o_left != FRAME_LEFT_FRINGE_WIDTH (f) ||
+        o_right != FRAME_RIGHT_FRINGE_WIDTH (f) ||
+        o_cols != FRAME_FRINGE_COLS (f))
+      redraw_frame (f);
+}
+
+DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap, Sdestroy_fringe_bitmap,
+       1, 1, 0,
+       doc: /* Destroy fringe bitmap WHICH.
+If WHICH overrides a standard fringe bitmap, the original bitmap is restored.  */)
+  (which)
+     Lisp_Object which;
+{
+  int n;
+  struct fringe_bitmap **fbp;
+
+  CHECK_NUMBER (which);
+  if (n = XINT (which), n >= max_used_fringe_bitmap)
+    return Qnil;
+
+  fringe_faces[n] = FRINGE_FACE_ID;
+
+  fbp = &fringe_bitmaps[n];
+  if (*fbp && (*fbp)->dynamic)
+    {
+      /* XXX Is SELECTED_FRAME OK here? */
+      if (FRAME_RIF (SELECTED_FRAME ())->destroy_fringe_bitmap)
+        FRAME_RIF (SELECTED_FRAME ())->destroy_fringe_bitmap (n);
+      xfree (*fbp);
+      *fbp = NULL;
+    }
+
+  while (max_used_fringe_bitmap > MAX_STANDARD_FRINGE_BITMAPS
+         && fringe_bitmaps[max_used_fringe_bitmap - 1] == NULL)
+    max_used_fringe_bitmap--;
+
+  return Qnil;
+}
+
+
+/* Initialize bitmap bit.
+
+   On X, we bit-swap the built-in bitmaps and reduce bitmap
+   from short to char array if width is <= 8 bits.
+
+   On MAC with big-endian CPU, we need to byte-swap each short.
+
+   On W32 and MAC (little endian), there's no need to do this.
+*/
+
+void
+init_fringe_bitmap (which, fb, once_p)
+     enum fringe_bitmap_type which;
+     struct fringe_bitmap *fb;
+     int once_p;
+{
+  if (once_p || fb->dynamic)
+    {
+#if defined (HAVE_X_WINDOWS)
+      static unsigned char swap_nibble[16]
+        = { 0x0, 0x8, 0x4, 0xc,    /* 0000 1000 0100 1100 */
+            0x2, 0xa, 0x6, 0xe,    /* 0010 1010 0110 1110 */
+            0x1, 0x9, 0x5, 0xd,    /* 0001 1001 0101 1101 */
+            0x3, 0xb, 0x7, 0xf };  /* 0011 1011 0111 1111 */
+      unsigned short *bits = fb->bits;
+      int j;
+
+      if (fb->width <= 8)
+        {
+          unsigned char *cbits = (unsigned char *)fb->bits;
+          for (j = 0; j < fb->height; j++)
+            {
+              unsigned short b = *bits++;
+              unsigned char c;
+              c = (unsigned char)((swap_nibble[b & 0xf] << 4)
+                                  | (swap_nibble[(b>>4) & 0xf]));
+              *cbits++ = (c >> (8 - fb->width));
+            }
+        }
+      else
+        {
+          for (j = 0; j < fb->height; j++)
+            {
+              unsigned short b = *bits;
+              b = (unsigned short)((swap_nibble[b & 0xf] << 12)
+                                   | (swap_nibble[(b>>4) & 0xf] << 8)
+                                   | (swap_nibble[(b>>8) & 0xf] << 4)
+                                   | (swap_nibble[(b>>12) & 0xf]));
+              *bits++ = (b >> (16 - fb->width));
+            }
+        }
+#endif /* HAVE_X_WINDOWS */
+
+#if defined (MAC_OS) && defined (WORDS_BIG_ENDIAN)
+      unsigned short *bits = fb->bits;
+      int j;
+      for (j = 0; j < fb->height; j++)
+        {
+          unsigned short b = *bits;
+          *bits++ = ((b >> 8) & 0xff) | ((b & 0xff) << 8);
+        }
+#endif /* MAC_OS && WORDS_BIG_ENDIAN */
+    }
+
+  if (!once_p)
+    {
+      Fdestroy_fringe_bitmap (make_number (which));
+
+      /* XXX Is SELECTED_FRAME OK here? */
+      if (FRAME_RIF (SELECTED_FRAME ())->define_fringe_bitmap)
+        FRAME_RIF (SELECTED_FRAME ())->define_fringe_bitmap (which, fb->bits, fb->height, fb->width);
+
+      fringe_bitmaps[which] = fb;
+      if (which >= max_used_fringe_bitmap)
+        max_used_fringe_bitmap = which + 1;
+    }
+}
+
+
+DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap, Sdefine_fringe_bitmap,
+       1, 5, 0,
+       doc: /* Define a fringe bitmap from BITS of height HEIGHT and width WIDTH.
+BITS is either a string or a vector of integers.
+HEIGHT is height of bitmap.  If HEIGHT is nil, use length of BITS.
+WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
+Optional forth arg ALIGN may be one of `top', `center', or `bottom',
+indicating the positioning of the bitmap relative to the rows where it
+is used; the default is to center the bitmap.  Fourth arg may also be a
+list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
+should be repeated.
+Optional fifth argument WHICH is bitmap number to redefine.
+Return new bitmap number, or nil of no more free bitmap slots.  */)
+  (bits, height, width, align, which)
+     Lisp_Object bits, height, width, align, which;
+{
+  Lisp_Object len;
+  int n, h, i, j;
+  unsigned short *b;
+  struct fringe_bitmap fb, *xfb;
+  int fill1 = 0, fill2 = 0;
+
+  if (!STRINGP (bits) && !VECTORP (bits))
+    bits = wrong_type_argument (Qstringp, bits);
+
+  len = Flength (bits);
+
+  if (NILP (height))
+    h = fb.height = XINT (len);
+  else
+    {
+      CHECK_NUMBER (height);
+      fb.height = min (XINT (height), 255);
+      if (fb.height > XINT (len))
+        {
+          h = XINT (len);
+          fill1 = (fb.height - h) / 2;
+          fill2 = fb.height - h - fill1;
+        }
+    }
+  
+  if (NILP (width))
+    fb.width = 8;
+  else
+    {
+      CHECK_NUMBER (width);
+      fb.width = min (XINT (width), 255);
+    }
+
+  fb.period = 0;
+  fb.align = ALIGN_BITMAP_CENTER;
+
+  if (CONSP (align))
+    {
+      Lisp_Object period = XCDR (align);
+      if (CONSP (period))
+        {
+          period = XCAR (period);
+          if (!NILP (period))
+            {
+              fb.period = fb.height;
+              fb.height = 255;
+            }
+        }
+      align = XCAR (align);
+    }
+  if (EQ (align, Qtop))
+    fb.align = ALIGN_BITMAP_TOP;
+  else if (EQ (align, Qbottom))
+    fb.align = ALIGN_BITMAP_BOTTOM;
+  else if (!NILP (align) && !EQ (align, Qcenter))
+    error ("Bad align argument");
+
+  if (NILP (which))
+    {
+      if (max_used_fringe_bitmap < MAX_FRINGE_BITMAPS)
+        n = max_used_fringe_bitmap++;
+      else
+        {
+          for (n = MAX_STANDARD_FRINGE_BITMAPS;
+               n < MAX_FRINGE_BITMAPS;
+               n++)
+            if (fringe_bitmaps[n] == NULL)
+              break;
+          if (n == MAX_FRINGE_BITMAPS)
+            return Qnil;
+        }
+      which = make_number (n);
+    }
+  else
+    {
+      CHECK_NUMBER (which);
+      n = XINT (which);
+      if (n <= NO_FRINGE_BITMAP || n >= MAX_FRINGE_BITMAPS)
+        error ("Invalid fringe bitmap number");
+    }
+
+  fb.dynamic = 1;
+
+  xfb = (struct fringe_bitmap *)xmalloc (sizeof fb
+                                         + fb.height * BYTES_PER_BITMAP_ROW);
+  fb.bits = b = (unsigned short *)(xfb+1);
+  bzero (b, fb.height);
+
+  j = 0;
+  while (j < fb.height)
+    {
+      for (i = 0; i < fill1 && j < fb.height; i++)
+        b[j++] = 0;
+      for (i = 0; i < h && j < fb.height; i++)
+        {
+          Lisp_Object elt = Faref (bits, make_number (i));
+          b[j++] = NUMBERP (elt) ? XINT (elt) : 0;
+        }
+      for (i = 0; i < fill2 && j < fb.height; i++)
+        b[j++] = 0;
+    }
+
+  *xfb = fb;
+
+  init_fringe_bitmap (n, xfb, 0);
+
+  return which;
+}
+
+DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
+       1, 2, 0,
+       doc:  /* Set face for fringe bitmap FRINGE-ID to FACE.
+If FACE is nil, reset face to default fringe face.  */)
+  (fringe_id, face)
+     Lisp_Object fringe_id, face;
+{
+  int face_id;
+
+  CHECK_NUMBER (fringe_id);
+  if (!valid_fringe_bitmap_id_p (XINT (fringe_id)))
+    error ("Invalid fringe id");
+
+  if (!NILP (face))
+    {
+      face_id = lookup_named_face (SELECTED_FRAME (), face, 'A');
+      if (face_id < 0)
+        error ("No such face");
+    }
+  else
+    face_id = FRINGE_FACE_ID;
+
+  fringe_faces [XINT (fringe_id)] = face_id;
+
+  return Qnil;
+}
+
+DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos, Sfringe_bitmaps_at_pos,
+       0, 2, 0,
+       doc:  /* Return fringe bitmaps of row containing position POS in window WINDOW.
+If WINDOW is nil, use selected window.  If POS is nil, use value of point
+in that window.  Return value is a cons (LEFT . RIGHT) where LEFT and RIGHT
+are the fringe bitmap numbers for the bitmaps in the left and right fringe,
+resp.  Return nil if POS is not visible in WINDOW.  */)
+  (pos, window)
+     Lisp_Object pos, window;
+{
+  struct window *w;
+  struct buffer *old_buffer = NULL;
+  struct glyph_row *row;
+  int textpos;
+
+  if (NILP (window))
+    window = selected_window;
+  CHECK_WINDOW (window);
+  w = XWINDOW (window);
+
+  if (!NILP (pos))
+    {
+      CHECK_NUMBER_COERCE_MARKER (pos);
+      textpos = XINT (pos);
+    }
+  else if (w == XWINDOW (selected_window))
+    textpos = PT;
+  else
+    textpos = XMARKER (w->pointm)->charpos;
+
+  row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
+  row = row_containing_pos (w, textpos, row, NULL, 0);
+  if (row)
+    return Fcons (make_number (row->left_fringe_bitmap),
+                  make_number (row->right_fringe_bitmap));
+  else
+    return Qnil;
+}
+
+
+/***********************************************************************
+                            Initialization
+ ***********************************************************************/
+
+void
+syms_of_fringe ()
+{
+
+  defsubr (&Sdestroy_fringe_bitmap);
+  defsubr (&Sdefine_fringe_bitmap);
+  defsubr (&Sfringe_bitmaps_at_pos);
+  defsubr (&Sset_fringe_bitmap_face);
+
+  DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe,
+    doc: /* *Non-nil means that newline may flow into the right fringe.
+This means that display lines which are exactly as wide as the window
+(not counting the final newline) will only occupy one screen line, by
+showing (or hiding) the final newline in the right fringe; when point
+is at the final newline, the cursor is shown in the right fringe.
+If nil, also continue lines which are exactly as wide as the window.  */);
+  Voverflow_newline_into_fringe = Qt;
+
+}
+
+/* Initialize this module when Emacs starts.  */
+
+void
+init_fringe_once ()
+{
+  enum fringe_bitmap_type bt;
+
+  for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
+    init_fringe_bitmap(bt, &standard_bitmaps[bt], 1);
+}
+
+void
+init_fringe ()
+{
+  int i;
+
+  bzero (fringe_bitmaps, sizeof fringe_bitmaps);
+  for (i = 0; i < MAX_FRINGE_BITMAPS; i++)
+    fringe_faces[i] = FRINGE_FACE_ID;
+}
+
+#ifdef HAVE_NTGUI
+
+void
+w32_init_fringe ()
+{
+  enum fringe_bitmap_type bt;
+
+  for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
+    {
+      struct fringe_bitmap *fb = &standard_bitmaps[bt];
+      rif->define_fringe_bitmap (bt, fb->bits, fb->height, fb->width);
+    }
+}
+
+void
+w32_reset_fringes ()
+{
+  /* Destroy row bitmaps.  */
+  int bt;
+  
+  for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++)
+    rif->destroy_fringe_bitmap (bt);
+}
+
+#endif /* HAVE_NTGUI */
+
+#endif /* HAVE_WINDOW_SYSTEM */
+
+/* arch-tag: 04596920-43eb-473d-b319-82712338162d
+   (do not change this comment) */
diff --git a/src/keyboard.c b/src/keyboard.c
index 11e1d18c7d5..8223049d79d 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1322,6 +1322,7 @@ cancel_hourglass_unwind (arg)
      Lisp_Object arg;
 {
   cancel_hourglass ();
+  return Qnil;
 }
 #endif
 
diff --git a/src/keymap.c b/src/keymap.c
index d03c84aa69d..4cea62c10fb 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1,5 +1,5 @@
 /* Manipulation of keymaps
-   Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000, 2001
+   Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000, 01, 2004
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -2321,7 +2321,7 @@ shadow_lookup (shadow, key, flag)
   return Qnil;
 }
 
-static Lisp_Object Vmenu_events;
+static Lisp_Object Vmouse_events;
 
 /* This function can GC if Flookup_key autoloads any keymaps.  */
 
@@ -2378,7 +2378,7 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap)
       /* if (nomenus && !ascii_sequence_p (this)) */
       if (nomenus && XINT (last) >= 0
           && SYMBOLP (tem = Faref (this, make_number (0)))
-          && !NILP (Fmemq (XCAR (parse_modifiers (tem)), Vmenu_events)))
+          && !NILP (Fmemq (XCAR (parse_modifiers (tem)), Vmouse_events)))
         /* If no menu entries should be returned, skip over the
            keymaps bound to `menu-bar' and `tool-bar' and other
            non-ascii prefixes like `C-down-mouse-2'.  */
@@ -3710,13 +3710,17 @@ This keymap works like `function-key-map', but comes after that,
 and applies even for keys that have ordinary bindings.  */);
   Vkey_translation_map = Qnil;
 
-  staticpro (&Vmenu_events);
-  Vmenu_events = Fcons (intern ("menu-bar"),
-                       Fcons (intern ("tool-bar"),
-                              Fcons (intern ("mouse-1"),
-                                     Fcons (intern ("mouse-2"),
-                                            Fcons (intern ("mouse-3"),
-                                                   Qnil)))));
+  staticpro (&Vmouse_events);
+  Vmouse_events = Fcons (intern ("menu-bar"),
+                  Fcons (intern ("tool-bar"),
+                  Fcons (intern ("header-line"),
+                  Fcons (intern ("mode-line"),
+                  Fcons (intern ("mouse-1"),
+                  Fcons (intern ("mouse-2"),
+                  Fcons (intern ("mouse-3"),
+                  Fcons (intern ("mouse-4"),
+                  Fcons (intern ("mouse-5"),
+                         Qnil)))))))));
 
 
   Qsingle_key_description = intern ("single-key-description");
diff --git a/src/lisp.h b/src/lisp.h
index 570d5ff9757..a0bc2af24bb 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2301,6 +2301,11 @@ EXFUN (Ftruncate, 2);
 extern void init_floatfns P_ ((void));
 extern void syms_of_floatfns P_ ((void));
 
+/* Defined in fringe.c */
+extern void syms_of_fringe P_ ((void));
+extern void init_fringe P_ ((void));
+extern void init_fringe_once P_ ((void));
+
 /* Defined in insdel.c */
 extern Lisp_Object Qinhibit_modification_hooks;
 extern void move_gap P_ ((int));
diff --git a/src/macfns.c b/src/macfns.c
index 0f87556fb1e..a01811048fe 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -7792,12 +7792,25 @@ x_kill_gs_process (pixmap, f)
  ***********************************************************************/
 
 DEFUN ("x-change-window-property", Fx_change_window_property,
-       Sx_change_window_property, 2, 3, 0,
+       Sx_change_window_property, 2, 6, 0,
        doc: /* Change window property PROP to VALUE on the X window of FRAME.
-PROP and VALUE must be strings.  FRAME nil or omitted means use the
-selected frame.  Value is VALUE.  */)
-  (prop, value, frame)
-     Lisp_Object frame, prop, value;
+VALUE may be a string or a list of conses, numbers and/or strings.
+If an element in the list is a string, it is converted to
+an Atom and the value of the Atom is used.  If an element is a cons,
+it is converted to a 32 bit number where the car is the 16 top bits and the
+cdr is the lower 16 bits.
+FRAME nil or omitted means use the selected frame.
+If TYPE is given and non-nil, it is the name of the type of VALUE.
+If TYPE is not given or nil, the type is STRING.
+FORMAT gives the size in bits of each element if VALUE is a list.
+It must be one of 8, 16 or 32.
+If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
+If OUTER_P is non-nil, the property is changed for the outer X window of
+FRAME.  Default is to change on the edit X window.
+
+Value is VALUE.  */)
+     (prop, value, frame, type, format, outer_p)
+     Lisp_Object prop, value, frame, type, format, outer_p;
 {
 #if 0 /* MAC_TODO : port window properties to Mac */
   struct frame *f = check_x_frame (frame);
diff --git a/src/macterm.c b/src/macterm.c
index 9c7c497c00b..8bcee4a86c3 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -467,15 +467,21 @@ XClearWindow (display, w)
 /* Mac replacement for XCopyArea.  */
 
 static void
-mac_draw_bitmap (display, w, gc, x, y, bitmap)
+mac_draw_bitmap (display, w, gc, x, y, width, height, bits, overlay_p)
      Display *display;
      WindowPtr w;
      GC gc;
-     int x, y;
-     BitMap *bitmap;
+     int x, y, width, height;
+     unsigned short *bits;
+     int overlay_p;
 {
+  BitMap bitmap;
   Rect r;
 
+  bitmap.rowBytes = sizeof(unsigned short);
+  bitmap.baseAddr = bits;
+  SetRect (&(bitmap.bounds), 0, 0, width, height);
+
 #if TARGET_API_MAC_CARBON
   SetPort (GetWindowPort (w));
 #else
@@ -483,7 +489,7 @@ mac_draw_bitmap (display, w, gc, x, y, bitmap)
 #endif
 
   mac_set_colors (gc);
-  SetRect (&r, x, y, x + bitmap->bounds.right, y + bitmap->bounds.bottom);
+  SetRect (&r, x, y, x + bitmap.bounds.right, y + bitmap.bounds.bottom);
 
 #if TARGET_API_MAC_CARBON
   {
@@ -491,11 +497,13 @@ mac_draw_bitmap (display, w, gc, x, y, bitmap)
 
     LockPortBits (GetWindowPort (w));
     pmh = GetPortPixMap (GetWindowPort (w));
-    CopyBits (bitmap, (BitMap *) *pmh, &(bitmap->bounds), &r, srcCopy, 0);
+    CopyBits (&bitmap, (BitMap *) *pmh, &(bitmap.bounds), &r,
+              overlay_p ? srcOr : srcCopy, 0);
     UnlockPortBits (GetWindowPort (w));
   }
 #else /* not TARGET_API_MAC_CARBON */
-  CopyBits (bitmap, &(w->portBits), &(bitmap->bounds), &r, srcCopy, 0);
+  CopyBits (&bitmap, &(w->portBits), &(bitmap.bounds), &r,
+            overlay_p ? srcOr : srcCopy, 0);
 #endif /* not TARGET_API_MAC_CARBON */
 }
 
@@ -1313,7 +1321,7 @@ x_draw_fringe_bitmap (w, row, p)
   else
     x_clip_to_row (w, row, gc);
 
-  if (p->bx >= 0)
+  if (p->bx >= 0 && !p->overlay_p)
     {
       XGCValues gcv;
       gcv.foreground = face->background;
@@ -1339,18 +1347,18 @@ x_draw_fringe_bitmap (w, row, p)
 #endif
     }
 
-  if (p->which != NO_FRINGE_BITMAP)
+  if (p->which)
     {
-      unsigned char *bits = fringe_bitmaps[p->which].bits + p->dh;
-      BitMap bitmap;
+      unsigned short *bits = p->bits + p->dh;
 
-      mac_create_bitmap_from_bitmap_data (&bitmap, bits, p->wd, p->h);
-      gcv.foreground = face->foreground;
+      gcv.foreground = (p->cursor_p
+                        ? (p->overlay_p ? face->background
+                           : f->output_data.mac->cursor_pixel)
+                        : face->foreground);
       gcv.background = face->background;
 
-      mac_draw_bitmap (display, window, &gcv, p->x, p->y, &bitmap);
-
-      mac_free_bitmap (&bitmap);
+      mac_draw_bitmap (display, window, &gcv, p->x, p->y, 
+                       p->wd, p->h, bits, p->overlay_p);
     }
 
   mac_reset_clipping (display, window);
@@ -6455,12 +6463,19 @@ static long app_sleep_time = WNE_SLEEP_AT_RESUME;
 
 Boolean terminate_flag = false;
 
+/* Contains the string "reverse", which is a constant for mouse button emu.*/
+Lisp_Object Qreverse;
+
 /* True if using command key as meta key.  */
 Lisp_Object Vmac_command_key_is_meta;
 
 /* True if the ctrl and meta keys should be reversed.  */
 Lisp_Object Vmac_reverse_ctrl_meta;
 
+/* True if the option and command modifiers should be used to emulate
+   a three button mouse */
+Lisp_Object Vmac_emulate_three_button_mouse;
+
 #if USE_CARBON_EVENTS
 /* True if the mouse wheel button (i.e. button 4) should map to
    mouse-2, instead of mouse-3.  */
@@ -6533,6 +6548,20 @@ mac_to_emacs_modifiers (EventModifiers mods)
   return result;
 }
 
+static int
+mac_get_emulated_btn ( UInt32 modifiers )
+{
+  int result = 0;
+  if (Vmac_emulate_three_button_mouse != Qnil) {
+    int cmdIs3 = (Vmac_emulate_three_button_mouse != Qreverse);
+    if (modifiers & controlKey)
+      result = cmdIs3 ? 2 : 1;
+    else if (modifiers & optionKey)
+      result = cmdIs3 ? 1 : 2;      
+  }
+  return result;
+}
+
 #if USE_CARBON_EVENTS
 /* Obtains the event modifiers from the event ref and then calls
    mac_to_emacs_modifiers.  */
@@ -6542,6 +6571,11 @@ mac_event_to_emacs_modifiers (EventRef eventRef)
   UInt32 mods = 0;
   GetEventParameter (eventRef, kEventParamKeyModifiers, typeUInt32, NULL,
                     sizeof (UInt32), NULL, &mods);
+  if (Vmac_emulate_three_button_mouse != Qnil &&
+      GetEventClass(eventRef) == kEventClassMouse)
+    {
+      mods &= ~(optionKey & cmdKey);
+    }
   return mac_to_emacs_modifiers (mods);
 }
 
@@ -6556,7 +6590,14 @@ mac_get_mouse_btn (EventRef ref)
   switch (result)
     {
     case kEventMouseButtonPrimary:
-      return 0;
+      if (Vmac_emulate_three_button_mouse == Qnil) 
+        return 0;
+      else {
+        UInt32 mods = 0;
+        GetEventParameter (ref, kEventParamKeyModifiers, typeUInt32, NULL,
+                           sizeof (UInt32), NULL, &mods);
+        return mac_get_emulated_btn(mods);
+      }
     case kEventMouseButtonSecondary:
       return NILP (Vmac_wheel_button_is_mouse_2) ? 1 : 2;
     case kEventMouseButtonTertiary:
@@ -7692,7 +7733,7 @@ XTread_socket (struct input_event *bufp, int numchars, int expected)
 #if USE_CARBON_EVENTS
               bufp->code = mac_get_mouse_btn (eventRef);
 #else
-              bufp->code = 0;  /* only one mouse button */
+              bufp_.code = mac_get_emulate_btn (er.modifiers);
 #endif
               bufp->kind = SCROLL_BAR_CLICK_EVENT;
               bufp->frame_or_window = tracked_scroll_bar->window;
@@ -7760,7 +7801,7 @@ XTread_socket (struct input_event *bufp, int numchars, int expected)
 #if USE_CARBON_EVENTS
                   bufp->code = mac_get_mouse_btn (eventRef);
 #else
-                  bufp->code = 0;  /* only one mouse button */
+                  bufp_.code = mac_get_emulate_btn (er.modifiers);
 #endif
                   XSETINT (bufp->x, mouse_loc.h);
                   XSETINT (bufp->y, mouse_loc.v);
@@ -8517,6 +8558,8 @@ static struct redisplay_interface x_redisplay_interface =
   x_get_glyph_overhangs,
   x_fix_overlapping_area,
   x_draw_fringe_bitmap,
+  0, /* define_fringe_bitmap */
+  0, /* destroy_fringe_bitmap */
   mac_per_char_metric,
   mac_encode_char,
   NULL, /* mac_compute_glyph_string_overhangs */
@@ -8636,6 +8679,9 @@ syms_of_macterm ()
 
   Fprovide (intern ("mac-carbon"), Qnil);
 
+  staticpro (&Qreverse);
+  Qreverse = intern ("reverse");
+
   staticpro (&x_display_name_list);
   x_display_name_list = Qnil;
 
@@ -8680,6 +8726,17 @@ Otherwise the option key is used.  */);
             useful for non-standard keyboard layouts.  */);
   Vmac_reverse_ctrl_meta = Qnil;
 
+  DEFVAR_LISP ("mac-emulate-three-button-mouse", 
+               &Vmac_emulate_three_button_mouse,
+    doc: /* t means that when the option-key is held down while pressing the
+    mouse button, the click will register as mouse-2 and while the 
+    command-key is held down, the click will register as mouse-3.
+    'reverse means that the the option-key will register for mouse-3
+    and the command-key will register for mouse-2.  nil means that
+    not emulation should be done and the modifiers should be placed
+    on the mouse-1 event. */);
+  Vmac_emulate_three_button_mouse = Qnil;
+
 #if USE_CARBON_EVENTS
   DEFVAR_LISP ("mac-wheel-button-is-mouse-2", &Vmac_wheel_button_is_mouse_2,
    doc: /* Non-nil means that the wheel button will be treated as mouse-2 and
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index bd5ad98571c..1007e3940b0 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -118,7 +118,8 @@ OBJ1 =  $(BLD)/abbrev.$(O)			\
         $(BLD)/coding.$(O)                      \
         $(BLD)/category.$(O)                    \
         $(BLD)/ccl.$(O)                         \
-        $(BLD)/fontset.$(O)
+        $(BLD)/fontset.$(O)                     \
+        $(BLD)/fringe.$(O)
 
 WIN32OBJ = $(BLD)/w32term.$(O)                  \
            $(BLD)/w32xfns.$(O)                  \
diff --git a/src/minibuf.c b/src/minibuf.c
index 6124054f3c0..1f5a114540d 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -132,6 +132,8 @@ Lisp_Object Qminibuffer_default;
 
 Lisp_Object Qcurrent_input_method, Qactivate_input_method;
 
+Lisp_Object Qcase_fold_search;
+
 extern Lisp_Object Qmouse_face;
 
 extern Lisp_Object Qfield;
@@ -322,7 +324,8 @@ read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag,
 DEFUN ("minibufferp", Fminibufferp,
        Sminibufferp, 0, 1, 0,
        doc: /* Return t if BUFFER is a minibuffer.
-No argument or nil as argument means use current buffer as BUFFER.*/)
+No argument or nil as argument means use current buffer as BUFFER.
+BUFFER can be a buffer or a buffer name.  */)
      (buffer)
      Lisp_Object buffer;
 {
@@ -411,9 +414,9 @@ minibuffer_completion_contents ()
    with initial position HISTPOS.  INITIAL should be a string or a
    cons of a string and an integer.  BACKUP_N should be <= 0, or
    Qnil, which is equivalent to 0.  If INITIAL is a cons, BACKUP_N is
-   ignored and replaced with an integer that puts point N characters
-   from the beginning of INITIAL, where N is the CDR of INITIAL, or at
-   the beginning of INITIAL if N <= 0.
+   ignored and replaced with an integer that puts point at one-indexed
+   position N in INITIAL, where N is the CDR of INITIAL, or at the
+   beginning of INITIAL if N <= 0.
 
    Normally return the result as a string (the text that was read),
    but if EXPFLAG is nonzero, read it and return the object read.
@@ -898,23 +901,22 @@ read_minibuf_unwind (data)
 
 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
-If optional second arg INITIAL-CONTENTS is non-nil, it is a string
-  to be inserted into the minibuffer before reading input.
-  If INITIAL-CONTENTS is (STRING . POSITION), the initial input
-  is STRING, but point is placed at position POSITION in the minibuffer.
+The optional second arg INITIAL-CONTENTS is an obsolete alternative to
+  DEFAULT-VALUE.  It normally should be nil in new code, except when
+  HIST is a cons.  It is discussed in more detail below.
 Third arg KEYMAP is a keymap to use whilst reading;
   if omitted or nil, the default is `minibuffer-local-map'.
 If fourth arg READ is non-nil, then interpret the result as a Lisp object
   and return that object:
   in other words, do `(car (read-from-string INPUT-STRING))'
-Fifth arg HIST, if non-nil, specifies a history list
-  and optionally the initial position in the list.
-  It can be a symbol, which is the history list variable to use,
-  or it can be a cons cell (HISTVAR . HISTPOS).
-  In that case, HISTVAR is the history list variable to use,
-  and HISTPOS is the initial position (the position in the list
-  which INITIAL-CONTENTS corresponds to).
-  Positions are counted starting from 1 at the beginning of the list.
+Fifth arg HIST, if non-nil, specifies a history list and optionally
+  the initial position in the list.  It can be a symbol, which is the
+  history list variable to use, or it can be a cons cell
+  (HISTVAR . HISTPOS).  In that case, HISTVAR is the history list variable
+  to use, and HISTPOS is the initial position for use by the minibuffer
+  history commands.  For consistency, you should also specify that
+  element of the history as the value of INITIAL-CONTENTS.  Positions
+  are counted starting from 1 at the beginning of the list.
 Sixth arg DEFAULT-VALUE is the default value.  If non-nil, it is available
   for history commands; but, unless READ is non-nil, `read-from-minibuffer'
   does NOT return DEFAULT-VALUE if the user enters empty input!  It returns
@@ -923,7 +925,19 @@ Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
  the current input method and the setting of `enable-multibyte-characters'.
 If the variable `minibuffer-allow-text-properties' is non-nil,
  then the string which is returned includes whatever text properties
- were present in the minibuffer.  Otherwise the value has no text properties.  */)
+ were present in the minibuffer.  Otherwise the value has no text properties.
+
+The remainder of this documentation string describes the
+INITIAL-CONTENTS argument in more detail.  It is only relevant when
+studying existing code, or when HIST is a cons.  If non-nil,
+INITIAL-CONTENTS is a string to be inserted into the minibuffer before
+reading input.  Normally, point is put at the end of that string.
+However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
+input is STRING, but point is placed at _one-indexed_ position
+POSITION in the minibuffer.  Any integer value less than or equal to
+one puts point at the beginning of the string.  *Note* that this
+behavior differs from the way such arguments are used in `completing-read'
+and some related functions, which use zero-indexing for POSITION.  */)
      (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
      Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
      Lisp_Object inherit_input_method;
@@ -963,9 +977,11 @@ If the variable `minibuffer-allow-text-properties' is non-nil,
 }
 
 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
-       doc: /* Return a Lisp object read using the minibuffer.
+       doc: /* Return a Lisp object read using the minibuffer, unevaluated.
 Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
-is a string to insert in the minibuffer before reading.  */)
+is a string to insert in the minibuffer before reading.
+\(INITIAL-CONTENTS can also be a cons of a string and an integer.  Such
+arguments are used as in `read-from-minibuffer')  */)
      (prompt, initial_contents)
      Lisp_Object prompt, initial_contents;
 {
@@ -978,7 +994,9 @@ is a string to insert in the minibuffer before reading.  */)
 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
        doc: /* Return value of Lisp expression read using the minibuffer.
 Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
-is a string to insert in the minibuffer before reading.  */)
+is a string to insert in the minibuffer before reading.
+\(INITIAL-CONTENTS can also be a cons of a string and an integer.  Such
+arguments are used as in `read-from-minibuffer')  */)
      (prompt, initial_contents)
      Lisp_Object prompt, initial_contents;
 {
@@ -990,6 +1008,9 @@ is a string to insert in the minibuffer before reading.  */)
 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
+  This argument has been superseded by DEFAULT-VALUE and should normally
+  be nil in new code.  It behaves as in `read-from-minibuffer'.  See the
+  documentation string of that function for details.
 The third arg HISTORY, if non-nil, specifies a history list
   and optionally the initial position in the list.
 See `read-from-minibuffer' for details of HISTORY argument.
@@ -1013,9 +1034,14 @@ Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
 
 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
        doc: /* Read a string from the terminal, not allowing blanks.
-Prompt with PROMPT, and provide INITIAL as an initial value of the input string.
+Prompt with PROMPT.  Whitespace terminates the input.  If INITIAL is
+non-nil, it should be a string, which is used as initial input, with
+point positioned at the end, so that SPACE will accept the input.
+\(Actually, INITIAL can also be a cons of a string and an integer.
+Such values are treated as in `read-from-minibuffer', but are normally
+not useful in this function.)
 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
-the current input method and the setting of `enable-multibyte-characters'.  */)
+the current input method and the setting of`enable-multibyte-characters'.  */)
      (prompt, initial, inherit_input_method)
      Lisp_Object prompt, initial, inherit_input_method;
 {
@@ -1243,7 +1269,7 @@ is used to further constrain the set of candidates.  */)
           && (tem = Fcompare_strings (eltstring, make_number (0),
                                       make_number (SCHARS (string)),
                                       string, make_number (0), Qnil,
-                                      completion_ignore_case ?Qt : Qnil),
+                                      completion_ignore_case ? Qt : Qnil),
               EQ (Qt, tem)))
         {
           /* Yes. */
@@ -1252,15 +1278,20 @@ is used to further constrain the set of candidates.  */)
           XSETFASTINT (zero, 0);
 
           /* Ignore this element if it fails to match all the regexps.  */
-          for (regexps = Vcompletion_regexp_list; CONSP (regexps);
-               regexps = XCDR (regexps))
-            {
-              tem = Fstring_match (XCAR (regexps), eltstring, zero);
-              if (NILP (tem))
-                break;
-            }
-          if (CONSP (regexps))
-            continue;
+          {
+            int count = SPECPDL_INDEX ();
+            specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
+            for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+                 regexps = XCDR (regexps))
+              {
+                tem = Fstring_match (XCAR (regexps), eltstring, zero);
+                if (NILP (tem))
+                  break;
+              }
+            unbind_to (count, Qnil);
+            if (CONSP (regexps))
+              continue;
+          }
 
           /* Ignore this element if there is a predicate
              and the predicate doesn't like it. */
@@ -1498,15 +1529,20 @@ are ignored unless STRING itself starts with a space.  */)
           XSETFASTINT (zero, 0);
 
           /* Ignore this element if it fails to match all the regexps.  */
-          for (regexps = Vcompletion_regexp_list; CONSP (regexps);
-               regexps = XCDR (regexps))
-            {
-              tem = Fstring_match (XCAR (regexps), eltstring, zero);
-              if (NILP (tem))
-                break;
-            }
-          if (CONSP (regexps))
-            continue;
+          {
+            int count = SPECPDL_INDEX ();
+            specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
+            for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+                 regexps = XCDR (regexps))
+              {
+                tem = Fstring_match (XCAR (regexps), eltstring, zero);
+                if (NILP (tem))
+                  break;
+              }
+            unbind_to (count, Qnil);
+            if (CONSP (regexps))
+              continue;
+          }
 
           /* Ignore this element if there is a predicate
              and the predicate doesn't like it. */
@@ -1542,7 +1578,7 @@ Lisp_Object Vminibuffer_completing_file_name;
 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
        doc: /* Read a string in the minibuffer, with completion.
 PROMPT is a string to prompt with; normally it ends in a colon and a space.
-TABLE is an alist whose elements' cars are strings, or an obarray.
+TABLE can be an list of strings, an alist, an obarray or a hash table.
 TABLE can also be a function to do the completion itself.
 PREDICATE limits completion to a subset of TABLE.
 See `try-completion' and `all-completions' for more details
@@ -1551,26 +1587,30 @@ See `try-completion' and `all-completions' for more details
 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
  the input is (or completes to) an element of TABLE or is null.
  If it is also not t, typing RET does not exit if it does non-null completion.
-If the input is null, `completing-read' returns an empty string,
- regardless of the value of REQUIRE-MATCH.
-
-If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
-  If it is (STRING . POSITION), the initial input
-  is STRING, but point is placed POSITION characters into the string.
-  This feature is deprecated--it is best to pass nil for INITIAL-INPUT
-  and supply the default value DEF instead.  The user can yank the
-  default value into the minibuffer easily using \\[next-history-element].
-
-HIST, if non-nil, specifies a history list
-  and optionally the initial position in the list.
-  It can be a symbol, which is the history list variable to use,
-  or it can be a cons cell (HISTVAR . HISTPOS).
-  In that case, HISTVAR is the history list variable to use,
-  and HISTPOS is the initial position (the position in the list
-  which INITIAL-INPUT corresponds to).
-  Positions are counted starting from 1 at the beginning of the list.
-  The variable `history-length' controls the maximum length of a
-  history list.
+If the input is null, `completing-read' returns DEF, or an empty string
+ if DEF is nil, regardless of the value of REQUIRE-MATCH.
+
+If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
+  with point positioned at the end.
+  If it is (STRING . POSITION), the initial input is STRING, but point
+  is placed at _zero-indexed_ position POSITION in STRING.  (*Note*
+  that this is different from `read-from-minibuffer' and related
+  functions, which use one-indexing for POSITION.)  This feature is
+  deprecated--it is best to pass nil for INITIAL-INPUT and supply the
+  default value DEF instead.  The user can yank the default value into
+  the minibuffer easily using \\[next-history-element].
+
+HIST, if non-nil, specifies a history list and optionally the initial
+  position in the list.  It can be a symbol, which is the history list
+  variable to use, or it can be a cons cell (HISTVAR . HISTPOS).  In
+  that case, HISTVAR is the history list variable to use, and HISTPOS
+  is the initial position (the position in the list used by the
+  minibuffer history commands).  For consistency, you should also
+  specify that element of the history as the value of
+  INITIAL-CONTENTS.  (This is the only case in which you should use
+  INITIAL-INPUT instead of DEF.)  Positions are counted starting from
+  1 at the beginning of the list.  The variable `history-length'
+  controls the maximum length of a history list.
 
 DEF, if non-nil, is the default value.
 
@@ -1737,20 +1777,27 @@ the values STRING, PREDICATE and `lambda'.  */)
     return call3 (alist, string, predicate, Qlambda);
 
   /* Reject this element if it fails to match all the regexps.  */
-  for (regexps = Vcompletion_regexp_list; CONSP (regexps);
-       regexps = XCDR (regexps))
-    {
-      if (NILP (Fstring_match (XCAR (regexps),
-                               SYMBOLP (tem) ? string : tem,
-                               Qnil)))
-        return Qnil;
-    }
+  {
+    int count = SPECPDL_INDEX ();
+    specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
+    for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+         regexps = XCDR (regexps))
+      {
+        if (NILP (Fstring_match (XCAR (regexps),
+                                 SYMBOLP (tem) ? string : tem,
+                                 Qnil)))
+          return unbind_to (count, Qnil);
+      }
+    unbind_to (count, Qnil);
+  }
 
   /* Finally, check the predicate.  */
   if (!NILP (predicate))
-    return HASH_TABLE_P (alist)
-      ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (alist), i))
-      : call1 (predicate, tem);
+    {
+      return HASH_TABLE_P (alist)
+        ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (alist), i))
+        : call1 (predicate, tem);
+    }
   else
     return Qt;
 }
@@ -2212,6 +2259,8 @@ DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_
        doc: /* Display the list of completions, COMPLETIONS, using `standard-output'.
 Each element may be just a symbol or string
 or may be a list of two strings to be printed as if concatenated.
+If it is a list of two strings, the first is the actual completion
+alternative, the second serves as annotation.
 `standard-output' must be a buffer.
 The actual completion alternatives, as inserted, are given `mouse-face'
 properties of `highlight'.
@@ -2252,6 +2301,8 @@ It can find the completion buffer in `standard-output'.  */)
           startpos = Qnil;
 
           elt = Fcar (tail);
+          if (SYMBOLP (elt))
+            elt = SYMBOL_NAME (elt);
           /* Compute the length of this element.  */
           if (CONSP (elt))
             {
@@ -2563,6 +2614,9 @@ syms_of_minibuf ()
   Qactivate_input_method = intern ("activate-input-method");
   staticpro (&Qactivate_input_method);
 
+  Qcase_fold_search = intern ("case-fold-search");
+  staticpro (&Qcase_fold_search);
+
   DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
                doc: /* If this is non-nil, `read-buffer' does its work by calling this function.  */);
   Vread_buffer_function = Qnil;
@@ -2597,7 +2651,8 @@ This variable makes a difference whenever the minibuffer window is active. */);
 
   DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
                doc: /* Alist or obarray used for completion in the minibuffer.
-This becomes the ALIST argument to `try-completion' and `all-completion'.
+This becomes the ALIST argument to `try-completion' and `all-completions'.
+The value can also be a list of strings or a hash table.
 
 The value may alternatively be a function, which is given three arguments:
   STRING, the current buffer contents;
@@ -2644,7 +2699,12 @@ Some uses of the echo area also raise that frame (since they use it too).  */);
   minibuffer_auto_raise = 0;
 
   DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
-               doc: /* List of regexps that should restrict possible completions.  */);
+               doc: /* List of regexps that should restrict possible completions.
+The basic completion functions only consider a completion acceptable
+if it matches all regular expressions in this list, with
+`case-fold-search' bound to the value of `completion-ignore-case'.
+See Info node `(elisp)Basic Completion', for a description of these
+functions.  */);
   Vcompletion_regexp_list = Qnil;
 
   DEFVAR_BOOL ("minibuffer-allow-text-properties",
diff --git a/src/process.c b/src/process.c
index be6094438e9..3e4b5dbc673 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4262,7 +4262,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
           else
             Available = input_wait_mask;
           check_connect = (num_pending_connects > 0);
-          check_delay = process_output_delay_count;
+          check_delay = wait_channel >= 0 ? 0 : process_output_delay_count;
         }
 
       /* If frame size has changed or the window is newly mapped,
diff --git a/src/region-cache.c b/src/region-cache.c
index fc9d3f98de0..251382a5a0e 100644
--- a/src/region-cache.c
+++ b/src/region-cache.c
@@ -21,12 +21,12 @@ Boston, MA 02111-1307, USA.  */
 
 
 #include <config.h>
+#include <stdio.h>
+
 #include "lisp.h"
 #include "buffer.h"
 #include "region-cache.h"
 
-#include <stdio.h>
-
 
 /* Data structures.  */
 
diff --git a/src/sysdep.c b/src/sysdep.c
index 73b7fb70a99..febf59253e1 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -24,6 +24,7 @@ Boston, MA 02111-1307, USA.  */
 #endif
 
 #include <signal.h>
+#include <stdio.h>
 #include <setjmp.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
@@ -82,7 +83,6 @@ static int delete_exited_processes;
 #undef fwrite
 #endif
 
-#include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
diff --git a/src/w32fns.c b/src/w32fns.c
index 1854c3908bd..3b53bade2ad 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -5558,6 +5558,11 @@ x_to_w32_font (lpxstr, lplogfont)
             (Fcheck_coding_system (Vlocale_coding_system), &coding);
           coding.src_multibyte = 1;
           coding.dst_multibyte = 1;
+          /* Need to set COMPOSITION_DISABLED, otherwise Emacs crashes in
+             encode_coding_iso2022 trying to dereference a null pointer.  */
+          coding.composing = COMPOSITION_DISABLED;
+          if (coding.type == coding_type_iso2022)
+            coding.flags |= CODING_FLAG_ISO_SAFE;
           bufsize = encoding_buffer_size (&coding, strlen (name));
           buf = (unsigned char *) alloca (bufsize);
           coding.mode |= CODING_MODE_LAST_BLOCK;
@@ -12400,12 +12405,25 @@ x_kill_gs_process (pixmap, f)
  ***********************************************************************/
 
 DEFUN ("x-change-window-property", Fx_change_window_property,
-       Sx_change_window_property, 2, 3, 0,
+       Sx_change_window_property, 2, 6, 0,
        doc: /* Change window property PROP to VALUE on the X window of FRAME.
-PROP and VALUE must be strings.  FRAME nil or omitted means use the
-selected frame.  Value is VALUE.  */)
-  (prop, value, frame)
-     Lisp_Object frame, prop, value;
+VALUE may be a string or a list of conses, numbers and/or strings.
+If an element in the list is a string, it is converted to
+an Atom and the value of the Atom is used.  If an element is a cons,
+it is converted to a 32 bit number where the car is the 16 top bits and the
+cdr is the lower 16 bits.
+FRAME nil or omitted means use the selected frame.
+If TYPE is given and non-nil, it is the name of the type of VALUE.
+If TYPE is not given or nil, the type is STRING.
+FORMAT gives the size in bits of each element if VALUE is a list.
+It must be one of 8, 16 or 32.
+If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
+If OUTER_P is non-nil, the property is changed for the outer X window of
+FRAME.  Default is to change on the edit X window.
+
+Value is VALUE.  */)
+     (prop, value, frame, type, format, outer_p)
+     Lisp_Object prop, value, frame, type, format, outer_p;
 {
 #if 0 /* TODO : port window properties to W32 */
   struct frame *f = check_x_frame (frame);
diff --git a/src/w32select.c b/src/w32select.c
index 6533f4b660d..940cce35772 100644
--- a/src/w32select.c
+++ b/src/w32select.c
@@ -212,6 +212,11 @@ DEFUN ("w32-set-clipboard-data", Fw32_set_clipboard_data,
           }
         coding.src_multibyte = 1;
         coding.dst_multibyte = 0;
+        /* Need to set COMPOSITION_DISABLED, otherwise Emacs crashes in
+           encode_coding_iso2022 trying to dereference a null pointer.  */
+        coding.composing = COMPOSITION_DISABLED;
+        if (coding.type == coding_type_iso2022)
+          coding.flags |= CODING_FLAG_ISO_SAFE;
         Vnext_selection_coding_system = Qnil;
         coding.mode |= CODING_MODE_LAST_BLOCK;
         bufsize = encoding_buffer_size (&coding, nbytes);
diff --git a/src/w32term.c b/src/w32term.c
index 834df6ef88f..82db82826e8 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -698,28 +698,46 @@ w32_draw_fringe_bitmap (w, row, p)
   else
     w32_clip_to_row (w, row, hdc);
 
-  if (p->bx >= 0)
+  if (p->bx >= 0 && !p->overlay_p)
     {
       w32_fill_area (f, hdc, face->background,
                      p->bx, p->by, p->nx, p->ny);
     }
 
-  if (p->which != NO_FRINGE_BITMAP)
+  if (p->which)
     {
       HBITMAP pixmap = fringe_bmp[p->which];
       HDC compat_hdc;
       HANDLE horig_obj;
 
       compat_hdc = CreateCompatibleDC (hdc);
+
       SaveDC (hdc);
 
       horig_obj = SelectObject (compat_hdc, pixmap);
       SetTextColor (hdc, face->background);
-      SetBkColor (hdc, face->foreground);
+      SetBkColor (hdc, p->cursor_p
+                        ? (p->overlay_p ? face->background
+                           : f->output_data.w32->cursor_pixel)
+                           : face->foreground);
 
-      BitBlt (hdc, p->x, p->y, p->wd, p->h,
-              compat_hdc, 0, p->dh,
-              SRCCOPY);
+      /* Paint overlays transparently.  */
+      if (p->overlay_p)
+        {
+        BitBlt (hdc, p->x, p->y, p->wd, p->h,
+                compat_hdc, 0, p->dh,
+                DSTINVERT);
+        BitBlt (hdc, p->x, p->y, p->wd, p->h,
+                compat_hdc, 0, p->dh,
+                MERGEPAINT);
+        BitBlt (hdc, p->x, p->y, p->wd, p->h,
+                compat_hdc, 0, p->dh,
+                DSTINVERT);
+        }
+      else
+        BitBlt (hdc, p->x, p->y, p->wd, p->h,
+                compat_hdc, 0, p->dh,
+                SRCCOPY);
 
       SelectObject (compat_hdc, horig_obj);
       DeleteDC (compat_hdc);
@@ -731,6 +749,25 @@ w32_draw_fringe_bitmap (w, row, p)
   release_frame_dc (f, hdc);
 }
 
+static void
+w32_define_fringe_bitmap (which, bits, h, wd)
+     int which;
+     unsigned short *bits;
+     int h, wd;
+{
+  fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
+}
+
+static void
+w32_destroy_fringe_bitmap (which)
+     int which;
+{
+  if (fringe_bmp[which])
+    DeleteObject (fringe_bmp[which]);
+  fringe_bmp[which] = 0;
+}
+
+
 
 /* This is called when starting Emacs and when restarting after
    suspend.  When starting Emacs, no window is mapped.  And nothing
@@ -6220,32 +6257,7 @@ w32_term_init (display_name, xrm_option, resource_name)
      horizontally reflected compared to how they appear on X, so we
      need to bitswap and convert to unsigned shorts before creating
      the bitmaps.  */
-  {
-    int i, j;
-
-    for (i = NO_FRINGE_BITMAP + 1; i < MAX_FRINGE_BITMAPS; i++)
-      {
-        int h = fringe_bitmaps[i].height;
-        int wd = fringe_bitmaps[i].width;
-        unsigned short *w32bits
-          = (unsigned short *)alloca (h * sizeof (unsigned short));
-        unsigned short *wb = w32bits;
-        unsigned char *bits = fringe_bitmaps[i].bits;
-        for (j = 0; j < h; j++)
-          {
-            static unsigned char swap_nibble[16]
-              = { 0x0, 0x8, 0x4, 0xc,    /* 0000 1000 0100 1100 */
-                  0x2, 0xa, 0x6, 0xe,    /* 0010 1010 0110 1110 */
-                  0x1, 0x9, 0x5, 0xd,    /* 0001 1001 0101 1101 */
-                  0x3, 0xb, 0x7, 0xf };  /* 0011 1011 0111 1111 */
-
-            unsigned char b = *bits++;
-            *wb++ = (unsigned short)((swap_nibble[b & 0xf]<<4)
-                                     | (swap_nibble[(b>>4) & 0xf]));
-          }
-        fringe_bmp[i] = CreateBitmap (wd, h, 1, 1, w32bits);
-      }
-  }
+  w32_init_fringe ();
 
 #ifndef F_SETOWN_BUG
 #ifdef F_SETOWN
@@ -6313,13 +6325,7 @@ x_delete_display (dpyinfo)
   xfree (dpyinfo->font_table);
   xfree (dpyinfo->w32_id_name);
 
-  /* Destroy row bitmaps.  */
-  {
-    int i;
-
-    for (i = NO_FRINGE_BITMAP + 1; i < MAX_FRINGE_BITMAPS; i++)
-      DeleteObject (fringe_bmp[i]);
-  }
+  w32_reset_fringes ();
 }
 
 /* Set up use of W32.  */
@@ -6350,6 +6356,8 @@ static struct redisplay_interface w32_redisplay_interface =
   w32_get_glyph_overhangs,
   x_fix_overlapping_area,
   w32_draw_fringe_bitmap,
+  w32_define_fringe_bitmap,
+  w32_destroy_fringe_bitmap,
   w32_per_char_metric,
   w32_encode_char,
   NULL, /* w32_compute_glyph_string_overhangs */
diff --git a/src/window.c b/src/window.c
index 363c8d0eaff..8f971ab0260 100644
--- a/src/window.c
+++ b/src/window.c
@@ -6018,9 +6018,7 @@ DEFUN ("window-fringes", Fwindow_fringes, Swindow_fringes,
        0, 1, 0,
        doc: /* Get width of fringes of window WINDOW.
 If WINDOW is omitted or nil, use the currently selected window.
-Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).
-If a window specific fringe width is not set, its width will be returned
-as nil.  */)
+Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
      (window)
      Lisp_Object window;
 {
diff --git a/src/xdisp.c b/src/xdisp.c
index 0e678b34897..edd7cc62e61 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -311,10 +311,7 @@ extern Lisp_Object Qscroll_bar;
 Lisp_Object Vshow_trailing_whitespace;
 
 #ifdef HAVE_WINDOW_SYSTEM
-/* Non-nil means that newline may flow into the right fringe.  */
-
-Lisp_Object Voverflow_newline_into_fringe;
-#endif /* HAVE_WINDOW_SYSTEM */
+extern Lisp_Object Voverflow_newline_into_fringe;
 
 /* Test if overflow newline into fringe.  Called with iterator IT
    at or past right window margin, and with IT->current_x set.  */ 
@@ -325,6 +322,8 @@ Lisp_Object Voverflow_newline_into_fringe;
    && WINDOW_RIGHT_FRINGE_WIDTH (it->w) > 0     \
    && it->current_x == it->last_visible_x)
 
+#endif /* HAVE_WINDOW_SYSTEM */
+
 /* Non-nil means show the text cursor in void text areas
    i.e. in blank areas after eol and eob.  This used to be
    the default in 21.3.  */
@@ -3275,6 +3274,8 @@ handle_display_prop (it)
       && !EQ (XCAR (prop), Qraise)
       /* Marginal area specifications.  */
       && !(CONSP (XCAR (prop)) && EQ (XCAR (XCAR (prop)), Qmargin))
+      && !EQ (XCAR (prop), Qleft_fringe)
+      && !EQ (XCAR (prop), Qright_fringe)
       && !NILP (XCAR (prop)))
     {
       for (; CONSP (prop); prop = XCDR (prop))
@@ -3481,6 +3482,43 @@ handle_single_display_prop (it, prop, object, position,
         }
 #endif /* HAVE_WINDOW_SYSTEM */
     }
+  else if (CONSP (prop)
+           && (EQ (XCAR (prop), Qleft_fringe)
+               || EQ (XCAR (prop), Qright_fringe))
+           && CONSP (XCDR (prop)))
+    {
+      unsigned face_id = DEFAULT_FACE_ID;
+
+      /* `(left-fringe BITMAP FACE)'.  */
+      if (FRAME_TERMCAP_P (it->f) || FRAME_MSDOS_P (it->f))
+        return 0;
+
+#ifdef HAVE_WINDOW_SYSTEM
+      value = XCAR (XCDR (prop));
+      if (!NUMBERP (value)
+          || !valid_fringe_bitmap_id_p (XINT (value)))
+        return 0;
+
+      if (CONSP (XCDR (XCDR (prop))))
+        {
+          Lisp_Object face_name = XCAR (XCDR (XCDR (prop)));
+          face_id = lookup_named_face (it->f, face_name, 'A');
+          if (face_id < 0)
+            return 0;
+        }
+
+      if (EQ (XCAR (prop), Qleft_fringe))
+        {
+          it->left_user_fringe_bitmap = XINT (value);
+          it->left_user_fringe_face_id = face_id;
+        }
+      else
+        {
+          it->right_user_fringe_bitmap = XINT (value);
+          it->right_user_fringe_face_id = face_id;
+        }
+#endif /* HAVE_WINDOW_SYSTEM */
+    }
   else if (!it->string_from_display_prop_p)
     {
       /* `((margin left-margin) VALUE)' or `((margin right-margin)
@@ -5610,7 +5648,11 @@ move_it_in_display_line_to (it, to_charpos, to_x, op)
 #ifdef HAVE_WINDOW_SYSTEM
                           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
                             {
-                              get_next_display_element (it);
+                              if (!get_next_display_element (it))
+                                {
+                                  result = MOVE_POS_MATCH_OR_ZV;
+                                  break;
+                                }
                               if (ITERATOR_AT_END_OF_LINE_P (it))
                                 {
                                   result = MOVE_NEWLINE_OR_CR;
@@ -5678,7 +5720,11 @@ move_it_in_display_line_to (it, to_charpos, to_x, op)
 #ifdef HAVE_WINDOW_SYSTEM
           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
             {
-              get_next_display_element (it);
+              if (!get_next_display_element (it))
+                {
+                  result = MOVE_POS_MATCH_OR_ZV;
+                  break;
+                }
               if (ITERATOR_AT_END_OF_LINE_P (it))
                 {
                   result = MOVE_NEWLINE_OR_CR;
@@ -7614,7 +7660,10 @@ clear_garbaged_frames ()
           if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
             {
               if (f->resized_p)
-                Fredraw_frame (frame);
+                {
+                  Fredraw_frame (frame);
+                  f->force_flush_display_p = 1;
+                }
               clear_current_matrices (f);
               changed_count++;
               f->garbaged = 0;
@@ -8928,536 +8977,6 @@ note_tool_bar_highlight (f, x, y)
 
 
 
-/***********************************************************************
-                               Fringes
- ***********************************************************************/
-
-#ifdef HAVE_WINDOW_SYSTEM
-
-/* Notice that all bitmaps bits are "mirrored".  */
-
-/* An arrow like this: `<-'.  */
-/*
-  ...xx...
-  ....xx..
-  .....xx.
-  ..xxxxxx
-  ..xxxxxx
-  .....xx.
-  ....xx..
-  ...xx...
-*/
-static unsigned char left_bits[] = {
-   0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
-
-
-/* Right truncation arrow bitmap `->'.  */
-/*
-  ...xx...
-  ..xx....
-  .xx.....
-  xxxxxx..
-  xxxxxx..
-  .xx.....
-  ..xx....
-  ...xx...
-*/
-static unsigned char right_bits[] = {
-   0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
-
-
-/* Up arrow bitmap.  */
-/*
-  ...xx...
-  ..xxxx..
-  .xxxxxx.
-  xxxxxxxx
-  ...xx...
-  ...xx...
-  ...xx...
-  ...xx...
-*/
-static unsigned char up_arrow_bits[] = {
-   0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
-
-
-/* Down arrow bitmap.  */
-/*
-  ...xx...
-  ...xx...
-  ...xx...
-  ...xx...
-  xxxxxxxx
-  .xxxxxx.
-  ..xxxx..
-  ...xx...
-*/
-static unsigned char down_arrow_bits[] = {
-   0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
-
-/* Marker for continued lines.  */
-/*
-  ..xxxx..
-  .xxxxx..
-  xx......
-  xxx..x..
-  xxxxxx..
-  .xxxxx..
-  ..xxxx..
-  .xxxxx..
-*/
-static unsigned char continued_bits[] = {
-   0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
-
-/* Marker for continuation lines.  */
-/*
-  ..xxxx..
-  ..xxxxx.
-  ......xx
-  ..x..xxx
-  ..xxxxxx
-  ..xxxxx.
-  ..xxxx..
-  ..xxxxx.
-*/
-static unsigned char continuation_bits[] = {
-   0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
-
-/* Overlay arrow bitmap.  A triangular arrow.  */
-/*
-  ......xx
-  ....xxxx
-  ...xxxxx
-  ..xxxxxx
-  ..xxxxxx
-  ...xxxxx
-  ....xxxx
-  ......xx
-*/
-static unsigned char ov_bits[] = {
-   0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
-
-
-/* First line bitmap.  An left-up angle.  */
-/*
-  ..xxxxxx
-  ..xxxxxx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ........
-*/
-static unsigned char first_line_bits[] = {
-   0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
-
-
-/* Last line bitmap.  An left-down angle.  */
-/*
-  ........
-  xx......
-  xx......
-  xx......
-  xx......
-  xx......
-  xxxxxx..
-  xxxxxx..
-*/
-static unsigned char last_line_bits[] = {
-   0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
-
-/* Filled box cursor bitmap.  A filled box; max 13 pixels high.  */
-/*
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-  .xxxxxxx
-*/
-static unsigned char filled_box_cursor_bits[] = {
-   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f};
-
-/* Hollow box cursor bitmap.  A hollow box; max 13 pixels high.  */
-/*
-  .xxxxxxx
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .x.....x
-  .xxxxxxx
-*/
-static unsigned char hollow_box_cursor_bits[] = {
-   0x7f, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x7f};
-
-/* Bar cursor bitmap.  A vertical bar; max 13 pixels high.  */
-/*
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-  ......xx
-*/
-static unsigned char bar_cursor_bits[] = {
-   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03};
-
-/* HBar cursor bitmap.  A horisontal bar; 2 pixels high.  */
-/*
-  .xxxxxxx
-  .xxxxxxx
-*/
-static unsigned char hbar_cursor_bits[] = {
-  0x7f, 0x7f};
-
-
-/* Bitmap drawn to indicate lines not displaying text if
-   `indicate-empty-lines' is non-nil.  */
-static unsigned char zv_bits[] = {
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
-  0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
-
-/* Hollow square bitmap.  */
-/*
-  .xxxxxx.
-  .x....x.
-  .x....x.
-  .x....x.
-  .x....x.
-  .xxxxxx.
-*/
-static unsigned char hollow_square_bits[] = {
-   0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
-
-
-struct fringe_bitmap fringe_bitmaps[MAX_FRINGE_BITMAPS] =
-{
-  { 0, 0, 0, NULL /* NO_FRINGE_BITMAP */ },
-  { 8, sizeof (left_bits), 0, left_bits },
-  { 8, sizeof (right_bits), 0, right_bits },
-  { 8, sizeof (up_arrow_bits), -1, up_arrow_bits },
-  { 8, sizeof (down_arrow_bits), -2, down_arrow_bits },
-  { 8, sizeof (continued_bits), 0, continued_bits },
-  { 8, sizeof (continuation_bits), 0, continuation_bits },
-  { 8, sizeof (ov_bits), 0, ov_bits },
-  { 8, sizeof (first_line_bits), -1, first_line_bits },
-  { 8, sizeof (last_line_bits), -2, last_line_bits },
-  { 8, sizeof (filled_box_cursor_bits), 0, filled_box_cursor_bits },
-  { 8, sizeof (hollow_box_cursor_bits), 0, hollow_box_cursor_bits },
-  { 8, sizeof (bar_cursor_bits), 0, bar_cursor_bits },
-  { 8, sizeof (hbar_cursor_bits), -2, hbar_cursor_bits },
-  { 8, sizeof (zv_bits), 3, zv_bits },
-  { 8, sizeof (hollow_square_bits), 0, hollow_square_bits },
-};
-
-
-/* Draw the bitmap WHICH in one of the left or right fringes of
-   window W.  ROW is the glyph row for which to display the bitmap; it
-   determines the vertical position at which the bitmap has to be
-   drawn.
-   LEFT_P is 1 for left fringe, 0 for right fringe.
-*/
-
-void
-draw_fringe_bitmap (w, row, left_p)
-     struct window *w;
-     struct glyph_row *row;
-     int left_p;
-{
-  struct frame *f = XFRAME (WINDOW_FRAME (w));
-  struct draw_fringe_bitmap_params p;
-  enum fringe_bitmap_type which;
-  int period;
-
-  if (left_p)
-    which = row->left_fringe_bitmap;
-  else if (!row->cursor_in_fringe_p)
-    which = row->right_fringe_bitmap;
-  else
-    switch (w->phys_cursor_type)
-      {
-      case HOLLOW_BOX_CURSOR:
-        if (row->visible_height >= sizeof(hollow_box_cursor_bits))
-          which = HOLLOW_BOX_CURSOR_BITMAP;
-        else
-          which = HOLLOW_SQUARE_BITMAP;
-        break;
-      case FILLED_BOX_CURSOR:
-        which = FILLED_BOX_CURSOR_BITMAP;
-        break;
-      case BAR_CURSOR:
-        which = BAR_CURSOR_BITMAP;
-        break;
-      case HBAR_CURSOR:
-        which = HBAR_CURSOR_BITMAP;
-        break;
-      case NO_CURSOR:
-      default:
-        w->phys_cursor_on_p = 0;
-        row->cursor_in_fringe_p = 0;
-        which = row->right_fringe_bitmap;
-        break;
-      }
-
-  period = fringe_bitmaps[which].period;
-
-  /* Convert row to frame coordinates.  */
-  p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
-
-  p.which = which;
-  p.wd = fringe_bitmaps[which].width;
-
-  p.h = fringe_bitmaps[which].height;
-  p.dh = (period > 0 ? (p.y % period) : 0);
-  p.h -= p.dh;
-  /* Clip bitmap if too high.  */
-  if (p.h > row->height)
-    p.h = row->height;
-
-  p.face = FACE_FROM_ID (f, FRINGE_FACE_ID);
-  PREPARE_FACE_FOR_DISPLAY (f, p.face);
-
-  /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
-     the fringe.  */
-  p.bx = -1;
-  if (left_p)
-    {
-      int wd = WINDOW_LEFT_FRINGE_WIDTH (w);
-      int x = window_box_left (w, (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                                   ? LEFT_MARGIN_AREA
-                                   : TEXT_AREA));
-      if (p.wd > wd)
-        p.wd = wd;
-      p.x = x - p.wd - (wd - p.wd) / 2;
-
-      if (p.wd < wd || row->height > p.h)
-        {
-          /* If W has a vertical border to its left, don't draw over it.  */
-          wd -= ((!WINDOW_LEFTMOST_P (w)
-                  && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
-                 ? 1 : 0);
-          p.bx = x - wd;
-          p.nx = wd;
-        }
-    }
-  else
-    {
-      int x = window_box_right (w,
-                                (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                                 ? RIGHT_MARGIN_AREA
-                                 : TEXT_AREA));
-      int wd = WINDOW_RIGHT_FRINGE_WIDTH (w);
-      if (p.wd > wd)
-        p.wd = wd;
-      p.x = x + (wd - p.wd) / 2;
-      /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
-         the fringe.  */
-      if (p.wd < wd || row->height > p.h)
-        {
-          p.bx = x;
-          p.nx = wd;
-        }
-    }
-
-  if (p.bx >= 0)
-    {
-      int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
-
-      p.by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, row->y));
-      p.ny = row->visible_height;
-    }
-
-  /* Adjust y to the offset in the row to start drawing the bitmap.  */
-  if (period == 0)
-    p.y += (row->height - p.h) / 2;
-  else if (period == -2)
-    {
-      p.h = fringe_bitmaps[which].height;
-      p.y += (row->visible_height - p.h);
-    }
-
-  FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
-}
-
-/* Draw fringe bitmaps for glyph row ROW on window W.  Call this
-   function with input blocked.  */
-
-void
-draw_row_fringe_bitmaps (w, row)
-     struct window *w;
-     struct glyph_row *row;
-{
-  xassert (interrupt_input_blocked);
-
-  /* If row is completely invisible, because of vscrolling, we
-     don't have to draw anything.  */
-  if (row->visible_height <= 0)
-    return;
-
-  if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
-    draw_fringe_bitmap (w, row, 1);
-
-  if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
-    draw_fringe_bitmap (w, row, 0);
-}
-
-/* Draw the fringes of window W.  Only fringes for rows marked for
-   update in redraw_fringe_bitmaps_p are drawn.  */
-
-void
-draw_window_fringes (w)
-     struct window *w;
-{
-  struct glyph_row *row;
-  int yb = window_text_bottom_y (w);
-  int nrows = w->current_matrix->nrows;
-  int y = 0, rn;
-
-  if (w->pseudo_window_p)
-    return;
-
-  for (y = 0, rn = 0, row = w->current_matrix->rows;
-       y < yb && rn < nrows;
-       y += row->height, ++row, ++rn)
-    {
-      if (!row->redraw_fringe_bitmaps_p)
-        continue;
-      draw_row_fringe_bitmaps (w, row);
-      row->redraw_fringe_bitmaps_p = 0;
-    }
-}
-
-
-/* Compute actual fringe widths for frame F.  
-
-   If REDRAW is 1, redraw F if the fringe settings was actually
-   modified and F is visible.
-
-   Since the combined left and right fringe must occupy an integral
-   number of columns, we may need to add some pixels to each fringe.
-   Typically, we add an equal amount (+/- 1 pixel) to each fringe,
-   but a negative width value is taken literally (after negating it).
-
-   We never make the fringes narrower than specified.  It is planned
-   to make fringe bitmaps customizable and expandable, and at that
-   time, the user will typically specify the minimum number of pixels
-   needed for his bitmaps, so we shouldn't select anything less than
-   what is specified.
-*/
-
-void
-compute_fringe_widths (f, redraw)
-     struct frame *f;
-     int redraw;
-{
-  int o_left = FRAME_LEFT_FRINGE_WIDTH (f);
-  int o_right = FRAME_RIGHT_FRINGE_WIDTH (f);
-  int o_cols = FRAME_FRINGE_COLS (f);
-
-  Lisp_Object left_fringe = Fassq (Qleft_fringe, f->param_alist);
-  Lisp_Object right_fringe = Fassq (Qright_fringe, f->param_alist);
-  int left_fringe_width, right_fringe_width;
-
-  if (!NILP (left_fringe))
-    left_fringe = Fcdr (left_fringe);
-  if (!NILP (right_fringe))
-    right_fringe = Fcdr (right_fringe);
-
-  left_fringe_width = ((NILP (left_fringe) || !INTEGERP (left_fringe)) ? 8 :
-                       XINT (left_fringe));
-  right_fringe_width = ((NILP (right_fringe) || !INTEGERP (right_fringe)) ? 8 :
-                        XINT (right_fringe));
-
-  if (left_fringe_width || right_fringe_width)
-    {
-      int left_wid = left_fringe_width >= 0 ? left_fringe_width : -left_fringe_width;
-      int right_wid = right_fringe_width >= 0 ? right_fringe_width : -right_fringe_width;
-      int conf_wid = left_wid + right_wid;
-      int font_wid = FRAME_COLUMN_WIDTH (f);
-      int cols = (left_wid + right_wid + font_wid-1) / font_wid;
-      int real_wid = cols * font_wid;
-      if (left_wid && right_wid)
-        {
-          if (left_fringe_width < 0)
-            {
-              /* Left fringe width is fixed, adjust right fringe if necessary */
-              FRAME_LEFT_FRINGE_WIDTH (f) = left_wid;
-              FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid - left_wid;
-            }
-          else if (right_fringe_width < 0)
-            {
-              /* Right fringe width is fixed, adjust left fringe if necessary */
-              FRAME_LEFT_FRINGE_WIDTH (f) = real_wid - right_wid;
-              FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid;
-            }
-          else
-            {
-              /* Adjust both fringes with an equal amount.
-                 Note that we are doing integer arithmetic here, so don't
-                 lose a pixel if the total width is an odd number.  */
-              int fill = real_wid - conf_wid;
-              FRAME_LEFT_FRINGE_WIDTH (f) = left_wid + fill/2;
-              FRAME_RIGHT_FRINGE_WIDTH (f) = right_wid + fill - fill/2;
-            }
-        }
-      else if (left_fringe_width)
-        {
-          FRAME_LEFT_FRINGE_WIDTH (f) = real_wid;
-          FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
-        }
-      else
-        {
-          FRAME_LEFT_FRINGE_WIDTH (f) = 0;
-          FRAME_RIGHT_FRINGE_WIDTH (f) = real_wid;
-        }
-      FRAME_FRINGE_COLS (f) = cols;
-    }
-  else
-    {
-      FRAME_LEFT_FRINGE_WIDTH (f) = 0;
-      FRAME_RIGHT_FRINGE_WIDTH (f) = 0;
-      FRAME_FRINGE_COLS (f) = 0;
-    }
-
-  if (redraw && FRAME_VISIBLE_P (f))
-    if (o_left != FRAME_LEFT_FRINGE_WIDTH (f) ||
-        o_right != FRAME_RIGHT_FRINGE_WIDTH (f) ||
-        o_cols != FRAME_FRINGE_COLS (f))
-      redraw_frame (f);
-}
-
-#endif /* HAVE_WINDOW_SYSTEM */
-
-
-
 /************************************************************************
                          Horizontal scrolling
  ************************************************************************/
@@ -9558,7 +9077,10 @@ hscroll_window_tree (window)
 
               /* Position cursor in window.  */
               if (!hscroll_relative_p && hscroll_step_abs == 0)
-                hscroll = max (0, it.current_x - text_area_width / 2)
+                hscroll = max (0, (it.current_x
+                                   - (ITERATOR_AT_END_OF_LINE_P (&it)
+                                      ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
+                                      : (text_area_width / 2))))
                           / FRAME_COLUMN_WIDTH (it.f);
               else if (w->cursor.x >= text_area_width - h_margin)
                 {
@@ -11674,136 +11196,6 @@ set_vertical_scroll_bar (w)
       (w, end - start, whole, start);
 }
 
-#ifdef HAVE_WINDOW_SYSTEM
-
-/* Recalculate the bitmaps to show in the fringes of window W.
-   If FORCE_P is 0, only mark rows with modified bitmaps for update in
-   redraw_fringe_bitmaps_p; else mark all rows for update.  */
-
-int
-update_window_fringes (w, force_p)
-     struct window *w;
-     int force_p;
-{
-  struct glyph_row *row, *cur = 0;
-  int yb = window_text_bottom_y (w);
-  int rn, nrows = w->current_matrix->nrows;
-  int y;
-  int redraw_p = 0;
-  Lisp_Object ind;
-
-  if (w->pseudo_window_p)
-    return 0;
-
-  if (!MINI_WINDOW_P (w)
-      && (ind = XBUFFER (w->buffer)->indicate_buffer_boundaries, !NILP (ind)))
-    {
-      int do_eob = 1, do_bob = 1;
-
-      for (y = 0, rn = 0;
-           y < yb && rn < nrows;
-           y += row->height, ++rn)
-        {
-          unsigned indicate_bob_p, indicate_top_line_p;
-          unsigned indicate_eob_p, indicate_bottom_line_p;
-          
-          row = w->desired_matrix->rows + rn;
-          if (!row->enabled_p)
-            row = w->current_matrix->rows + rn;
-
-          indicate_bob_p = row->indicate_bob_p;
-          indicate_top_line_p = row->indicate_top_line_p;
-          indicate_eob_p = row->indicate_eob_p;
-          indicate_bottom_line_p = row->indicate_bottom_line_p;
-          
-          row->indicate_bob_p = row->indicate_top_line_p = 0;
-          row->indicate_eob_p = row->indicate_bottom_line_p = 0;
-
-          if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer)))
-            row->indicate_bob_p = do_bob, do_bob = 0;
-          else if (EQ (ind, Qt)
-                   && (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0) == rn)
-            row->indicate_top_line_p = 1;
-
-          if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer)))
-            row->indicate_eob_p = do_eob, do_eob = 0;
-          else if (EQ (ind, Qt)
-                   && y + row->height >= yb)
-            row->indicate_bottom_line_p = 1;
-
-          if (indicate_bob_p != row->indicate_bob_p
-              || indicate_top_line_p != row->indicate_top_line_p
-              || indicate_eob_p != row->indicate_eob_p
-              || indicate_bottom_line_p != row->indicate_bottom_line_p)
-            row->redraw_fringe_bitmaps_p = 1;
-        }
-    }
-
-  for (y = 0, rn = 0;
-       y < yb && rn < nrows;
-       y += row->height, rn++)
-    {
-      enum fringe_bitmap_type left, right;
-
-      row = w->desired_matrix->rows + rn;
-      cur = w->current_matrix->rows + rn;
-      if (!row->enabled_p)
-        row = cur;
-
-      /* Decide which bitmap to draw in the left fringe.  */
-      if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
-        left = NO_FRINGE_BITMAP;
-      else if (row->overlay_arrow_p)
-        left = OVERLAY_ARROW_BITMAP;
-      else if (row->truncated_on_left_p)
-        left = LEFT_TRUNCATION_BITMAP;
-      else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
-        left = CONTINUATION_LINE_BITMAP;
-      else if (row->indicate_empty_line_p)
-        left = ZV_LINE_BITMAP;
-      else if (row->indicate_bob_p)
-        left = FIRST_LINE_BITMAP;
-      else
-        left = NO_FRINGE_BITMAP;
-
-      /* Decide which bitmap to draw in the right fringe.  */
-      if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
-        right = NO_FRINGE_BITMAP;
-      else if (row->truncated_on_right_p)
-        right = RIGHT_TRUNCATION_BITMAP;
-      else if (row->continued_p)
-        right = CONTINUED_LINE_BITMAP;
-      else if (row->indicate_eob_p)
-        right = LAST_LINE_BITMAP;
-      else if (row->indicate_top_line_p) 
-        right = UP_ARROW_BITMAP;
-      else if (row->indicate_bottom_line_p)
-        right = DOWN_ARROW_BITMAP;
-      else if (row->indicate_empty_line_p && WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
-        right = ZV_LINE_BITMAP;
-      else
-        right = NO_FRINGE_BITMAP;
-
-      if (force_p
-          || row->y != cur->y
-          || row->visible_height != cur->visible_height
-          || left != cur->left_fringe_bitmap
-          || right != cur->right_fringe_bitmap
-          || cur->redraw_fringe_bitmaps_p)
-        {
-          redraw_p = row->redraw_fringe_bitmaps_p = cur->redraw_fringe_bitmaps_p = 1;
-          cur->left_fringe_bitmap = left;
-          cur->right_fringe_bitmap = right;
-        }
-
-      row->left_fringe_bitmap = left;
-      row->right_fringe_bitmap = right;
-    }
-
-  return redraw_p;
-}
-
-#endif /* HAVE_WINDOW_SYSTEM */
 
 /* Redisplay leaf window WINDOW.  JUST_THIS_ONE_P non-zero means only
    selected_window is redisplayed.
@@ -12494,6 +11886,7 @@ redisplay_window (window, just_this_one_p)
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (update_window_fringes (w, 0)
+      && !just_this_one_p
       && (used_current_matrix_p || overlay_arrow_seen)
       && !w->pseudo_window_p)
     {
@@ -14835,6 +14228,11 @@ display_line (it)
              display the cursor there under X.  Set the charpos of the
              first glyph of blank lines not corresponding to any text
              to -1.  */
+#ifdef HAVE_WINDOW_SYSTEM
+          if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
+            row->exact_window_width_line_p = 1;
+          else
+#endif /* HAVE_WINDOW_SYSTEM */
           if ((append_space (it, 1) && row->used[TEXT_AREA] == 1)
               || row->used[TEXT_AREA] == 0)
             {
@@ -14947,8 +14345,14 @@ display_line (it)
 #ifdef HAVE_WINDOW_SYSTEM
                           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
                             {
-                              get_next_display_element (it);
-                              if (ITERATOR_AT_END_OF_LINE_P (it))
+                              if (!get_next_display_element (it))
+                                {
+                                  row->exact_window_width_line_p = 1;
+                                  it->continuation_lines_width = 0;
+                                  row->continued_p = 0;
+                                  row->ends_at_zv_p = 1;
+                                }
+                              else if (ITERATOR_AT_END_OF_LINE_P (it))
                                 {
                                   row->continued_p = 0;
                                   row->exact_window_width_line_p = 1;
@@ -15053,7 +14457,7 @@ display_line (it)
                                   it->max_phys_ascent + it->max_phys_descent);
 
           /* End of this display line if row is continued.  */
-          if (row->continued_p)
+          if (row->continued_p || row->ends_at_zv_p)
             break;
         }
 
@@ -15119,7 +14523,15 @@ display_line (it)
               /* Don't truncate if we can overflow newline into fringe.  */
               if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
                 {
-                  get_next_display_element (it);
+                  if (!get_next_display_element (it))
+                    {
+#ifdef HAVE_WINDOW_SYSTEM
+                      it->continuation_lines_width = 0;
+                      row->ends_at_zv_p = 1;
+                      row->exact_window_width_line_p = 1;
+                      break;
+#endif /* HAVE_WINDOW_SYSTEM */
+                    }
                   if (ITERATOR_AT_END_OF_LINE_P (it))
                     {
                       row->exact_window_width_line_p = 1;
@@ -15196,6 +14608,17 @@ display_line (it)
   /* Remember the position at which this line ends.  */
   row->end = it->current;
 
+  /* Save fringe bitmaps in this row.  */
+  row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
+  row->left_user_fringe_face_id = it->left_user_fringe_face_id;
+  row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
+  row->right_user_fringe_face_id = it->right_user_fringe_face_id;
+
+  it->left_user_fringe_bitmap = 0;
+  it->left_user_fringe_face_id = 0;
+  it->right_user_fringe_bitmap = 0;
+  it->right_user_fringe_face_id = 0;
+
   /* Maybe set the cursor.  */
   if (it->w->cursor.vpos < 0
       && PT >= MATRIX_ROW_START_CHARPOS (row)
@@ -20555,8 +19978,7 @@ on_hot_spot_p (hot_spot, x, y)
           return inside;
         }
     }
-  else
-    return 0;
+  return 0;
 }
 
 Lisp_Object
@@ -20595,10 +20017,8 @@ Returns the alist element for the first matching AREA in MAP.  */)
   if (NILP (map))
     return Qnil;
 
-  if (!INTEGERP (x))
-    wrong_type_argument (Qintegerp, x);
-  if (!INTEGERP (y))
-    wrong_type_argument (Qintegerp, y);
+  CHECK_NUMBER (x);
+  CHECK_NUMBER (y);
 
   return find_hot_spot (map, XINT (x), XINT (y));
 }
@@ -22016,17 +21436,6 @@ wide as that tab on the display.  */);
 The face used for trailing whitespace is `trailing-whitespace'.  */);
   Vshow_trailing_whitespace = Qnil;
 
-#ifdef HAVE_WINDOW_SYSTEM
-  DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe,
-    doc: /* *Non-nil means that newline may flow into the right fringe.
-This means that display lines which are exactly as wide as the window
-(not counting the final newline) will only occupy one screen line, by
-showing (or hiding) the final newline in the right fringe; when point
-is at the final newline, the cursor is shown in the right fringe.
-If nil, also continue lines which are exactly as wide as the window.  */);
-  Voverflow_newline_into_fringe = Qt;
-#endif
-
   DEFVAR_LISP ("void-text-area-pointer", &Vvoid_text_area_pointer,
     doc: /* *The pointer shape to show in void text areas.
 Nil means to show the text pointer.  Other options are `arrow', `text',
diff --git a/src/xfaces.c b/src/xfaces.c
index fc23b3e2b24..7761282f9eb 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -192,6 +192,7 @@ Boston, MA 02111-1307, USA.  */
    used to fill in unspecified attributes of the default face.  */
 
 #include <config.h>
+#include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdio.h>              /* This needs to be before termchar.h */
diff --git a/src/xfns.c b/src/xfns.c
index 6e51965c248..a649ddd1068 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -775,7 +775,6 @@ x_create_bitmap_mask (f, id)
   unsigned long x, y, xp, xm, yp, ym;
   GC gc;
 
-  int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
   struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
 
   if (!(id > 0))
@@ -1597,7 +1596,7 @@ x_set_menu_bar_lines (f, value, oldval)
      Lisp_Object value, oldval;
 {
   int nlines;
-#ifndef USE_X_TOOLKIT
+#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
   int olines = FRAME_MENU_BAR_LINES (f);
 #endif
 
@@ -4292,125 +4291,6 @@ x_sync (f)
 
 
 /***********************************************************************
-                General X functions exposed to Elisp.
- ***********************************************************************/
-
-DEFUN ("x-send-client-message", Fx_send_client_event,
-       Sx_send_client_message, 6, 6, 0,
-       doc: /* Send a client message of MESSAGE-TYPE to window DEST on DISPLAY.
-
-For DISPLAY, specify either a frame or a display name (a string).
-If DISPLAY is nil, that stands for the selected frame's display.
-DEST may be an integer, in which case it is a Window id.  The value 0 may
-be used to send to the root window of the DISPLAY.
-If DEST is a frame the event is sent to the outer window of that frame.
-Nil means the currently selected frame.
-If DEST is the string "PointerWindow" the event is sent to the window that
-contains the pointer.  If DEST is the string "InputFocus" the event is
-sent to the window that has the input focus.
-FROM is the frame sending the event.  Use nil for currently selected frame.
-MESSAGE-TYPE is the name of an Atom as a string.
-FORMAT must be one of 8, 16 or 32 and determines the size of the values in
-bits.  VALUES is a list of integer and/or strings containing the values to
-send.  If a value is a string, it is converted to an Atom and the value of
-the Atom is sent.  If more values than fits into the event is given,
-the excessive values are ignored.  */)
-     (display, dest, from, message_type, format, values)
-     Lisp_Object display, dest, from, message_type, format, values;
-{
-  struct x_display_info *dpyinfo = check_x_display_info (display);
-  Window wdest;
-  XEvent event;
-  Lisp_Object cons;
-  int i;
-  int max_nr_values = (int) sizeof (event.xclient.data.b);
-  struct frame *f = check_x_frame (from);
-  
-  CHECK_STRING (message_type);
-  CHECK_NUMBER (format);
-  CHECK_CONS (values);
-
-  for (cons = values; CONSP (cons); cons = XCDR (cons))
-    {
-      Lisp_Object o = XCAR (cons);
-
-      if (! INTEGERP (o) && ! STRINGP (o))
-        error ("Bad data in VALUES, must be integer or string");
-    }
-
-  event.xclient.type = ClientMessage;
-  event.xclient.format = XFASTINT (format);
-
-  if (event.xclient.format != 8 && event.xclient.format != 16
-      && event.xclient.format != 32)
-    error ("FORMAT must be one of 8, 16 or 32");
-  if (event.xclient.format == 16) max_nr_values /= 2;
-  if (event.xclient.format == 32) max_nr_values /= 4;
-  
-  if (FRAMEP (dest) || NILP (dest))
-    {
-      struct frame *fdest = check_x_frame (dest);
-      wdest = FRAME_OUTER_WINDOW (fdest);
-    }
-  else if (STRINGP (dest))
-    {
-      if (strcmp (SDATA (dest), "PointerWindow") == 0)
-        wdest = PointerWindow;
-      else if (strcmp (SDATA (dest), "InputFocus") == 0)
-        wdest = InputFocus;
-      else
-        error ("DEST as a string must be one of PointerWindow or InputFocus");
-    }
-  else
-    {
-      CHECK_NUMBER (dest);
-      wdest = (Window) XFASTINT (dest);
-      if (wdest == 0) wdest = dpyinfo->root_window;
-    }
-
-  BLOCK_INPUT;
-  for (cons = values, i = 0;
-       CONSP (cons) && i < max_nr_values;
-       cons = XCDR (cons), ++i)
-    {
-      Lisp_Object o = XCAR (cons);
-      long val;
-
-      if (INTEGERP (o))
-        val = XINT (o);
-      else if (STRINGP (o))
-          val = XInternAtom (dpyinfo->display, SDATA (o), False);
-
-      if (event.xclient.format == 8)
-        event.xclient.data.b[i] = (char) val;
-      else if (event.xclient.format == 16)
-        event.xclient.data.s[i] = (short) val;
-      else
-        event.xclient.data.l[i] = val;
-    }
-
-  for ( ; i < max_nr_values; ++i)
-    if (event.xclient.format == 8)
-      event.xclient.data.b[i] = 0;
-    else if (event.xclient.format == 16)
-      event.xclient.data.s[i] = 0;
-    else
-      event.xclient.data.l[i] = 0;
-
-  event.xclient.message_type
-    = XInternAtom (dpyinfo->display, SDATA (message_type), False);
-  event.xclient.display = dpyinfo->display;
-  event.xclient.window = FRAME_OUTER_WINDOW (f);
-
-  XSendEvent (dpyinfo->display, wdest, False, 0xffff, &event);
-
-  XFlush (dpyinfo->display);
-  UNBLOCK_INPUT;
-
-  return Qnil;
-}
-
-/***********************************************************************
                             Image types
  ***********************************************************************/
 
@@ -9601,24 +9481,85 @@ x_kill_gs_process (pixmap, f)
  ***********************************************************************/
 
 DEFUN ("x-change-window-property", Fx_change_window_property,
-       Sx_change_window_property, 2, 3, 0,
+       Sx_change_window_property, 2, 6, 0,
        doc: /* Change window property PROP to VALUE on the X window of FRAME.
-PROP and VALUE must be strings.  FRAME nil or omitted means use the
-selected frame.  Value is VALUE.  */)
-     (prop, value, frame)
-     Lisp_Object frame, prop, value;
+PROP must be a string.
+VALUE may be a string or a list of conses, numbers and/or strings.
+If an element in the list is a string, it is converted to
+an Atom and the value of the Atom is used.  If an element is a cons,
+it is converted to a 32 bit number where the car is the 16 top bits and the
+cdr is the lower 16 bits.
+FRAME nil or omitted means use the selected frame.
+If TYPE is given and non-nil, it is the name of the type of VALUE.
+If TYPE is not given or nil, the type is STRING.
+FORMAT gives the size in bits of each element if VALUE is a list.
+It must be one of 8, 16 or 32.
+If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
+If OUTER_P is non-nil, the property is changed for the outer X window of
+FRAME.  Default is to change on the edit X window.
+
+Value is VALUE.  */)
+     (prop, value, frame, type, format, outer_p)
+     Lisp_Object prop, value, frame, type, format, outer_p;
 {
   struct frame *f = check_x_frame (frame);
   Atom prop_atom;
+  Atom target_type = XA_STRING;
+  int element_format = 8;
+  unsigned char *data;
+  int nelements;
+  Window w;
 
   CHECK_STRING (prop);
-  CHECK_STRING (value);
+
+  if (! NILP (format))
+    {
+      CHECK_NUMBER (format);
+      element_format = XFASTINT (format);
+
+      if (element_format != 8 && element_format != 16
+          && element_format != 32)
+        error ("FORMAT must be one of 8, 16 or 32");
+    }
+
+  if (CONSP (value))
+    {
+      nelements = x_check_property_data (value);
+      if (nelements == -1)
+        error ("Bad data in VALUE, must be number, string or cons");
+
+      if (element_format == 8)
+        data = (unsigned char *) xmalloc (nelements);
+      else if (element_format == 16)
+        data = (unsigned char *) xmalloc (nelements*2);
+      else
+        data = (unsigned char *) xmalloc (nelements*4);
+
+      x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
+    }
+  else
+    {
+      CHECK_STRING (value);
+      data = SDATA (value);
+      nelements = SCHARS (value);
+    }
 
   BLOCK_INPUT;
   prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
-  XChangeProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                   prop_atom, XA_STRING, 8, PropModeReplace,
-                   SDATA (value), SCHARS (value));
+  if (! NILP (type))
+    {
+      CHECK_STRING (type);
+      target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
+    }
+
+  if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
+  else w = FRAME_X_WINDOW (f);
+ 
+  XChangeProperty (FRAME_X_DISPLAY (f), w,
+                   prop_atom, target_type, element_format, PropModeReplace,
+                   data, nelements);
+
+  if (CONSP (value)) xfree (data);
 
   /* Make sure the property is set when we return.  */
   XFlush (FRAME_X_DISPLAY (f));
@@ -9652,13 +9593,20 @@ FRAME nil or omitted means use the selected frame.  Value is PROP.  */)
 
 
 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
-       1, 2, 0,
+       1, 6, 0,
        doc: /* Value is the value of window property PROP on FRAME.
-If FRAME is nil or omitted, use the selected frame.  Value is nil
-if FRAME hasn't a property with name PROP or if PROP has no string
-value.  */)
-     (prop, frame)
-     Lisp_Object prop, frame;
+If FRAME is nil or omitted, use the selected frame.
+If TYPE is nil or omitted, get the property as a string.  Otherwise TYPE
+is the name of the Atom that denotes the type expected.
+If SOURCE is non-nil, get the property on that window instead of from
+FRAME.  The number 0 denotes the root window.
+If DELETE_P is non-nil, delete the property after retreiving it.
+If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
+
+Value is nil if FRAME hasn't a property with name PROP or if PROP has
+no value of TYPE.  */)
+     (prop, frame, type, source, delete_p, vector_ret_p)
+     Lisp_Object prop, frame, type, source, delete_p, vector_ret_p;
 {
   struct frame *f = check_x_frame (frame);
   Atom prop_atom;
@@ -9666,14 +9614,43 @@ value.  */)
   Lisp_Object prop_value = Qnil;
   char *tmp_data = NULL;
   Atom actual_type;
+  Atom target_type = XA_STRING;
   int actual_format;
   unsigned long actual_size, bytes_remaining;
+  Window target_window = FRAME_X_WINDOW (f);
+  struct gcpro gcpro1;
 
+  GCPRO1 (prop_value);
   CHECK_STRING (prop);
+
+  if (! NILP (source))
+    {
+      if (NUMBERP (source))
+        {
+          if (FLOATP (source))
+            target_window = (Window) XFLOAT (source);
+          else
+            target_window = XFASTINT (source);
+
+          if (target_window == 0)
+            target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
+        }
+      else if (CONSP (source))
+        target_window = cons_to_long (source);
+    }
+
   BLOCK_INPUT;
+  if (STRINGP (type))
+    {
+      if (strcmp ("AnyPropertyType", SDATA (type)) == 0)
+        target_type = AnyPropertyType;
+      else
+        target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
+    }
+
   prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
-  rc = XGetWindowProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                           prop_atom, 0, 0, False, XA_STRING,
+  rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
+                           prop_atom, 0, 0, False, target_type,
                            &actual_type, &actual_format, &actual_size,
                            &bytes_remaining, (unsigned char **) &tmp_data);
   if (rc == Success)
@@ -9683,19 +9660,29 @@ value.  */)
       XFree (tmp_data);
       tmp_data = NULL;
 
-      rc = XGetWindowProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+      rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
                                prop_atom, 0, bytes_remaining,
-                               False, XA_STRING,
+                               ! NILP (delete_p), target_type,
                                &actual_type, &actual_format,
                                &actual_size, &bytes_remaining,
                                (unsigned char **) &tmp_data);
       if (rc == Success && tmp_data)
-        prop_value = make_string (tmp_data, size);
+        {
+          if (NILP (vector_ret_p))
+            prop_value = make_string (tmp_data, size);
+          else
+            prop_value = x_property_data_to_lisp (f,
+                                                  (unsigned char *) tmp_data,
+                                                  actual_type,
+                                                  actual_format,
+                                                  actual_size);
+        }
 
-      XFree (tmp_data);
+      if (tmp_data) XFree (tmp_data);
     }
 
   UNBLOCK_INPUT;
+  UNGCPRO;
   return prop_value;
 }
 
@@ -10752,7 +10739,6 @@ selection dialog's entry field, if MUSTMATCH is non-nil.")
   int count = specpdl_ptr - specpdl;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   char *cdef_file;
-  char *cprompt;
 
   GCPRO5 (prompt, dir, default_filename, mustmatch, file);
   CHECK_STRING (prompt);
@@ -11110,7 +11096,6 @@ meaning don't clear the cache.  */);
   defsubr (&Sx_close_connection);
   defsubr (&Sx_display_list);
   defsubr (&Sx_synchronize);
-  defsubr (&Sx_send_client_message);
   defsubr (&Sx_focus_frame);
   defsubr (&Sx_backspace_delete_keys_p);
 
diff --git a/src/xselect.c b/src/xselect.c
index e1dbb4601dc..637b39272b7 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -23,6 +23,7 @@ Boston, MA 02111-1307, USA.  */
 /* Rewritten by jwz */
 
 #include <config.h>
+#include <stdio.h>      /* termhooks.h needs this */
 #include "lisp.h"
 #include "xterm.h"      /* for all of the X includes */
 #include "dispextern.h" /* frame.h seems to want this */
@@ -30,6 +31,9 @@ Boston, MA 02111-1307, USA.  */
 #include "blockinput.h"
 #include "buffer.h"
 #include "process.h"
+#include "termhooks.h"
+
+#include <X11/Xproto.h>
 
 struct prop_location;
 
@@ -50,7 +54,9 @@ static struct prop_location *expect_property_change P_ ((Display *, Window,
 static void unexpect_property_change P_ ((struct prop_location *));
 static Lisp_Object wait_for_property_change_unwind P_ ((Lisp_Object));
 static void wait_for_property_change P_ ((struct prop_location *));
-static Lisp_Object x_get_foreign_selection P_ ((Lisp_Object, Lisp_Object));
+static Lisp_Object x_get_foreign_selection P_ ((Lisp_Object,
+                                                Lisp_Object,
+                                                Lisp_Object));
 static void x_get_window_property P_ ((Display *, Window, Atom,
                                        unsigned char **, int *,
                                        Atom *, int *, unsigned long *, int));
@@ -1223,8 +1229,8 @@ static Window reading_selection_window;
    Converts this to Lisp data and returns it.  */
 
 static Lisp_Object
-x_get_foreign_selection (selection_symbol, target_type)
-     Lisp_Object selection_symbol, target_type;
+x_get_foreign_selection (selection_symbol, target_type, time_stamp)
+     Lisp_Object selection_symbol, target_type, time_stamp;
 {
   struct frame *sf = SELECTED_FRAME ();
   Window requestor_window;
@@ -1252,6 +1258,18 @@ x_get_foreign_selection (selection_symbol, target_type)
   else
     type_atom = symbol_to_x_atom (dpyinfo, display, target_type);
 
+  if (! NILP (time_stamp))
+    {
+      if (CONSP (time_stamp))
+        requestor_time = (Time) cons_to_long (time_stamp);
+      else if (INTEGERP (time_stamp))
+        requestor_time = (Time) XUINT (time_stamp);
+      else if (FLOATP (time_stamp))
+        requestor_time = (Time) XFLOAT (time_stamp);
+      else
+        error ("TIME_STAMP must be cons or number");
+    }
+
   BLOCK_INPUT;
 
   count = x_catch_errors (display);
@@ -1943,13 +1961,15 @@ anything that the functions on `selection-converter-alist' know about.  */)
    will block until all of the data has arrived.  */
 
 DEFUN ("x-get-selection-internal", Fx_get_selection_internal,
-       Sx_get_selection_internal, 2, 2, 0,
+       Sx_get_selection_internal, 2, 3, 0,
        doc: /* Return text selected from some X window.
 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
 \(Those are literal upper-case symbol names, since that's what X expects.)
-TYPE is the type of data desired, typically `STRING'.  */)
-     (selection_symbol, target_type)
-     Lisp_Object selection_symbol, target_type;
+TYPE is the type of data desired, typically `STRING'.
+TIME_STAMP is the time to use in the XConvertSelection call for foreign
+selections.  If omitted, defaults to the time for the last event.  */)
+  (selection_symbol, target_type, time_stamp)
+     Lisp_Object selection_symbol, target_type, time_stamp;
 {
   Lisp_Object val = Qnil;
   struct gcpro gcpro1, gcpro2;
@@ -1973,7 +1993,7 @@ TYPE is the type of data desired, typically `STRING'.  */)
 
   if (NILP (val))
     {
-      val = x_get_foreign_selection (selection_symbol, target_type);
+      val = x_get_foreign_selection (selection_symbol, target_type, time_stamp);
       goto DONE;
     }
 
@@ -2310,6 +2330,351 @@ Positive means shift the values forward, negative means backward.  */)
 
 #endif
 
+/***********************************************************************
+                      Drag and drop support
+***********************************************************************/
+/* Check that lisp values are of correct type for x_fill_property_data.
+   That is, number, string or a cons with two numbers (low and high 16
+   bit parts of a 32 bit number).  */
+
+int
+x_check_property_data (data)
+     Lisp_Object data;
+{
+  Lisp_Object iter;
+  int size = 0;
+
+  for (iter = data; CONSP (iter) && size != -1; iter = XCDR (iter), ++size)
+    {
+      Lisp_Object o = XCAR (iter);
+
+      if (! NUMBERP (o) && ! STRINGP (o) && ! CONSP (o))
+        size = -1;
+      else if (CONSP (o) &&
+               (! NUMBERP (XCAR (o)) || ! NUMBERP (XCDR (o))))
+        size = -1;
+    }
+
+  return size;
+}
+
+/* Convert lisp values to a C array.  Values may be a number, a string
+   which is taken as an X atom name and converted to the atom value, or
+   a cons containing the two 16 bit parts of a 32 bit number.
+
+   DPY is the display use to look up X atoms.
+   DATA is a Lisp list of values to be converted.
+   RET is the C array that contains the converted values.  It is assumed
+   it is big enough to hol all values.
+   FORMAT is 8, 16 or 32 and gives the size in bits for each C value to
+   be stored in RET.  */
+
+void
+x_fill_property_data (dpy, data, ret, format)
+     Display *dpy;
+     Lisp_Object data;
+     void *ret;
+     int format;
+{
+  CARD32 val;
+  CARD32 *d32 = (CARD32 *) ret;
+  CARD16 *d16 = (CARD16 *) ret;
+  CARD8  *d08 = (CARD8  *) ret;
+  Lisp_Object iter;
+
+  for (iter = data; CONSP (iter); iter = XCDR (iter))
+    {
+      Lisp_Object o = XCAR (iter);
+
+      if (INTEGERP (o))
+        val = (CARD32) XFASTINT (o);
+      else if (FLOATP (o))
+        val = (CARD32) XFLOAT (o);
+      else if (CONSP (o))
+        val = (CARD32) cons_to_long (o);
+      else if (STRINGP (o))
+        {
+          BLOCK_INPUT;
+          val = XInternAtom (dpy, (char *) SDATA (o), False);
+          UNBLOCK_INPUT;
+        }
+      else
+        error ("Wrong type, must be string, number or cons");
+
+      if (format == 8)
+        *d08++ = (CARD8) val;
+      else if (format == 16)
+        *d16++ = (CARD16) val;
+      else
+        *d32++ = val;
+    }
+}
+
+/* Convert an array of C values to a Lisp list.
+   F is the frame to be used to look up X atoms if the TYPE is XA_ATOM.
+   DATA is a C array of values to be converted.
+   TYPE is the type of the data.  Only XA_ATOM is special, it converts
+   each number in DATA to its corresponfing X atom as a symbol.
+   FORMAT is 8, 16 or 32 and gives the size in bits for each C value to
+   be stored in RET.
+   SIZE is the number of elements in DATA.
+
+   Also see comment for selection_data_to_lisp_data above.  */
+
+Lisp_Object
+x_property_data_to_lisp (f, data, type, format, size)
+     struct frame *f;
+     unsigned char *data;
+     Atom type;
+     int format;
+     unsigned long size;
+{
+  return selection_data_to_lisp_data (FRAME_X_DISPLAY (f),
+                                      data, size*format/8, type, format);
+}
+
+/* Get the mouse position frame relative coordinates.  */
+
+static void
+mouse_position_for_drop (f, x, y)
+     FRAME_PTR f;
+     int *x;
+     int *y;
+{
+  Window root, dummy_window;
+  int dummy;
+
+  BLOCK_INPUT;
+
+  XQueryPointer (FRAME_X_DISPLAY (f),
+                 DefaultRootWindow (FRAME_X_DISPLAY (f)),
+
+                 /* The root window which contains the pointer.  */
+                 &root,
+
+                 /* Window pointer is on, not used  */
+                 &dummy_window,
+
+                 /* The position on that root window.  */
+                 x, y,
+
+                 /* x/y in dummy_window coordinates, not used.  */
+                 &dummy, &dummy,
+
+                 /* Modifier keys and pointer buttons, about which
+                    we don't care.  */
+                 (unsigned int *) &dummy);
+
+
+  /* Absolute to relative.  */
+  *x -= f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
+  *y -= f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
+
+  UNBLOCK_INPUT;
+}
+
+DEFUN ("x-get-atom-name", Fx_get_atom_name,
+       Sx_get_atom_name, 1, 2, 0,
+       doc: /* Return the X atom name for VALUE as a string.
+VALUE may be a number or a cons where the car is the upper 16 bits and
+the cdr is the lower 16 bits of a 32 bit value.
+Use the display for FRAME or the current frame if FRAME is not given or nil.
+
+If the value is 0 or the atom is not known, return the empty string.  */)
+  (value, frame)
+     Lisp_Object value, frame;
+{
+  struct frame *f = check_x_frame (frame);
+  char *name = 0;
+  Lisp_Object ret = Qnil;
+  int count;
+  Display *dpy = FRAME_X_DISPLAY (f);
+  Atom atom;
+
+  if (INTEGERP (value))
+    atom = (Atom) XUINT (value);
+  else if (FLOATP (value))
+    atom = (Atom) XFLOAT (value);
+  else if (CONSP (value))
+    atom = (Atom) cons_to_long (value);
+  else
+    error ("Wrong type, value must be number or cons");
+
+  BLOCK_INPUT;
+  count = x_catch_errors (dpy);
+
+  name = atom ? XGetAtomName (dpy, atom) : "";
+
+  if (! x_had_errors_p (dpy))
+    ret = make_string (name, strlen (name));
+
+  x_uncatch_errors (dpy, count);
+
+  if (atom && name) XFree (name);
+  if (NILP (ret)) ret = make_string ("", 0);
+
+  UNBLOCK_INPUT;
+
+  return ret;
+}
+
+/* Convert an XClientMessageEvent to a Lisp event of type DRAG_N_DROP_EVENT.
+   TODO: Check if this client event really is a DND event?  */
+
+int
+x_handle_dnd_message (f, event, dpyinfo, bufp)
+     struct frame *f;
+     XClientMessageEvent *event;
+     struct x_display_info *dpyinfo;
+     struct input_event *bufp;
+{
+  Lisp_Object vec;
+  Lisp_Object frame;
+  unsigned long size = (8*sizeof (event->data))/event->format;
+  int x, y;
+
+  XSETFRAME (frame, f);
+
+  vec = Fmake_vector (make_number (4), Qnil);
+  AREF (vec, 0) = SYMBOL_NAME (x_atom_to_symbol (FRAME_X_DISPLAY (f),
+                                                 event->message_type));
+  AREF (vec, 1) = frame;
+  AREF (vec, 2) = make_number (event->format);
+  AREF (vec, 3) = x_property_data_to_lisp (f,
+                                           event->data.b,
+                                           event->message_type,
+                                           event->format,
+                                           size);
+
+  mouse_position_for_drop (f, &x, &y);
+  bufp->kind = DRAG_N_DROP_EVENT;
+  bufp->frame_or_window = Fcons (frame, vec);
+  bufp->timestamp = CurrentTime;
+  bufp->x = make_number (x);
+  bufp->y = make_number (y);
+  bufp->arg = Qnil;
+  bufp->modifiers = 0;
+
+  return 1;
+}
+
+DEFUN ("x-send-client-message", Fx_send_client_event,
+       Sx_send_client_message, 6, 6, 0,
+       doc: /* Send a client message of MESSAGE-TYPE to window DEST on DISPLAY.
+
+For DISPLAY, specify either a frame or a display name (a string).
+If DISPLAY is nil, that stands for the selected frame's display.
+DEST may be a number, in which case it is a Window id.  The value 0 may
+be used to send to the root window of the DISPLAY.
+If DEST is a cons, it is converted to a 32 bit number
+with the high 16 bits from the car and the lower 16 bit from the cdr.  That
+number is then used as a window id.
+If DEST is a frame the event is sent to the outer window of that frame.
+Nil means the currently selected frame.
+If DEST is the string "PointerWindow" the event is sent to the window that
+contains the pointer.  If DEST is the string "InputFocus" the event is
+sent to the window that has the input focus.
+FROM is the frame sending the event.  Use nil for currently selected frame.
+MESSAGE-TYPE is the name of an Atom as a string.
+FORMAT must be one of 8, 16 or 32 and determines the size of the values in
+bits.  VALUES is a list of numbers, cons and/or strings containing the values
+to send.  If a value is a string, it is converted to an Atom and the value of
+the Atom is sent.  If a value is a cons, it is converted to a 32 bit number
+with the high 16 bits from the car and the lower 16 bit from the cdr.
+If more values than fits into the event is given, the excessive values
+are ignored.  */)
+     (display, dest, from, message_type, format, values)
+     Lisp_Object display, dest, from, message_type, format, values;
+{
+  struct x_display_info *dpyinfo = check_x_display_info (display);
+  Window wdest;
+  XEvent event;
+  Lisp_Object cons;
+  int size;
+  struct frame *f = check_x_frame (from);
+  int count;
+  int to_root;
+
+  CHECK_STRING (message_type);
+  CHECK_NUMBER (format);
+  CHECK_CONS (values);
+
+  if (x_check_property_data (values) == -1)
+    error ("Bad data in VALUES, must be number, cons or string");
+
+  event.xclient.type = ClientMessage;
+  event.xclient.format = XFASTINT (format);
+
+  if (event.xclient.format != 8 && event.xclient.format != 16
+      && event.xclient.format != 32)
+    error ("FORMAT must be one of 8, 16 or 32");
+  
+  if (FRAMEP (dest) || NILP (dest))
+    {
+      struct frame *fdest = check_x_frame (dest);
+      wdest = FRAME_OUTER_WINDOW (fdest);
+    }
+  else if (STRINGP (dest))
+    {
+      if (strcmp (SDATA (dest), "PointerWindow") == 0)
+        wdest = PointerWindow;
+      else if (strcmp (SDATA (dest), "InputFocus") == 0)
+        wdest = InputFocus;
+      else
+        error ("DEST as a string must be one of PointerWindow or InputFocus");
+    }
+  else if (INTEGERP (dest))
+    wdest = (Window) XFASTINT (dest);
+  else if (FLOATP (dest))
+    wdest =  (Window) XFLOAT (dest);
+  else if (CONSP (dest))
+    {
+      if (! NUMBERP (XCAR (dest)) || ! NUMBERP (XCDR (dest)))
+        error ("Both car and cdr for DEST must be numbers");
+      else
+        wdest = (Window) cons_to_long (dest);
+    }
+  else
+    error ("DEST must be a frame, nil, string, number or cons");
+
+  if (wdest == 0) wdest = dpyinfo->root_window;
+  to_root = wdest == dpyinfo->root_window;
+
+  for (cons = values, size = 0; CONSP (cons); cons = XCDR (cons), ++size)
+    ;
+
+  BLOCK_INPUT;
+
+  event.xclient.message_type
+    = XInternAtom (dpyinfo->display, SDATA (message_type), False);
+  event.xclient.display = dpyinfo->display;
+
+  /* Some clients (metacity for example) expects sending window to be here
+     when sending to the root window.  */
+  event.xclient.window = to_root ? FRAME_OUTER_WINDOW (f) : wdest;
+
+  memset (event.xclient.data.b, 0, sizeof (event.xclient.data.b));
+  x_fill_property_data (dpyinfo->display, values, event.xclient.data.b,
+                        event.xclient.format);
+
+  /* If event mask is 0 the event is sent to the client that created
+     the destination window.  But if we are sending to the root window,
+     there is no such client.  Then we set the event mask to 0xffff.  The
+     event then goes to clients selecting for events on the root window.  */
+  count = x_catch_errors (dpyinfo->display);
+  {
+    int propagate = to_root ? False : True;
+    unsigned mask = to_root ? 0xffff : 0;
+    XSendEvent (dpyinfo->display, wdest, propagate, mask, &event);
+    XFlush (dpyinfo->display);
+  }
+  x_uncatch_errors (dpyinfo->display, count);
+  UNBLOCK_INPUT;
+
+  return Qnil;
+}
+
+
 void
 syms_of_xselect ()
 {
@@ -2325,6 +2690,9 @@ syms_of_xselect ()
   defsubr (&Sx_rotate_cut_buffers_internal);
 #endif
 
+  defsubr (&Sx_get_atom_name);
+  defsubr (&Sx_send_client_message);
+
   reading_selection_reply = Fcons (Qnil, Qnil);
   staticpro (&reading_selection_reply);
   reading_selection_window = 0;
diff --git a/src/xterm.c b/src/xterm.c
index 2d60a534a42..321e9fa3f2f 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -716,7 +716,7 @@ x_draw_fringe_bitmap (w, row, p)
   else
     x_clip_to_row (w, row, gc);
 
-  if (p->bx >= 0)
+  if (p->bx >= 0 && !p->overlay_p)
     {
       /* In case the same realized face is used for fringes and
          for something displayed in the text (e.g. face `region' on
@@ -734,20 +734,49 @@ x_draw_fringe_bitmap (w, row, p)
         XSetForeground (display, face->gc, face->foreground);
     }
 
-  if (p->which != NO_FRINGE_BITMAP)
+  if (p->which)
     {
-      unsigned char *bits = fringe_bitmaps[p->which].bits + p->dh;
-      Pixmap pixmap;
+      unsigned char *bits;
+      Pixmap pixmap, clipmask = (Pixmap) 0;
       int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
+      XGCValues gcv;
+
+      if (p->wd > 8)
+        bits = (unsigned char *)(p->bits + p->dh);
+      else
+        bits = (unsigned char *)p->bits + p->dh;
 
       /* Draw the bitmap.  I believe these small pixmaps can be cached
          by the server.  */
       pixmap = XCreatePixmapFromBitmapData (display, window, bits, p->wd, p->h,
-                                            face->foreground,
+                                            (p->cursor_p
+                                             ? (p->overlay_p ? face->background
+                                                : f->output_data.x->cursor_pixel)
+                                             : face->foreground),
                                             face->background, depth);
+
+      if (p->overlay_p)
+        {
+          clipmask = XCreatePixmapFromBitmapData (display, 
+                                                  FRAME_X_DISPLAY_INFO (f)->root_window,
+                                                  bits, p->wd, p->h, 
+                                                  1, 0, 1);
+          gcv.clip_mask = clipmask;
+          gcv.clip_x_origin = p->x;
+          gcv.clip_y_origin = p->y; 
+          XChangeGC (display, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
+        }
+
       XCopyArea (display, pixmap, window, gc, 0, 0,
                  p->wd, p->h, p->x, p->y);
       XFreePixmap (display, pixmap);
+
+      if (p->overlay_p)
+        {
+          gcv.clip_mask = (Pixmap) 0;
+          XChangeGC (display, gc, GCClipMask, &gcv);
+          XFreePixmap (display, clipmask);
+        }
     }
 
   XSetClipMask (display, gc, None);
@@ -5943,7 +5972,25 @@ handle_one_xevent (dpyinfo, eventp, bufp_r, numcharsp, finish)
           }
 #endif /* USE_TOOLKIT_SCROLL_BARS */
         else
-          goto OTHER;
+          {
+            struct frame *f
+              = x_any_window_to_frame (dpyinfo, event.xclient.window);
+
+            if (f)
+              {
+                int ret = x_handle_dnd_message (f, &event.xclient,
+                                                dpyinfo, bufp);
+                if (ret > 0)
+                  {
+                    ++bufp, ++count, --numchars;
+                  }
+
+                if (ret != 0)
+                  *finish = X_EVENT_DROP;
+              }
+            else
+              goto OTHER;
+          }
       }
       break;
 
@@ -10877,6 +10924,8 @@ static struct redisplay_interface x_redisplay_interface =
     x_get_glyph_overhangs,
     x_fix_overlapping_area,
     x_draw_fringe_bitmap,
+    0, /* define_fringe_bitmap */
+    0, /* destroy_fringe_bitmap */
     x_per_char_metric,
     x_encode_char,
     x_compute_glyph_string_overhangs,
diff --git a/src/xterm.h b/src/xterm.h
index 8eb8604ae75..45de640f165 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -1009,8 +1009,24 @@ extern void x_handle_selection_request P_ ((struct input_event *));
 extern void x_handle_selection_clear P_ ((struct input_event *));
 extern void x_clear_frame_selections P_ ((struct frame *));
 
+extern int x_handle_dnd_message P_ ((struct frame *,
+                                     XClientMessageEvent *,
+                                     struct x_display_info *,
+                                     struct input_event *bufp));
+extern int x_check_property_data P_ ((Lisp_Object));
+extern void x_fill_property_data P_ ((Display *,
+                                      Lisp_Object,
+                                      void *,
+                                      int));
+extern Lisp_Object x_property_data_to_lisp P_ ((struct frame *,
+                                                unsigned char *,
+                                                Atom,
+                                                int,
+                                                unsigned long));
+
 /* Defined in xfns.c */
 
+extern struct x_display_info * check_x_display_info P_ ((Lisp_Object frame));
 extern int have_menus_p P_ ((void));
 extern int x_bitmap_height P_ ((struct frame *, int));
 extern int x_bitmap_width P_ ((struct frame *, int));
@@ -1062,6 +1078,7 @@ extern void x_free_dpy_colors P_ ((Display *, Screen *, Colormap,
 extern void x_activate_menubar P_ ((struct frame *));
 extern int popup_activated P_ ((void));
 extern void initialize_frame_menubar P_ ((struct frame *));
+extern void free_frame_menubar P_ ((struct frame *));
 
 /* Defined in widget.c */