(read_char): Use message3_nolog to show help-echo.

(make_lispy_event) <TOOLBAR_EVENT>: Apply modifiers.
(kbd_store_ptr): Declare it as a volatile pointer
instead of a pointer to a volatile input_event.
(kbd_buffer_store_event): Remove volatile modifier from
declaration of local variable `sp'.
(Fdiscard_input): Don't cast when assigning kbd_store_ptr
to kbd_fetch_ptr.
(make_lispy_event): Handle mouse on top lines.
(make_lispy_movement): Ditto.
(read_char): Rename local variable echo_area_message
because it shadows the global one.
(cmd_error_internal): Set echo_areA_message.
(command_loop_1): Test echo_areA_message.
(read_char): Ditto.
(record_menu_key): Set echo_area_message to nil.
(Fexecute_extended_command): Test echo_area_message.
(Fexecute_extended_command): Handle echo_area_message.
(toolbar_items): Call access_keymap with third
parameter 1, so that we don't get inherited toolbar item
definitions.
 Ditto.
(kbd_buffer_get_event): Set flag to prevent recording
TOOLBAR_EVENT events in last_nonmenu_event.
(timer_check): Inhibit busy cursor around calls to
timer-event-handler.  This busy cursor tends to be anoying if
fontifying stealthily.
(command_loop_1): Display busy cursor.
(Vshow_help_function): New.
(read_char): Use it.
(make_lispy_event): Add string and string position
info to mouse-click events.
(read_key_sequence): Handle `local-map' property of mode line
strings.
(Qend_scroll): New.
(scroll_bar_parts): Add it.
(scroll_bar_parts): Add Qtop and Qbottom.
(syms_of_keyboard): Add Qbottom.
(make_lispy_event): Handle scroll_bar_click
differently when using toolkit scroll bars.
(cmd_error_internal): Bug fix.
(syms_of_keyboard): Staticpro toolbar_item_properties
and toolbar_items_vectors.
(Qhelp_echo): New symbol.
(read_char): Handle `toolbar' and `help_echo' events.
(kbd_buffer_get_event): Handle HELP_ECHO input event.
(make_lispy_event): Handle TOOLBAR_EVENT.
(toolbar_items): New.
(process_toolbar_item): New.
(PROP): New.
(init_toolbar_items): New.
(append_toolbar_item): New.
(read_char_x_menu_prompt): Handle `toolbar' event.
(read_key_sequence): Ditto.
(syms_of_keyboard): Intern `:help'.
(toolbar_items): New.
(process_toolbar_item): New.
(parse_toolbar_item): New.
(init_toolbar_items): New.
(append_toolbar_item): New.
(detect_input_pending_run_timers): Likewise.
(detect_input_pending_run_timers): Call gobble_input
after redisplaying.
(clear_waiting_for_input): Return void.
(record_asynch_buffer_change): Return void.
(stop_polling): Return void.
(start_polling): Ditto.
(cmd_error_internal): Write to stderr if selected
frame is Vterminal_frame under X.  This is the case when a font
cannot be loaded when Emacs starts.  Replace test for
FRAME_MESSAGE_BUF with test for glyphs_initialized_p.
(quit_throw_to_read_char): Ditto.
(make_lispy_event): mouse clicks; don't do frame
glyph position calculations.
(make_lispy_movement): Use buffer_posn_from_coords and window
relative coordinates.
(make_lispy_event): For mouse clicks, use
x_y_to_hpos_vpos.
(make_lispy_event): Use BUFFER_POSN_FROM_COORDS
with window relative pixel coordinates.  Use GLYPH_TO_PIXEL_-
COORDS mit new arguments.
(make_lispy_event): WINDOW_FROM_COORDINATES with
pixel coords.
(make_lispy_movement): Same.
(interrupt_signal): Cursor_to with 4 params.
(command_loop_1): Call DIRECT_OUTPUT_FOR_INSERT
for any character.

1 files changed, 716 insertions, 121 deletions

diff --git a/src/keyboard.c b/src/keyboard.c
index 78860dd6496..282ce450297 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -166,6 +166,11 @@ extern int message_enable_multibyte;
 
 extern struct backtrace *backtrace_list;
 
+/* If non-nil, the function that implements the display of help.
+   It's called with one argument, the help string to display.  */
+
+Lisp_Object Vshow_help_function;
+
 /* Nonzero means do menu prompting.  */
 static int menu_prompting;
 
@@ -459,7 +464,7 @@ static struct input_event *kbd_fetch_ptr;
 /* Pointer to next place to store character in kbd_buffer.  This
    may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
    character should go in kbd_buffer[0].  */
-static volatile struct input_event *kbd_store_ptr;
+static struct input_event * volatile kbd_store_ptr;
 
 /* The above pair of variables forms a "queue empty" flag.  When we
    enqueue a non-hook event, we increment kbd_store_ptr.  When we
@@ -482,6 +487,7 @@ Lisp_Object Qswitch_frame;
 Lisp_Object Qdelete_frame;
 Lisp_Object Qiconify_frame;
 Lisp_Object Qmake_frame_visible;
+Lisp_Object Qhelp_echo;
 
 /* Symbols to denote kinds of events.  */
 Lisp_Object Qfunction_key;
@@ -600,6 +606,7 @@ static Lisp_Object make_lispy_switch_frame ();
 static int parse_solitary_modifier ();
 static void save_getcjmp ();
 static void restore_getcjmp ();
+static Lisp_Object apply_modifiers P_ ((int, Lisp_Object));
 
 /* > 0 if we are to echo keystrokes.  */
 static int echo_keystrokes;
