(last_nonmenu_event): New var.

(syms_of_keyboard): New Lisp var.
(read_key_sequence): Use that instead of prev_event.

(read_char): Call read_char_menu_prompt here.
Accept 4 new args to pass to it.  Include them in recursive call.
Don't delay before starting echo if prev_event was a mouse event.
Test for eof in batch mode now understands C is a Lisp_Object.
(read_key_sequence): Don't call it here; always call read_char.
Don't change last_event_buffer after a mouse menu input.
(read_char_menu_prompt): Arg PROMPT deleted.
Return nil if nothing to do.

(read_key_sequence): Keep track of prev_event.
Pass new proper args to read_char_menu_prompt.
(read_char_menu_prompt): New arg prev_event.  Use Fx_popup_menu.
Handle any number of keymaps, not just LOCAL and GLOBAL.
Invert meaning of arg PROMPT.  Test of menu_prompting was backwards.

(keymap_table): No longer static.

1 files changed, 240 insertions, 117 deletions

diff --git a/src/keyboard.c b/src/keyboard.c
index c8b5299b7e3..8988a5e762c 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -141,6 +141,10 @@ int num_input_keys;
 /* Last input character read as a command.  */
 Lisp_Object last_command_char;
 
+/* Last input character read as a command, not counting menus
+   reached by the mouse.  */
+Lisp_Object last_nonmenu_event;
+
 /* Last input character read for any purpose.  */
 Lisp_Object last_input_char;
 
@@ -1052,9 +1056,22 @@ static Lisp_Object kbd_buffer_get_event ();
    -1 means do not do redisplay, but do do autosaving.
    1 means do both.  */
 
+/* The arguments MAPS and NMAPS are for menu prompting.
+   MAPS is an array of keymaps;  NMAPS is the length of MAPS.
+
+   PREV_EVENT is the previous input event, or nil if we are reading
+   the first event of a key sequence.
+
+   If we use a mouse menu to read the input, we store 1 into *USED_MOUSE_MENU.
+   Otherwise we store 0 there.  */
+
 Lisp_Object
-read_char (commandflag)
+read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
      int commandflag;
+     int nmaps;
+     Lisp_Object *maps;
+     Lisp_Object prev_event;
+     int *used_mouse_menu;
 {
   register Lisp_Object c;
   int count;
@@ -1118,9 +1135,17 @@ read_char (commandflag)
     {
       Lisp_Object tem0;
 
-      tem0 = sit_for (echo_keystrokes, 0, 1, 1);
-      if (EQ (tem0, Qt))
+      /* After a mouse event, start echoing right away.
+         This is because we are probably about to display a menu,
+         and we don't want to delay before doing so.  */
+      if (XTYPE (prev_event) == Lisp_Cons)
         echo ();
+      else
+        {
+          tem0 = sit_for (echo_keystrokes, 0, 1, 1);
+          if (EQ (tem0, Qt))
+            echo ();
+        }
     }
 
   /* Maybe auto save due to number of keystrokes or idle time.  */
@@ -1136,55 +1161,65 @@ read_char (commandflag)
       restore_getcjmp (temp);
     }
 
+  /* Try reading a character via menu prompting.
+     Try this before the sit-for, because the sit-for
+     would do the wrong thing if we are supposed to do
+     menu prompting.  */
+  c = Qnil;
+  if (INTERACTIVE && !NILP (prev_event))
+    c = read_char_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
+
   /* Slow down auto saves logarithmically in size of current buffer,
      and garbage collect while we're at it.  */