@@ -1014,17 +1021,27 @@ cmd_error_internal (data, context)
      char *context;
 {
   Lisp_Object stream;
+  int kill_emacs_p = 0;
 
   Vquit_flag = Qnil;
   Vinhibit_quit = Qt;
   echo_area_glyphs = 0;
+  echo_area_message = Qnil;
 
   /* If the window system or terminal frame hasn't been initialized
      yet, or we're not interactive, it's best to dump this message out
      to stderr and exit.  */
-  if (! FRAME_MESSAGE_BUF (selected_frame)
+  if (!selected_frame->glyphs_initialized_p
+      /* This is the case of the frame dumped with Emacs, when we're
+         running under a window system.  */
+      || (!NILP (Vwindow_system)
+          && !inhibit_window_system
+          && !FRAME_WINDOW_P (selected_frame))
       || noninteractive)
-    stream = Qexternal_debugging_output;
+    {
+      stream = Qexternal_debugging_output;
+      kill_emacs_p = 1;
+    }
   else
     {
       Fdiscard_input ();
@@ -1039,8 +1056,7 @@ cmd_error_internal (data, context)
 
   /* If the window system or terminal frame hasn't been initialized
      yet, or we're in -batch mode, this error should cause Emacs to exit.  */
-  if (! FRAME_MESSAGE_BUF (selected_frame)
-      || noninteractive)
+  if (kill_emacs_p)
     {
       Fterpri (stream);
       Fkill_emacs (make_number (-1));
@@ -1222,7 +1238,8 @@ command_loop_1 ()
       /* If minibuffer on and echo area in use,
          wait 2 sec and redraw minibuffer.  */
 
-      if (minibuf_level && echo_area_glyphs
+      if (minibuf_level
+          && (echo_area_glyphs || STRINGP (echo_area_message))
           && EQ (minibuf_window, echo_area_window))
         {
           /* Bind inhibit-quit to t so that C-g gets read in
@@ -1421,7 +1438,6 @@ command_loop_1 ()
                 {
                   unsigned int c = XINT (last_command_char);
                   int value;
-
                   if (NILP (Vexecuting_macro)
                       && !EQ (minibuf_window, selected_window))
                     {
@@ -1432,6 +1448,7 @@ command_loop_1 ()
                         }
                       nonundocount++;
                     }
+                  
                   lose = ((XFASTINT (XWINDOW (selected_window)->last_modified)
                            < MODIFF)
                           || (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
@@ -1444,58 +1461,33 @@ command_loop_1 ()
                           || detect_input_pending ()
                           || !NILP (XWINDOW (selected_window)->column_number_displayed)
                           || !NILP (Vexecuting_macro));
+                  
                   value = internal_self_insert (c, 0);
-                  if (value)
-                    lose = 1;
+
                   if (value == 2)
                     nonundocount = 0;
 
-                  if (!lose
-                      && (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n'))
-                    {
-                      struct Lisp_Char_Table *dp
-                        = window_display_table (XWINDOW (selected_window));
-                      int lose = c;
-
-                      /* Add the offset to the character, for Finsert_char.
-                         We pass internal_self_insert the unmodified character
-                         because it itself does this offsetting.  */
-                      if (! NILP (current_buffer->enable_multibyte_characters))
-                        lose = unibyte_char_to_multibyte (lose);
-
-                      if (dp)
-                        {
-                          Lisp_Object obj;
-
-                          obj = DISP_CHAR_VECTOR (dp, lose);
-                          if (NILP (obj))
-                            {
-                              /* Do it only for char codes
-                                 that by default display as themselves.  */
-                              if (lose >= 0x20 && lose <= 0x7e)
-                                no_redisplay = direct_output_for_insert (lose);
-                            }
-                          else if (VECTORP (obj)
-                                   && XVECTOR (obj)->size == 1
-                                   && (obj = XVECTOR (obj)->contents[0],
-                                       INTEGERP (obj))
-                                   /* Insist face not specified in glyph.  */
-                                   && (XINT (obj) & ((-1) << 8)) == 0)
-                            no_redisplay
-                              = direct_output_for_insert (XINT (obj));
-                        }
-                      else
-                        {
-                          if (lose >= 0x20 && lose <= 0x7e)
-                            no_redisplay = direct_output_for_insert (lose);
-                        }
-                    }
+                  /* VALUE == 1 when AFTER-CHANGE functions are
+                     installed which is the case most of the time
+                     because FONT-LOCK installs one.  */
+                  if (!lose && !value)
+                    no_redisplay = direct_output_for_insert (c);
                   goto directly_done;
                 }
             }
 
           /* Here for a command that isn't executed directly */
 
+#ifdef HAVE_X_WINDOWS
+          if (display_busy_cursor_p)
+            {
+              if (inhibit_busy_cursor != 2)
+                inhibit_busy_cursor = 0;
+              if (!inhibit_busy_cursor)
+                Fx_show_busy_cursor ();
+            }
+#endif
+
           nonundocount = 0;
           if (NILP (current_kboard->Vprefix_arg))
             Fundo_boundary ();
@@ -1810,7 +1802,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
   jmp_buf save_jump;
   int key_already_recorded = 0;
   Lisp_Object tem, save;
-  Lisp_Object echo_area_message;
+  Lisp_Object previous_echo_area_message;
   Lisp_Object also_record;
   int reread;
   struct gcpro gcpro1, gcpro2;
@@ -1820,9 +1812,9 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
   before_command_key_count = this_command_key_count;
   before_command_echo_length = echo_length ();
   c = Qnil;
-  echo_area_message = Qnil;
+  previous_echo_area_message = Qnil;
 
-  GCPRO2 (c, echo_area_message);
+  GCPRO2 (c, previous_echo_area_message);
 
  retry:
 
@@ -1958,10 +1950,13 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
     }
 
   /* Message turns off echoing unless more keystrokes turn it on again. */
-  if (echo_area_glyphs && *echo_area_glyphs
+  if (echo_area_glyphs 
+      && *echo_area_glyphs
       && echo_area_glyphs != current_kboard->echobuf
       && ok_to_echo_at_next_pause != echo_area_glyphs)
     cancel_echoing ();
+  else if (STRINGP (echo_area_message))
+    cancel_echoing ();
   else
     /* If already echoing, continue.  */
     echo_dash ();
@@ -2034,10 +2029,12 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
   /* If in middle of key sequence and minibuffer not active,
      start echoing if enough time elapses.  */
 
-  if (minibuf_level == 0 && !current_kboard->immediate_echo
+  if (minibuf_level == 0 
+      && !current_kboard->immediate_echo
       && this_command_key_count > 0
       && ! noninteractive
       && echo_keystrokes > 0
+      && !STRINGP (echo_area_message)
       && (echo_area_glyphs == 0 || *echo_area_glyphs == 0
           || ok_to_echo_at_next_pause == echo_area_glyphs))
     {
@@ -2081,6 +2078,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       && !NILP (prev_event)
       && EVENT_HAS_PARAMETERS (prev_event)
       && !EQ (XCONS (prev_event)->car, Qmenu_bar)
+      && !EQ (XCONS (prev_event)->car, Qtoolbar)
       /* Don't bring up a menu if we already have another event.  */
       && NILP (Vunread_command_events)
       && unread_command_char < 0)
@@ -2333,7 +2331,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       posn = POSN_BUFFER_POSN (EVENT_START (c));
       /* Handle menu-bar events:
          insert the dummy prefix event `menu-bar'.  */
-      if (EQ (posn, Qmenu_bar))
+      if (EQ (posn, Qmenu_bar) || EQ (posn, Qtoolbar))
         {
           /* Change menu-bar to (menu-bar) as the event "position".  */
           POSN_BUFFER_POSN (EVENT_START (c)) = Fcons (posn, Qnil);
@@ -2357,12 +2355,16 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       && ! NILP (Vinput_method_function)
       && (unsigned) XINT (c) >= ' '
       && (unsigned) XINT (c) < 127)
-    Vinput_method_previous_message = echo_area_message = Fcurrent_message ();
+    {
+      previous_echo_area_message = Fcurrent_message ();
+      Vinput_method_previous_message = previous_echo_area_message;
+    }
 
   /* Now wipe the echo area.  */
-  if (echo_area_glyphs)
+  if (echo_area_glyphs || STRINGP (echo_area_message))
     safe_run_hooks (Qecho_area_clear_hook);
   echo_area_glyphs = 0;
+  echo_area_message = Qnil;
 
  reread_for_input_method:
  from_macro:
@@ -2407,9 +2409,10 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       this_command_key_count = 0;
 
       /* Now wipe the echo area.  */
-      if (echo_area_glyphs)
+      if (echo_area_glyphs || STRINGP (echo_area_message))
         safe_run_hooks (Qecho_area_clear_hook);
       echo_area_glyphs = 0;
+      echo_area_message = Qnil;
       echo_truncate (0);
 
       /* If we are not reading a key sequence,
@@ -2442,8 +2445,8 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       if (! CONSP (tem))
         {
           /* Bring back the previous message, if any.  */
-          if (! NILP (echo_area_message))
-            message_with_string ("%s", echo_area_message, 0);
+          if (! NILP (previous_echo_area_message))
+            message_with_string ("%s", previous_echo_area_message, 0);
           goto retry;
         }
       /* It returned one event or more.  */
@@ -2454,6 +2457,25 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
 
  reread_first:
 
+  /* Display help if not echoing.  */
+  if (CONSP (c)
+      && EQ (XCAR (c), Qhelp_echo))
+    {
+      Lisp_Object msg = XCDR (XCDR (c));
+
+      if (!NILP (Vshow_help_function))
+        call1 (Vshow_help_function, msg);
+      else if (!echoing && !MINI_WINDOW_P (XWINDOW (selected_window)))
+        {
+          if (STRINGP (msg))
+            message3_nolog (msg, XSTRING (msg)->size, STRING_MULTIBYTE (msg));
+          else
+            message (0);
+        }
+      
+      goto retry;
+    }
+  
   if (this_command_key_count == 0 || ! reread)
     {
       before_command_key_count = this_command_key_count;
@@ -2523,6 +2545,7 @@ record_menu_key (c)
 {
   /* Wipe the echo area.  */
   echo_area_glyphs = 0;
+  echo_area_message = Qnil;
 
   record_char (c);
 
@@ -2855,7 +2878,7 @@ kbd_buffer_store_event (event)
      Discard the event if it would fill the last slot.  */
   if (kbd_fetch_ptr - 1 != kbd_store_ptr)
     {
-      volatile struct input_event *sp = kbd_store_ptr;
+      struct input_event *sp = kbd_store_ptr;
       sp->kind = event->kind;
       if (event->kind == selection_request_event)
         {
@@ -3100,7 +3123,13 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
          mouse events during a popup-menu call.  */
       else if (event->kind == no_event)
         kbd_fetch_ptr = event + 1;
-
+      else if (event->kind == HELP_EVENT)
+        {
+          /* The car of event->frame_or_window is a frame,
+             the cdr is the help to display.  */
+          obj = Fcons (Qhelp_echo, event->frame_or_window);
+          kbd_fetch_ptr = event + 1;
+        }
       /* If this event is on a different frame, return a switch-frame this
          time, and leave the event in the queue for next time.  */
       else
@@ -3135,8 +3164,10 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
                  we're returning is (menu-bar), though; that indicates the
                  beginning of the menu sequence, and we might as well leave
                  that as the `event with parameters' for this selection.  */
-              if (event->kind == menu_bar_event
+              if ((event->kind == menu_bar_event
+                   || event->kind == TOOLBAR_EVENT)
                   && !(CONSP (obj) && EQ (XCONS (obj)->car, Qmenu_bar))
+                  && !(CONSP (obj) && EQ (XCONS (obj)->car, Qtoolbar))
                   && used_mouse_menu)
                 *used_mouse_menu = 1;
 #endif
@@ -3471,6 +3502,9 @@ timer_check (do_it_now)
               Lisp_Object tem;
               int was_locked = single_kboard;
               int count = specpdl_ptr - specpdl;
+#ifdef HAVE_WINDOW_SYSTEM
+              int old_inhibit_busy_cursor = inhibit_busy_cursor;
+#endif
 
               /* Mark the timer as triggered to prevent problems if the lisp
                  code fails to reschedule it right.  */
@@ -3478,9 +3512,17 @@ timer_check (do_it_now)
 
               specbind (Qinhibit_quit, Qt);
 
+#ifdef HAVE_WINDOW_SYSTEM
+              inhibit_busy_cursor = 2;
+#endif
+              
               call1 (Qtimer_event_handler, chosen_timer);
               timers_run++;
 
+#ifdef HAVE_WINDOW_SYSTEM
+              inhibit_busy_cursor = old_inhibit_busy_cursor;
+#endif
+
               unbind_to (count, Qnil);
 
               /* Resume allowing input from any kboard, if that was true before.  */
@@ -3946,12 +3988,13 @@ static char *lispy_drag_n_drop_names[] =
 
 /* Scroll bar parts.  */
 Lisp_Object Qabove_handle, Qhandle, Qbelow_handle;
-Lisp_Object Qup, Qdown;
+Lisp_Object Qup, Qdown, Qbottom, Qend_scroll;
+Lisp_Object Qtop;
 
 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value.  */
 Lisp_Object *scroll_bar_parts[] = {
   &Qabove_handle, &Qhandle, &Qbelow_handle,
-  &Qup, &Qdown,
+  &Qup, &Qdown, &Qtop, &Qbottom, &Qend_scroll
 };
 
 /* User signal events.  */
@@ -4095,7 +4138,9 @@ make_lispy_event (event)
       /* A mouse click.  Figure out where it is, decide whether it's
          a press, click or drag, and build the appropriate structure.  */
     case mouse_click:
+#ifndef USE_TOOLKIT_SCROLL_BARS
     case scroll_bar_click:
+#endif
       {
         int button = event->code;
         int is_double;
@@ -4113,6 +4158,7 @@ make_lispy_event (event)
             FRAME_PTR f = XFRAME (event->frame_or_window);
             Lisp_Object window;
             Lisp_Object posn;
+            Lisp_Object string_info = Qnil;
             int row, column;
 
             /* Ignore mouse events that were made on frame that
@@ -4120,8 +4166,13 @@ make_lispy_event (event)
             if (! FRAME_LIVE_P (f))
               return Qnil;
 
-            pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
-                                   &column, &row, NULL, 1);
+            /* EVENT->x and EVENT->y are frame-relative pixel
+               coordinates at this place.  Under old redisplay, COLUMN
+               and ROW are set to frame relative glyph coordinates
+               which are then used to determine whether this click is
+               in a menu (non-toolkit version).  */
+            pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
+                                   &column, &row, NULL, 1);
 
 #ifndef USE_X_TOOLKIT
             /* In the non-toolkit version, clicks on the menu bar
@@ -4146,6 +4197,7 @@ make_lispy_event (event)
                   return Qnil;
 #endif
 
+                /* Find the menu bar item under `column'.  */
                 item = Qnil;
                 items = FRAME_MENU_BAR_ITEMS (f);
                 for (i = 0; i < XVECTOR (items)->size; i += 4)
@@ -4163,6 +4215,8 @@ make_lispy_event (event)
                       }
                   }
 
+                /* ELisp manual 2.4b says (x y) are window relative but
+                   code says they are frame-relative.  */
                 position
                   = Fcons (event->frame_or_window,
                            Fcons (Qmenu_bar,
@@ -4174,7 +4228,10 @@ make_lispy_event (event)
               }
 #endif /* not USE_X_TOOLKIT */
 
-            window = window_from_coordinates (f, column, row, &part);
+            /* Set `window' to the window under frame pixel coordinates
+               event->x/event->y.  */
+            window = window_from_coordinates (f, XINT (event->x),
+                                              XINT (event->y), &part, 0);
 
             if (!WINDOWP (window))
               {
@@ -4183,21 +4240,36 @@ make_lispy_event (event)
               }
             else
               {
-                int pixcolumn, pixrow;
-                column -= WINDOW_LEFT_MARGIN (XWINDOW (window));
-                row -= XINT (XWINDOW (window)->top);
-                glyph_to_pixel_coords (f, column, row, &pixcolumn, &pixrow);
-                XSETINT (event->x, pixcolumn);
-                XSETINT (event->y, pixrow);
-
-                if (part == 1)
-                  posn = Qmode_line;
+                /* It's a click in window window at frame coordinates
+                   event->x/ event->y.  */
+                struct window *w = XWINDOW (window);
+
+                /* Get window relative coordinates.  Original code
+                   `rounded' this to glyph boundaries.  */
+                int wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (event->x));
+                int wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (event->y));
+
+                /* Set event coordinates to window-relative coordinates
+                   for constructing the Lisp event below.  */
+                XSETINT (event->x, wx);
+                XSETINT (event->y, wy);
+
+                if (part == 1 || part == 3)
+                  {
+                    /* Mode line or top line.  Look for a string under
+                       the mouse that may have a `local-map' property.  */
+                    Lisp_Object string;
+                    int charpos;
+                    
+                    posn = part == 1 ? Qmode_line : Qtop_line;
+                    string = mode_line_string (w, wx, wy, part == 1, &charpos);
+                    if (STRINGP (string))
+                      string_info = Fcons (string, make_number (charpos));
+                  }
                 else if (part == 2)
                   posn = Qvertical_line;
                 else
-                  XSETINT (posn,
-                           buffer_posn_from_coords (XWINDOW (window),
-                                                    column, row));
+                  XSETINT (posn, buffer_posn_from_coords (w, &wx, &wy));
               }
 
             position
@@ -4205,10 +4277,14 @@ make_lispy_event (event)
                        Fcons (posn,
                               Fcons (Fcons (event->x, event->y),
                                      Fcons (make_number (event->timestamp),
-                                            Qnil))));
+                                            (NILP (string_info)
+                                             ? Qnil
+                                             : Fcons (string_info, Qnil))))));
           }
+#ifndef USE_TOOLKIT_SCROLL_BARS
         else
           {
+            /* It's a scrollbar click.  */
             Lisp_Object window;
             Lisp_Object portion_whole;
             Lisp_Object part;
@@ -4224,6 +4300,7 @@ make_lispy_event (event)
                                      Fcons (make_number (event->timestamp),
                                             Fcons (part, Qnil)))));
           }
+#endif /* not USE_TOOLKIT_SCROLL_BARS */
 
         start_pos_ptr = &XVECTOR (button_down_location)->contents[button];
 
@@ -4335,6 +4412,55 @@ make_lispy_event (event)
         }
       }
 
+#if USE_TOOLKIT_SCROLL_BARS
+
+      /* We don't have down and up events if using toolkit scroll bars,
+         so make this always a click event.  Store in the `part' of
+         the Lisp event a symbol which maps to the following actions:
+
+         `above_handle'         page up
+         `below_handle'         page down
+         `up'                   line up
+         `down'                 line down
+         `top'                  top of buffer
+         `bottom'               bottom of buffer
+         `handle'               thumb has been dragged.
+         `end-scroll'           end of interaction with scroll bar
+
+         The incoming input_event contains in its `part' member an
+         index of type `enum scroll_bar_part' which we can use as an
+         index in scroll_bar_parts to get the appropriate symbol.  */
+         
+    case scroll_bar_click:
+      {
+        Lisp_Object position, head, window, portion_whole, part;
+
+        window = event->frame_or_window;
+        portion_whole = Fcons (event->x, event->y);
+        part = *scroll_bar_parts[(int) event->part];
+
+        position
+          = Fcons (window,
+                   Fcons (Qvertical_scroll_bar,
+                          Fcons (portion_whole,
+                                 Fcons (make_number (event->timestamp),
+                                        Fcons (part, Qnil)))));
+
+        /* Always treat scroll bar events as clicks. */
+        event->modifiers |= click_modifier;
+
+        /* Get the symbol we should use for the mouse click.  */
+        head = modify_event_symbol (event->code,
+                                    event->modifiers,
+                                    Qmouse_click, Qnil,
+                                    lispy_mouse_names, &mouse_syms,
+                                    (sizeof (lispy_mouse_names)
+                                     / sizeof (lispy_mouse_names[0])));
+        return Fcons (head, Fcons (position, Qnil));
+      }
+      
+#endif /* USE_TOOLKIT_SCROLL_BARS */
+
 #ifdef WINDOWSNT
     case w32_scroll_bar_click:
       {
@@ -4397,7 +4523,7 @@ make_lispy_event (event)
           return Qnil;
         pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
                                &column, &row, NULL, 1);