-  {
-    int delay_level, buffer_size;
-
-    if (! MINI_WINDOW_P (XWINDOW (selected_window)))
-      last_non_minibuf_size = Z - BEG;
-    buffer_size = (last_non_minibuf_size >> 8) + 1;
-    delay_level = 0;
-    while (buffer_size > 64)
-      delay_level++, buffer_size -= buffer_size >> 2;
-    if (delay_level < 4) delay_level = 4;
-    /* delay_level is 4 for files under around 50k, 7 at 100k,
-       9 at 200k, 11 at 300k, and 12 at 500k.  It is 15 at 1 meg.  */
-
-    /* Auto save if enough time goes by without input.  */
-    if (commandflag != 0
-        && num_input_chars > last_auto_save
-        && XTYPE (Vauto_save_timeout) == Lisp_Int
-        && XINT (Vauto_save_timeout) > 0)
-      {
-        Lisp_Object tem0;
-        int delay = delay_level * XFASTINT (Vauto_save_timeout) / 4;
-        tem0 = sit_for (delay, 0, 1, 1);
-        if (EQ (tem0, Qt))
-          {
-            jmp_buf temp;
-            save_getcjmp (temp);
-            Fdo_auto_save (Qnil, Qnil);
-            restore_getcjmp (temp);
-
-            /* If we have auto-saved and there is still no input
-               available, garbage collect if there has been enough
-               consing going on to make it worthwhile.  */
-            if (!detect_input_pending ()
-                && consing_since_gc > gc_cons_threshold / 2)
-              Fgarbage_collect ();
-          }
-      }
-  }
+  if (NILP (c))
+    {
+      int delay_level, buffer_size;
+
+      if (! MINI_WINDOW_P (XWINDOW (selected_window)))
+        last_non_minibuf_size = Z - BEG;
+      buffer_size = (last_non_minibuf_size >> 8) + 1;
+      delay_level = 0;
+      while (buffer_size > 64)
+        delay_level++, buffer_size -= buffer_size >> 2;
+      if (delay_level < 4) delay_level = 4;
+      /* delay_level is 4 for files under around 50k, 7 at 100k,
+         9 at 200k, 11 at 300k, and 12 at 500k.  It is 15 at 1 meg.  */
+
+      /* Auto save if enough time goes by without input.  */
+      if (commandflag != 0
+          && num_input_chars > last_auto_save
+          && XTYPE (Vauto_save_timeout) == Lisp_Int
+          && XINT (Vauto_save_timeout) > 0)
+        {
+          Lisp_Object tem0;
+          int delay = delay_level * XFASTINT (Vauto_save_timeout) / 4;
+          tem0 = sit_for (delay, 0, 1, 1);
+          if (EQ (tem0, Qt))
+            {
+              jmp_buf temp;
+              save_getcjmp (temp);
+              Fdo_auto_save (Qnil, Qnil);
+              restore_getcjmp (temp);
+
+              /* If we have auto-saved and there is still no input
+                 available, garbage collect if there has been enough
+                 consing going on to make it worthwhile.  */
+              if (!detect_input_pending ()
+                  && consing_since_gc > gc_cons_threshold / 2)
+                Fgarbage_collect ();
+            }
+        }
+    }
 
   /* Actually read a character, waiting if necessary.  */
-  c = kbd_buffer_get_event ();
+  if (NILP (c))
+    c = kbd_buffer_get_event ();
 
   if (NILP (c))
     abort ();                   /* Don't think this can happen. */
 
   /* Terminate Emacs in batch mode if at eof.  */
-  if (noninteractive && c < 0)
+  if (noninteractive && XTYPE (c) == Lisp_Int && XINT (c) < 0)
     Fkill_emacs (make_number (1));
 
  non_reread:
@@ -1278,7 +1313,7 @@ read_char (commandflag)
       if (EQ (c, make_number (040)))
         {
           cancel_echoing ();
-          c = read_char (0);
+          c = read_char (0, 0, 0, Qnil, 0);
         }
     }
 
@@ -1543,8 +1578,8 @@ kbd_buffer_get_event ()
         kbd_fetch_ptr = kbd_buffer;
       /* Do the redirection specified by the focus_frame
          member now, before we return this event.  */
-      kbd_fetch_ptr->frame =
-        XFRAME (FRAME_FOCUS_FRAME (kbd_fetch_ptr->frame));
+      kbd_fetch_ptr->frame
+        = XFRAME (FRAME_FOCUS_FRAME (kbd_fetch_ptr->frame));
 
 #ifdef MULTI_FRAME
       XSET (Vlast_event_frame, Lisp_Frame, kbd_fetch_ptr->frame);