-        window = window_from_coordinates (f, column, row, &part);
+        window = window_from_coordinates (f, column, row, &part, 0);
 
         if (!WINDOWP (window))
           {
@@ -4417,6 +4543,8 @@ make_lispy_event (event)
               posn = Qmode_line;
             else if (part == 2)
               posn = Qvertical_line;
+            else if (part == 3)
+              posn = Qtop_line;
             else
               XSETINT (posn,
                        buffer_posn_from_coords (XWINDOW (window),
@@ -4470,7 +4598,7 @@ make_lispy_event (event)
           return Qnil;
         pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
                                &column, &row, NULL, 1);
-        window = window_from_coordinates (f, column, row, &part);
+        window = window_from_coordinates (f, column, row, &part, 0);
 
         if (!WINDOWP (window))
           {
@@ -4479,21 +4607,27 @@ make_lispy_event (event)
           }
         else
           {
-            int pixcolumn, pixrow;
-            column -= XINT (XWINDOW (window)->left);
-            row -= XINT (XWINDOW (window)->top);
-            glyph_to_pixel_coords (f, column, row, &pixcolumn, &pixrow);
-            XSETINT (event->x, pixcolumn);
-            XSETINT (event->y, pixrow);
+            /* It's an event in window `window' at frame coordinates
+               event->x/ event->y.  */
+            struct window *w = XWINDOW (window);
+
+            /* Get window relative coordinates.  */
+            int wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (event->x));
+            int wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (event->y));
+
+            /* Set event coordinates to window-relative coordinates
+               for constructing the Lisp event below.  */
+            XSETINT (event->x, wx);
+            XSETINT (event->y, wy);
 
             if (part == 1)
               posn = Qmode_line;
             else if (part == 2)
               posn = Qvertical_line;
+            else if (part == 3)
+              posn = Qtop_line;
             else
-              XSETINT (posn,
-                       buffer_posn_from_coords (XWINDOW (window),
-                                                column, row));
+              XSETINT (posn, buffer_posn_from_coords (w, &wx, &wy));
           }
 
         {
@@ -4526,6 +4660,17 @@ make_lispy_event (event)
       return XCONS (event->frame_or_window)->cdr;
 #endif
 
+    case TOOLBAR_EVENT:
+      {
+        Lisp_Object key;
+        if (!CONSP (event->frame_or_window))
+          abort ();
+        key = XCDR (event->frame_or_window);
+        if (SYMBOLP (key))
+          key = apply_modifiers (event->modifiers, key);
+        return key;
+      }
+
     case user_signal:
       /* A user signal.  */
       return *lispy_user_signals[event->code];
@@ -4568,34 +4713,34 @@ make_lispy_movement (frame, bar_window, part, x, y, time)
       int area;
       Lisp_Object window;
       Lisp_Object posn;
-      int column, row;
 
       if (frame)
-        {
-          /* It's in a frame; which window on that frame?  */
-          pixel_to_glyph_coords (frame, XINT (x), XINT (y), &column, &row,
-                                 NULL, 1);
-          window = window_from_coordinates (frame, column, row, &area);
-        }
+        /* It's in a frame; which window on that frame?  */
+        window = window_from_coordinates (frame, XINT (x), XINT (y), &area, 0);
       else
         window = Qnil;
 
       if (WINDOWP (window))
         {
-          int pixcolumn, pixrow;
-          column -= WINDOW_LEFT_MARGIN (XWINDOW (window));
-          row -= XINT (XWINDOW (window)->top);
-          glyph_to_pixel_coords (frame, column, row, &pixcolumn, &pixrow);
-          XSETINT (x, pixcolumn);
-          XSETINT (y, pixrow);
-
+          struct window *w = XWINDOW (window);
+          int hpos, vpos;
+          int wx, wy;
+          int pos;
+          
+          /* Get window relative coordinates.  */
+          wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (x));
+          wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (y));
+          XSETINT (x, wx);
+          XSETINT (y, wy);
+          
           if (area == 1)
             posn = Qmode_line;
           else if (area == 2)
             posn = Qvertical_line;
+          else if (area == 3)
+            posn = Qtop_line;
           else
-            XSETINT (posn,
-                     buffer_posn_from_coords (XWINDOW (window), column, row));
+            XSETINT (posn, buffer_posn_from_coords (w, &wx, &wy));
         }
       else if (frame != 0)
         {
@@ -5846,7 +5991,7 @@ menu_item_eval_property_1 (arg)
 
 /* Evaluate an expression and return the result (or nil if something 
    went wrong).  Used to evaluate dynamic parts of menu items.  */
-static Lisp_Object
+Lisp_Object
 menu_item_eval_property (sexpr)
      Lisp_Object sexpr;
 {
@@ -6206,6 +6351,392 @@ parse_menu_item (item, notreal, inmenubar)
 
   return 1;
 }
+
+
+
+/***********************************************************************
+                               Tool-bars
+ ***********************************************************************/
+
+/* A vector holding toolbar items while they are parsed in function
+   toolbar_items runs Each item occupies TOOLBAR_ITEM_NSCLOTS
+   elements in the vector.  */
+
+static Lisp_Object toolbar_items_vector;
+
+/* A vector holding the result of parse_toolbar_item.  Layout is like
+   the one for a single item in toolbar_items_vector.  */
+
+static Lisp_Object toolbar_item_properties;
+
+/* Next free index in toolbar_items_vector.  */
+
+static int ntoolbar_items;
+
+/* The symbols `toolbar', `toolbar-item', and `:image'.  */
+
+extern Lisp_Object Qtoolbar;
+Lisp_Object QCimage;
+
+/* Function prototypes.  */
+
+static void init_toolbar_items P_ ((Lisp_Object));
+static void process_toolbar_item P_ ((Lisp_Object, Lisp_Object));
+static int parse_toolbar_item P_ ((Lisp_Object, Lisp_Object));
+static void append_toolbar_item P_ ((void));
+
+
+/* Return a vector of toolbar items for keymaps currently in effect.
+   Reuse vector REUSE if non-nil.  Return in *NITEMS the number of
+   toolbar items found.  */
+
+Lisp_Object
+toolbar_items (reuse, nitems)
+     Lisp_Object reuse;
+     int *nitems;
+{
+  Lisp_Object *maps;
+  int nmaps, i;
+  Lisp_Object oquit;
+  Lisp_Object *tmaps;
+  extern Lisp_Object Voverriding_local_map_menu_flag;
+  extern Lisp_Object Voverriding_local_map;
+
+  *nitems = 0;
+
+  /* In order to build the menus, we need to call the keymap
+     accessors.  They all call QUIT.  But this function is called
+     during redisplay, during which a quit is fatal.  So inhibit
+     quitting while building the menus.  We do this instead of
+     specbind because (1) errors will clear it anyway and (2) this
+     avoids risk of specpdl overflow.  */
+  oquit = Vinhibit_quit;
+  Vinhibit_quit = Qt;
+  
+  /* Initialize toolbar_items_vector and protect it from GC.  */
+  init_toolbar_items (reuse);
+
+  /* Build list of keymaps in maps.  Set nmaps to the number of maps
+     to process.  */
+  
+  /* Should overriding-terminal-local-map and overriding-local-map apply?  */
+  if (!NILP (Voverriding_local_map_menu_flag))
+    {
+      /* Yes, use them (if non-nil) as well as the global map.  */
+      maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
+      nmaps = 0;
+      if (!NILP (current_kboard->Voverriding_terminal_local_map))
+        maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
+      if (!NILP (Voverriding_local_map))
+        maps[nmaps++] = Voverriding_local_map;
+    }
+  else
+    {
+      /* No, so use major and minor mode keymaps.  */
+      nmaps = current_minor_maps (NULL, &tmaps);
+      maps = (Lisp_Object *) alloca ((nmaps + 2) * sizeof (maps[0]));
+      bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
+#ifdef USE_TEXT_PROPERTIES
+      maps[nmaps++] = get_local_map (PT, current_buffer);
+#else
+      maps[nmaps++] = current_buffer->keymap;
+#endif
+    }
+
+  /* Add global keymap at the end.  */
+  maps[nmaps++] = current_global_map;
+
+  /* Process maps in reverse order and look up in each map the prefix
+     key `toolbar'.  */
+  for (i = nmaps - 1; i >= 0; --i)
+    if (!NILP (maps[i]))
+      {
+        Lisp_Object keymap;
+      
+        keymap = get_keyelt (access_keymap (maps[i], Qtoolbar, 1, 1), 0);
+        if (!NILP (Fkeymapp (keymap)))
+          {
+            Lisp_Object tail;
+            
+            /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'.  */
+            for (tail = keymap; CONSP (tail); tail = XCONS (tail)->cdr)
+              {
+                Lisp_Object keydef = XCAR (tail);
+                if (CONSP (keydef))
+                  process_toolbar_item (XCAR (keydef), XCDR (keydef));
+              }
+          }
+      }
+
+  Vinhibit_quit = oquit;
+  *nitems = ntoolbar_items / TOOLBAR_ITEM_NSLOTS;
+  return toolbar_items_vector;
+}
+
+
+/* Process the definition of KEY which is DEF.  */
+
+static void
+process_toolbar_item (key, def)
+     Lisp_Object key, def;
+{
+  int i;
+  extern Lisp_Object Qundefined;
+  struct gcpro gcpro1, gcpro2;
+
+  /* Protect KEY and DEF from GC because parse_toolbar_item may call
+     eval.  */
+  GCPRO2 (key, def);
+
+  if (EQ (def, Qundefined))
+    {
+      /* If a map has an explicit `undefined' as definition,
+         discard any previously made item.  */
+      for (i = 0; i < ntoolbar_items; i += TOOLBAR_ITEM_NSLOTS)
+        {
+          Lisp_Object *v = XVECTOR (toolbar_items_vector)->contents + i;
+          
+          if (EQ (key, v[TOOLBAR_ITEM_KEY]))
+            {
+              if (ntoolbar_items > i + TOOLBAR_ITEM_NSLOTS)
+                bcopy (v + TOOLBAR_ITEM_NSLOTS, v,
+                       ((ntoolbar_items - i - TOOLBAR_ITEM_NSLOTS)
+                        * sizeof (Lisp_Object)));
+              ntoolbar_items -= TOOLBAR_ITEM_NSLOTS;
+              break;
+            }
+        }
+    }
+  else if (parse_toolbar_item (key, def))
+    /* Append a new toolbar item to toolbar_items_vector.  Accept
+       more than one definition for the same key.  */
+    append_toolbar_item ();
+
+  UNGCPRO;
+}
+
+
+/* Parse a toolbar item specification ITEM for key KEY and return the
+   result in toolbar_item_properties.  Value is zero if ITEM is
+   invalid.
+
+   ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
+   
+   CAPTION is the caption of the item,  If it's not a string, it is
+   evaluated to get a string.
+   
+   BINDING is the toolbar item's binding.  Toolbar items with keymaps
+   as binding are currently ignored.
+
+   The following properties are recognized:
+
+   - `:enable FORM'.
+   
+   FORM is evaluated and specifies whether the toolbar item is enabled
+   or disabled.
+   
+   - `:visible FORM'
+   
+   FORM is evaluated and specifies whether the toolbar item is visible.
+   
+   - `:filter FUNCTION'
+
+   FUNCTION is invoked with one parameter `(quote BINDING)'.  Its
+   result is stored as the new binding.
+   
+   - `:button (TYPE SELECTED)'
+
+   TYPE must be one of `:radio' or `:toggle'.  SELECTED is evaluated
+   and specifies whether the button is selected (pressed) or not.
+   
+   - `:image IMAGES'
+
+   IMAGES is either a single image specification or a vector of four
+   image specifications.  See enum toolbar_item_images.
+   
+   - `:help HELP-STRING'.
+   
+   Gives a help string to display for the toolbar item.  */
+
+static int
+parse_toolbar_item (key, item)
+     Lisp_Object key, item;
+{
+  /* Access slot with index IDX of vector toolbar_item_properties.  */
+#define PROP(IDX) XVECTOR (toolbar_item_properties)->contents[IDX]
+
+  Lisp_Object filter = Qnil;
+  Lisp_Object caption;
+  extern Lisp_Object QCenable, QCvisible, QChelp, QCfilter;
+  extern Lisp_Object QCbutton, QCtoggle, QCradio;
+  int i;
+  struct gcpro gcpro1;
+
+  /* Defininition looks like `(toolbar-item CAPTION BINDING
+     PROPS...)'.  Rule out items that aren't lists, don't start with
+     `toolbar-item' or whose rest following `toolbar-item' is not a
+     list.  */
+  if (!CONSP (item)
+      || !EQ (XCAR (item), Qmenu_item)
+      || (item = XCDR (item),
+          !CONSP (item)))
+    return 0;
+
+  /* Create toolbar_item_properties vector if necessary.  Reset it to
+     defaults.  */
+  if (VECTORP (toolbar_item_properties))
+    {
+      for (i = 0; i < TOOLBAR_ITEM_NSLOTS; ++i)
+        PROP (i) = Qnil;
+    }
+  else
+    toolbar_item_properties
+      = Fmake_vector (make_number (TOOLBAR_ITEM_NSLOTS), Qnil);
+  
+  /* Set defaults.  */
+  PROP (TOOLBAR_ITEM_KEY) = key;
+  PROP (TOOLBAR_ITEM_ENABLED_P) = Qt;
+         
+  /* Get the caption of the item.  If the caption is not a string,
+     evaluate it to get a string.  If we don't get a string, skip this
+     item.  */
+  caption = XCAR (item);
+  if (!STRINGP (caption))
+    {
+      caption = menu_item_eval_property (caption);
+      if (!STRINGP (caption))
+        return 0;
+    }
+  PROP (TOOLBAR_ITEM_CAPTION) = caption;
+
+  /* Give up if rest following the caption is not a list.  */
+  item = XCDR (item);
+  if (!CONSP (item))
+    return 0;
+
+  /* Store the binding.  */
+  PROP (TOOLBAR_ITEM_BINDING) = XCAR (item);
+  item = XCDR (item);
+
+  /* Process the rest of the properties.  */
+  for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
+    {
+      Lisp_Object key, value;
+
+      key = XCAR (item);
+      value = XCAR (XCDR (item));
+
+      if (EQ (key, QCenable))
+        /* `:enable FORM'.  */
+        PROP (TOOLBAR_ITEM_ENABLED_P) = value;
+      else if (EQ (key, QCvisible))
+        {
+          /* `:visible FORM'.  If got a visible property and that
+             evaluates to nil then ignore this item.  */
+          if (NILP (menu_item_eval_property (value)))
+            return 0;
+        }
+      else if (EQ (key, QChelp))
+        /* `:help HELP-STRING'.  */
+        PROP (TOOLBAR_ITEM_HELP) = value;
+      else if (EQ (key, QCfilter))
+        /* ':filter FORM'.  */
+        filter = value;
+      else if (EQ (key, QCbutton) && CONSP (value))
+        {
+          /* `:button (TYPE . SELECTED)'.  */
+          Lisp_Object type, selected;
+
+          type = XCAR (value);
+          selected = XCDR (value);
+          if (EQ (type, QCtoggle) || EQ (type, QCradio))
+            {
+              PROP (TOOLBAR_ITEM_SELECTED_P) = selected;
+              PROP (TOOLBAR_ITEM_TYPE) = type;
+            }
+        }
+      else if (EQ (key, QCimage)
+               && (CONSP (value)
+                   || (VECTORP (value) && XVECTOR (value)->size == 4)))
+        /* Value is either a single image specification or a vector
+           of 4 such specifications for the different buttion states.  */
+        PROP (TOOLBAR_ITEM_IMAGES) = value;
+    }
+
+  /* If got a filter apply it on binding.  */
+  if (!NILP (filter))
+    PROP (TOOLBAR_ITEM_BINDING)
+      = menu_item_eval_property (list2 (filter,
+                                        list2 (Qquote,
+                                               PROP (TOOLBAR_ITEM_BINDING))));
+
+  /* See if the binding is a keymap.  Give up if it is.  */
+  if (!NILP (get_keymap_1 (PROP (TOOLBAR_ITEM_BINDING), 0, 1)))
+    return 0;
+
+  /* Enable or disable selection of item.  */
+  if (!EQ (PROP (TOOLBAR_ITEM_ENABLED_P), Qt))
+    PROP (TOOLBAR_ITEM_ENABLED_P)
+      = menu_item_eval_property (PROP (TOOLBAR_ITEM_ENABLED_P));
+
+  /* Handle radio buttons or toggle boxes.  */ 
+  if (!NILP (PROP (TOOLBAR_ITEM_SELECTED_P)))
+    PROP (TOOLBAR_ITEM_SELECTED_P)
+      = menu_item_eval_property (PROP (TOOLBAR_ITEM_SELECTED_P));
+
+  return 1;
+  
+#undef PROP
+}
+
+
+/* Initialize Vtoolbar_items.  REUSE, if non-nil, is a vector that can
+   be reused.  */
+
+static void
+init_toolbar_items (reuse)
+     Lisp_Object reuse;
+{
+  if (VECTORP (reuse))
+    toolbar_items_vector = reuse;
+  else
+    toolbar_items_vector = Fmake_vector (make_number (64), Qnil);
+  ntoolbar_items = 0;
+}
+
+
+/* Append parsed toolbar item properties from toolbar_item_properties */
+
+static void
+append_toolbar_item ()
+{
+  Lisp_Object *to, *from;
+  
+  /* Enlarge toolbar_items_vector if necessary.  */
+  if (ntoolbar_items + TOOLBAR_ITEM_NSLOTS
+      >= XVECTOR (toolbar_items_vector)->size)
+    {
+      Lisp_Object new_vector;
+      int old_size = XVECTOR (toolbar_items_vector)->size;
+
+      new_vector = Fmake_vector (make_number (2 * old_size), Qnil);
+      bcopy (XVECTOR (toolbar_items_vector)->contents,
+             XVECTOR (new_vector)->contents,
+             old_size * sizeof (Lisp_Object));
+      toolbar_items_vector = new_vector;
+    }
+
+  /* Append entries from toolbar_item_properties to the end of
+     toolbar_items_vector.  */
+  to = XVECTOR (toolbar_items_vector)->contents + ntoolbar_items;
+  from = XVECTOR (toolbar_item_properties)->contents;
+  bcopy (from, to, TOOLBAR_ITEM_NSLOTS * sizeof *to);
+  ntoolbar_items += TOOLBAR_ITEM_NSLOTS;
+}
+
+
+
+
 
 /* Read a character using menus based on maps in the array MAPS.
    NMAPS is the length of MAPS.  Return nil if there are no menus in the maps.
@@ -6269,7 +6800,8 @@ read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
   /* If we got to this point via a mouse click,
      use a real menu for mouse selection.  */
   if (EVENT_HAS_PARAMETERS (prev_event)
-      && !EQ (XCONS (prev_event)->car, Qmenu_bar))
+      && !EQ (XCONS (prev_event)->car, Qmenu_bar)
+      && !EQ (XCONS (prev_event)->car, Qtoolbar))
     {
       /* Display the menu and get the selection.  */
       Lisp_Object *realmaps
@@ -7114,6 +7646,7 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
 
               window = POSN_WINDOW      (EVENT_START (key));
               posn   = POSN_BUFFER_POSN (EVENT_START (key));
+
               if (CONSP (posn))
                 {
                   /* We're looking at the second event of a
@@ -7154,15 +7687,18 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
                   orig_local_map = get_local_map (PT, current_buffer);
                   goto replay_sequence;
                 }
+              
               /* For a mouse click, get the local text-property keymap
                  of the place clicked on, rather than point.  */
-              if (last_real_key_start == 0 && CONSP (XCONS (key)->cdr)
+              if (last_real_key_start == 0
+                  && CONSP (XCONS (key)->cdr)
                   && ! localized_local_map)
                 {
                   Lisp_Object map_here, start, pos;
 
                   localized_local_map = 1;
                   start = EVENT_START (key);
+                  
                   if (CONSP (start) && CONSP (XCONS (start)->cdr))
                     {
                       pos = POSN_BUFFER_POSN (start);
@@ -7191,11 +7727,33 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
                   keybuf[t] = posn;
                   keybuf[t+1] = key;
                   mock_input = t + 2;
-
+                  
                   /* Zap the position in key, so we know that we've
                      expanded it, and don't try to do so again.  */
                   POSN_BUFFER_POSN (EVENT_START (key))
                     = Fcons (posn, Qnil);
+
+                  /* If on a mode line string with a local keymap,
+                     reconsider the key sequence with that keymap.  */
+                  if (CONSP (POSN_STRING (EVENT_START (key))))
+                    {
+                      Lisp_Object string, pos, map;
+
+                      string = POSN_STRING (EVENT_START (key));
+                      pos = XCDR (string);
+                      string = XCAR (string);
+                      
+                      if (pos >= 0
+                          && pos < XSTRING (string)->size
+                          && (map = Fget_text_property (pos, Qlocal_map,
+                                                        string),
+                              !NILP (map)))
+                        {
+                          orig_local_map = map;
+                          goto replay_sequence;
+                        }
+                    }
+
                   goto replay_key;
                 }
             }
@@ -7208,7 +7766,7 @@ read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
               posn = POSN_BUFFER_POSN (EVENT_START (key));
               /* Handle menu-bar events:
                  insert the dummy prefix event `menu-bar'.  */
-              if (EQ (posn, Qmenu_bar))
+              if (EQ (posn, Qmenu_bar) || EQ (posn, Qtoolbar))
                 {
                   if (t + 1 >= bufsize)
                     error ("Key sequence too long");
@@ -8085,7 +8643,7 @@ DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_
     {
       /* But first wait, and skip the message if there is input.  */
       int delay_time;
-      if (echo_area_glyphs != 0)
+      if (echo_area_glyphs != 0 || STRINGP (echo_area_message))
         /* This command displayed something in the echo area;
            so wait a few seconds, then display our suggestion message.  */
         delay_time = (NUMBERP (Vsuggest_key_bindings)
@@ -8101,6 +8659,7 @@ DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_
           Lisp_Object binding;
           char *newmessage;
           char *oldmessage = echo_area_glyphs;
+          Lisp_Object oldmessage_string = echo_area_message;
           int oldmessage_len = echo_area_glyphs_length;
           int oldmultibyte = message_enable_multibyte;
 
@@ -8119,7 +8678,13 @@ DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_
           if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings)
                                 ? Vsuggest_key_bindings : make_number (2)),
                                Qnil, Qnil)))
-            message2_nolog (oldmessage, oldmessage_len, oldmultibyte);
+            {
+              if (STRINGP (oldmessage_string))
+                message3_nolog (oldmessage_string, oldmessage_len,
+                                oldmultibyte);
+              else
+                message2_nolog (oldmessage, oldmessage_len, oldmultibyte);
+            }
         }
     }
 