@@ -2233,54 +2268,85 @@ static int echo_flag;
 static int echo_now;
 
 /* Read a character like read_char but optionally prompt based on maps
-   LOCAL and GLOBAL.
+   in the array MAPS.  NMAPS is the length of MAPS.
+
+   PREV_EVENT is the previous input event, or nil if we are reading
+   the first event of a key sequence.
+
+   If we use a mouse menu to read the input, we store 1 into *USED_MOUSE_MENU.
+   Otherwise we store 0 there.
 
    The prompting is done based on the prompt-string of the map
    and the strings associated with various map elements.  */
 
 Lisp_Object
-read_char_menu_prompt (prompt, local, global)
-     int prompt;
-     Lisp_Object local, global;
+read_char_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
+     int nmaps;
+     Lisp_Object *maps;
+     Lisp_Object prev_event;
+     int *used_mouse_menu;
 {
-  register Lisp_Object rest, name;
-  Lisp_Object hmap;
+  int mapno;
+  register Lisp_Object name;
   int nlength;
   int width = FRAME_WIDTH (selected_frame) - 4;
-  char *menu = (char *) alloca (width);
+  char *menu = (char *) alloca (width + 4);
+  int idx = -1;
+  Lisp_Object rest, vector;
+
+  *used_mouse_menu = 0;
 
   /* Use local over global Menu maps */
 
-  if (menu_prompting)
-    return read_char (!prompt);
-
-  /* We can't get prompt strings from dense keymaps.  */
-  if (CONSP (local)
-      && EQ (Fcar (local), Qkeymap)
-      && !(CONSP (XCONS (local)->cdr)
-           && XTYPE (XCONS (XCONS (local)->cdr)->car) == Lisp_Vector))
-    hmap = local;
-  else if (CONSP (global)
-           && EQ (Fcar (global), Qkeymap)
-           && !(CONSP (XCONS (global)->cdr)
-                && XTYPE (XCONS (XCONS (global)->cdr)->car) == Lisp_Vector))
-    hmap = global;
-  else
-    return read_char (!prompt);
+  if (! menu_prompting)
+    return Qnil;
+
+  /* Get the menu name from the first map that has one (a prompt string).  */
+  for (mapno = 0; mapno < nmaps; mapno++)
+    {
+      name = map_prompt (maps[mapno]);
+      if (!NILP (name))
+        break;
+    }
 
-  /* Get the map's prompt string.  */
-  name = map_prompt (hmap);
+  /* If we don't have any menus, just read a character normally.  */
   if (NILP (name))
-    return read_char (!prompt);
+    return Qnil;
+
+#ifdef HAVE_X_MENU
+  /* If we got to this point via a mouse click,
+     use a real menu for mouse selection.  */
+  if (XTYPE (prev_event) == Lisp_Cons)
+    {
+      /* Display the menu and get the selection.  */
+      Lisp_Object *realmaps
+        = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
+      Lisp_Object value;
+      int nmaps1 = 0;
+
+      /* Use the maps that are not nil.  */
+      for (mapno = 0; mapno < nmaps; mapno++)
+        if (!NILP (maps[mapno]))
+          realmaps[nmaps1++] = maps[mapno];
+
+      value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
+      if (NILP (value))
+        XSET (value, Lisp_Int, quit_char);
+      *used_mouse_menu = 1;
+      return value;
+    }
+#endif /* HAVE_X_MENU */
 
   /* Prompt string always starts with map's prompt, and a space.  */
   strcpy (menu, XSTRING (name)->data);
   nlength = XSTRING (name)->size;
+  menu[nlength++] = ':';
   menu[nlength++] = ' ';
   menu[nlength] = 0;
 
-  /* Start prompting at start of map.  */
-  rest = hmap;                  /* Current menu item */
+  /* Start prompting at start of first map.  */
+  mapno = 0;
+  rest = maps[mapno];
 
   /* Present the documented bindings, a line at a time.  */
   while (1)
@@ -2290,54 +2356,92 @@ read_char_menu_prompt (prompt, local, global)
       Lisp_Object obj;
       int ch;
 
-      /* If reached end of map, start at beginning.  */
-      if (NILP (Fcdr (rest))) rest = hmap;
-
       /* Loop over elements of map.  */
-      while (!NILP (rest) && i < width)
+      while (i < width)
         {
-          Lisp_Object s;
-
-          /* Look for conses whose cadrs are strings.  */
-          s = Fcar_safe (Fcdr_safe (Fcar_safe (rest)));
-          if (XTYPE (s) != Lisp_String)
-            /* Ignore all other elements.  */
-            ;
-          /* If first such element, or enough room, add string to prompt.  */
-          else if (XSTRING (s)->size + i < width
-                   || !notfirst)
-            {
-              int thiswidth;
+          Lisp_Object s, elt;
 
-              /* Punctuate between strings.  */
-              if (notfirst)
+          /* If reached end of map, start at beginning of next map.  */
+          if (NILP (rest))
+            {
+              mapno++;
+              /* At end of last map, wrap around to first map if just starting,
+                 or end this line if already have something on it.  */
+              if (mapno == nmaps)
                 {
-                  strcpy (menu + i, ", ");
-                  i += 2;
+                  if (notfirst)
+                    break;
+                  else
+                    mapno = 0;
                 }
-              notfirst = 1;
-
-              /* Add as much of string as fits.  */
-              thiswidth = XSTRING (s)->size;
-              if (thiswidth + i > width)
-                thiswidth = width - i;
-              bcopy (XSTRING (s)->data, menu + i, thiswidth);
-              i += thiswidth;
+              rest = maps[mapno];
             }
+
+          /* Look at the next element of the map.  */
+          if (idx >= 0)
+            elt = XVECTOR (vector)->contents[idx];
           else
+            elt = Fcar_safe (rest);
+
+          if (idx < 0 && XTYPE (elt) == Lisp_Vector)
             {
-              /* If some elts don't fit, show there are more.  */
-              strcpy (menu + i, "...");
-              break;
+              /* If we found a dense table in the keymap,
+                 advanced past it, but start scanning its contents.  */
+              rest = Fcdr_safe (rest);
+              vector = elt;
+              idx = 0;
             }
+          else
+            {
+              /* An ordinary element.  */
+              s = Fcar_safe (Fcdr_safe (elt));
+              if (XTYPE (s) != Lisp_String)
+                /* Ignore the element if it has no prompt string.  */
+                ;
+              /* If we have room for the prompt string, add it to this line.
+                 If this is the first on the line, always add it.  */
+              else if (XSTRING (s)->size + i < width
+                       || !notfirst)
+                {
+                  int thiswidth;
 
-          /* Move past this element.  */
-          rest = Fcdr_safe (rest);
+                  /* Punctuate between strings.  */
+                  if (notfirst)
+                    {
+                      strcpy (menu + i, ", ");
+                      i += 2;
+                    }
+                  notfirst = 1;
+
+                  /* Add as much of string as fits.  */
+                  thiswidth = XSTRING (s)->size;
+                  if (thiswidth + i > width)
+                    thiswidth = width - i;
+                  bcopy (XSTRING (s)->data, menu + i, thiswidth);
+                  i += thiswidth;
+                }
+              else
+                {
+                  /* If this element does not fit, end the line now,
+                     and save the element for the next line.  */
+                  strcpy (menu + i, "...");
+                  break;
+                }
+
+              /* Move past this element.  */
+              if (idx >= 0 && idx + 1 >= XVECTOR (rest)->size)
+                /* Handle reaching end of dense table.  */
+                idx = -1;
+              if (idx >= 0)
+                idx++;
+              else
+                rest = Fcdr_safe (rest);
+            }
         }
 
       /* Prompt with that and read response.  */
       message1 (menu);
-      obj = read_char (1);
+      obj = read_char (1, 0, 0, Qnil, 0);
 
       if (XTYPE (obj) != Lisp_Int)
         return obj;
@@ -2350,7 +2454,6 @@ read_char_menu_prompt (prompt, local, global)
         return obj;
     }
 }
-
 
 /* Reading key sequences.  */
 
@@ -2518,6 +2621,8 @@ read_key_sequence (keybuf, bufsize, prompt)
   int fkey_start = 0, fkey_end = 0;
   Lisp_Object fkey_map = Vfunction_key_map;
 
+  last_nonmenu_event = Qnil;
+
   if (INTERACTIVE)
     {
       if (prompt)
@@ -2561,6 +2666,7 @@ read_key_sequence (keybuf, bufsize, prompt)
          || (first_binding >= nmaps && fkey_start < t))
     {
       Lisp_Object key;
+      int used_mouse_menu = 0;
 
       if (t >= bufsize)
         error ("key sequence too long");
@@ -2578,10 +2684,8 @@ read_key_sequence (keybuf, bufsize, prompt)
         {
           struct buffer *buf;
 
-          if (!prompt && INTERACTIVE)
-            key = read_char_menu_prompt (prompt, Qnil, Qnil);
-          else
-            key = read_char (!prompt);
+          key = read_char (!prompt, nmaps, submaps, last_nonmenu_event,
+                           &used_mouse_menu);
 
           /* The above routines return -1 at the end of a macro.
              Emacs 18 handles this by returning immediately with a
@@ -2593,7 +2697,10 @@ read_key_sequence (keybuf, bufsize, prompt)
 
 #ifdef MULTI_FRAME
           /* What buffer was this event typed/moused at?  */
-          if (XTYPE (key) == Lisp_Int || XTYPE (key) == Lisp_Symbol)
+          if (used_mouse_menu)
+            /* Never change last_event_buffer for using a menu.  */
+            buf = last_event_buffer;
+          else if (XTYPE (key) == Lisp_Int || XTYPE (key) == Lisp_Symbol)
             buf = (XBUFFER
                    (XWINDOW
                     (FRAME_SELECTED_WINDOW
@@ -2638,6 +2745,12 @@ read_key_sequence (keybuf, bufsize, prompt)
                                    submaps + first_binding)
                        + first_binding);
       keybuf[t++] = key;
+      /* Normally, last_nonmenu_event gets the previous key we read.
+         But when a mouse popup menu is being used,
+         we don't update last_nonmenu_event; it continues to hold the mouse
+         event that preceded the first level of menu.  */
+      if (!used_mouse_menu)
+        last_nonmenu_event = key;
 
       /* If the sequence is unbound, see if we can hang a function key
          off the end of it.  We only want to scan real keyboard input
@@ -3418,11 +3531,17 @@ syms_of_keyboard ()
 
   DEFVAR_LISP ("disabled-command-hook", &Vdisabled_command_hook,
     "Value is called instead of any command that is disabled\n\
-(has a non-nil `disabled' property).");
+\(has a non-nil `disabled' property).");
 
   DEFVAR_LISP ("last-command-char", &last_command_char,
     "Last terminal input key that was part of a command.");
 
+  DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event,
+    "Last terminal input key in a command, except for mouse menus.\n\
+Mouse menus give back keys that don't look like mouse events;\n\
+this variable holds the actual mouse event that led to the menu,\n\
+so that you can determine whether the command was run by mouse or not.");
+
   DEFVAR_LISP ("last-input-char", &last_input_char,
     "Last terminal input key.");
 
@@ -3503,9 +3622,13 @@ If string is of length N, character codes N and up are untranslated.");
   Vkeyboard_translate_table = Qnil;
 
   DEFVAR_BOOL ("menu-prompting", &menu_prompting,
-    "Non-nil means prompt with menus in echo area when appropriate.\n\
+    "Non-nil means prompt with menus when appropriate.\n\
 This is done when reading from a keymap that has a prompt string,\n\
-for elements that have prompt strings.");
+for elements that have prompt strings.\n\
+The menu is displayed on the screen\n\
+if X menus were enabled at configuration\n\
+time and the previous event was a mouse click prefix key.\n\
+Otherwise, menu prompting uses the echo area.");
   menu_prompting = 1;
 
   DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char,