@@ -8190,7 +8755,16 @@ detect_input_pending_run_timers (do_display)
     get_input_pending (&input_pending, 1);
 
   if (old_timers_run != timers_run && do_display)
-    redisplay_preserve_echo_area ();
+    {
+      redisplay_preserve_echo_area ();
+      /* The following fixes a bug when using lazy-lock with
+         lazy-lock-defer-on-the-fly set to t, i.e.  when fontifying
+         from an idle timer function.  The symptom of the bug is that
+         the cursor sometimes doesn't become visible until the next X
+         event is processed.  --gerd.  */
+      if (rif)
+        rif->flush_display (NULL);
+    }
 
   return input_pending;
 }
@@ -8369,10 +8943,7 @@ Also cancel any kbd macro being defined.")
 
   discard_tty_input ();
 
-  /* Without the cast, GCC complains that this assignment loses the
-     volatile qualifier of kbd_store_ptr.  Is there anything wrong
-     with that?  */
-  kbd_fetch_ptr = (struct input_event *) kbd_store_ptr;
+  kbd_fetch_ptr =  kbd_store_ptr;
   Ffillarray (kbd_buffer_frame_or_window, Qnil);
   input_pending = 0;
 
@@ -8658,7 +9229,6 @@ interrupt_signal (signalnum)	/* If we don't have an argument, */
 void
 quit_throw_to_read_char ()
 {
-  quit_error_check ();
   sigfree ();
   /* Prevent another signal from doing this before we finish.  */
   clear_waiting_for_input ();
@@ -8936,9 +9506,21 @@ struct event_head head_table[] = {
 void
 syms_of_keyboard ()
 {
+  /* Toolbars.  */
+  QCimage = intern (":image");
+  staticpro (&QCimage);
+
+  staticpro (&Qhelp_echo);
+  Qhelp_echo = intern ("help-echo");
+
   staticpro (&item_properties);
   item_properties = Qnil;
 
+  staticpro (&toolbar_item_properties);
+  toolbar_item_properties = Qnil;
+  staticpro (&toolbar_items_vector);
+  toolbar_items_vector = Qnil;
+
   staticpro (&real_this_command);
   real_this_command = Qnil;
 
@@ -9004,6 +9586,8 @@ syms_of_keyboard ()
   staticpro (&QCenable);
   QCvisible = intern (":visible");
   staticpro (&QCvisible);
+  QChelp = intern (":help");
+  staticpro (&QChelp);
   QCfilter = intern (":filter");
   staticpro (&QCfilter);
   QCbutton = intern (":button");
@@ -9036,6 +9620,12 @@ syms_of_keyboard ()
   staticpro (&Qup);
   Qdown = intern ("down");
   staticpro (&Qdown);
+  Qtop = intern ("top");
+  staticpro (&Qtop);
+  Qbottom = intern ("bottom");
+  staticpro (&Qbottom);
+  Qend_scroll = intern ("end-scroll");
+  staticpro (&Qend_scroll);
 
   Qevent_kind = intern ("event-kind");
   staticpro (&Qevent_kind);
@@ -9493,6 +10083,11 @@ for guidance on what to do.");
 This variable exists because `read-event' clears the echo area\n\
 before running the input method.  It is nil if there was no message.");
   Vinput_method_previous_message = Qnil;
+
+  DEFVAR_LISP ("show-help-function", &Vshow_help_function,
+    "If non-nil, the function that implements the display of help.\n\
+It's called with one argument, the help string to display.");
+  Vshow_help_function = Qnil;
 }
 
 void