Merge branch 'feature/tabs'

1 files changed, 425 insertions, 11 deletions

diff --git a/src/keyboard.c b/src/keyboard.c
index a16d13cc7b8..40aaf496384 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2385,7 +2385,8 @@ read_char (int commandflag, Lisp_Object map,
       if (used_mouse_menu
           /* Also check was_disabled so last-nonmenu-event won't return
              a bad value when submenus are involved.  (Bug#447)  */
-          && (EQ (c, Qtool_bar) || EQ (c, Qmenu_bar) || was_disabled))
+          && (EQ (c, Qtool_bar) || EQ (c, Qtab_bar) || EQ (c, Qmenu_bar)
+              || was_disabled))
         *used_mouse_menu = true;
 
       goto reread_for_input_method;
@@ -2666,6 +2667,7 @@ read_char (int commandflag, Lisp_Object map,
       && !NILP (prev_event)
       && EVENT_HAS_PARAMETERS (prev_event)
       && !EQ (XCAR (prev_event), Qmenu_bar)
+      && !EQ (XCAR (prev_event), Qtab_bar)
       && !EQ (XCAR (prev_event), Qtool_bar)
       /* Don't bring up a menu if we already have another event.  */
       && !CONSP (Vunread_command_events))
@@ -2930,7 +2932,7 @@ read_char (int commandflag, Lisp_Object map,
       posn = POSN_POSN (xevent_start (c));
       /* Handle menu-bar events:
          insert the dummy prefix event `menu-bar'.  */
-      if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
+      if (EQ (posn, Qmenu_bar) || EQ (posn, Qtab_bar) || EQ (posn, Qtool_bar))
         {
           /* Change menu-bar to (menu-bar) as the event "position".  */
           POSN_SET_POSN (xevent_start (c), list1 (posn));
@@ -3974,6 +3976,7 @@ kbd_buffer_get_event (KBOARD **kbp,
               if (used_mouse_menu
                   && !EQ (event->ie.frame_or_window, event->ie.arg)
                   && (event->kind == MENU_BAR_EVENT
+                      || event->kind == TAB_BAR_EVENT
                       || event->kind == TOOL_BAR_EVENT))
                 *used_mouse_menu = true;
 #endif
@@ -5012,7 +5015,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
   int xret = 0, yret = 0;
   /* The window or frame under frame pixel coordinates (x,y)  */
   Lisp_Object window_or_frame = f
-    ? window_from_coordinates (f, XFIXNUM (x), XFIXNUM (y), &part, 0)
+    ? window_from_coordinates (f, XFIXNUM (x), XFIXNUM (y), &part, 0, 0)
     : Qnil;
 
   if (WINDOWP (window_or_frame))
@@ -5036,17 +5039,21 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
       if (part == ON_TEXT)
         {
           xret = XFIXNUM (x) - window_box_left (w, TEXT_AREA);
-          yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
+          yret = wy - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w);
         }
       /* For mode line and header line clicks, return X, Y relative to
          the left window edge.  Use mode_line_string to look for a
          string on the click position.  */
-      else if (part == ON_MODE_LINE || part == ON_HEADER_LINE)
+      else if (part == ON_MODE_LINE || part == ON_TAB_LINE
+               || part == ON_HEADER_LINE)
         {
           Lisp_Object string;
           ptrdiff_t charpos;
 
-          posn = (part == ON_MODE_LINE) ? Qmode_line : Qheader_line;
+          posn = (part == ON_MODE_LINE ? Qmode_line
+                  : (part == ON_TAB_LINE ? Qtab_line
+                     : Qheader_line));
+
           /* Note that mode_line_string takes COL, ROW as pixels and
              converts them to characters.  */
           col = wx;
@@ -5075,7 +5082,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
           if (STRINGP (string))
             string_info = Fcons (string, make_fixnum (charpos));
           xret = wx;
-          yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
+          yret = wy - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w);
         }
       else if (part == ON_LEFT_FRINGE)
         {
@@ -5085,7 +5092,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
           dx = wx
             - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
                ? 0 : window_box_width (w, LEFT_MARGIN_AREA));
-          dy = yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
+          dy = yret = wy - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w);
         }
       else if (part == ON_RIGHT_FRINGE)
         {
@@ -5098,7 +5105,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
             - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
                ? window_box_width (w, RIGHT_MARGIN_AREA)
                : 0);
-          dy = yret = wy - WINDOW_HEADER_LINE_HEIGHT (w);
+          dy = yret = wy - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w);
         }
       else if (part == ON_VERTICAL_BORDER)
         {
@@ -5953,6 +5960,16 @@ make_lispy_event (struct input_event *event)
       /* Make an event (select-window (WINDOW)).  */
       return list2 (Qselect_window, list1 (event->frame_or_window));
 
+    case TAB_BAR_EVENT:
+      if (EQ (event->arg, event->frame_or_window))
+        /* This is the prefix key.  We translate this to
+           `(tab_bar)' because the code in keyboard.c for tab bar
+           events, which we use, relies on this.  */
+        return list1 (Qtab_bar);
+      else if (SYMBOLP (event->arg))
+        return apply_modifiers (event->modifiers, event->arg);
+      return event->arg;
+
     case TOOL_BAR_EVENT:
       if (EQ (event->arg, event->frame_or_window))
         /* This is the prefix key.  We translate this to
@@ -6730,6 +6747,7 @@ lucid_event_type_list_p (Lisp_Object object)
   if (EQ (XCAR (object), Qhelp_echo)
       || EQ (XCAR (object), Qvertical_line)
       || EQ (XCAR (object), Qmode_line)
+      || EQ (XCAR (object), Qtab_line)
       || EQ (XCAR (object), Qheader_line))
     return 0;
 
@@ -7891,6 +7909,389 @@ parse_menu_item (Lisp_Object item, int inmenubar)
 
 
 /***********************************************************************
+                               Tab-bars
+ ***********************************************************************/
+
+/* A vector holding tab bar items while they are parsed in function
+   tab_bar_items. Each item occupies TAB_BAR_ITEM_NSCLOTS elements
+   in the vector.  */
+
+static Lisp_Object tab_bar_items_vector;
+
+/* A vector holding the result of parse_tab_bar_item.  Layout is like
+   the one for a single item in tab_bar_items_vector.  */
+
+static Lisp_Object tab_bar_item_properties;
+
+/* Next free index in tab_bar_items_vector.  */
+
+static int ntab_bar_items;
+
+/* Function prototypes.  */
+
+static void init_tab_bar_items (Lisp_Object);
+static void process_tab_bar_item (Lisp_Object, Lisp_Object, Lisp_Object,
+                                   void *);
+static bool parse_tab_bar_item (Lisp_Object, Lisp_Object);
+static void append_tab_bar_item (void);
+
+
+/* Return a vector of tab bar items for keymaps currently in effect.
+   Reuse vector REUSE if non-nil.  Return in *NITEMS the number of
+   tab bar items found.  */
+
+Lisp_Object
+tab_bar_items (Lisp_Object reuse, int *nitems)
+{
+  Lisp_Object *maps;
+  Lisp_Object mapsbuf[3];
+  ptrdiff_t nmaps, i;
+  Lisp_Object oquit;
+  Lisp_Object *tmaps;
+  USE_SAFE_ALLOCA;
+
+  *nitems = 0;
+
+  /* In order to build the menus, we need to call the keymap
+     accessors.  They all call maybe_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 tab_bar_items_vector and protect it from GC.  */
+  init_tab_bar_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)
+      && !NILP (Voverriding_local_map))
+    {
+      /* Yes, use them (if non-nil) as well as the global map.  */
+      maps = mapsbuf;
+      nmaps = 0;
+      if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
+        maps[nmaps++] = KVAR (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 and keymap property.
+         Note that tab-bar bindings in the local-map and keymap
+         properties may not work reliably, as they are only
+         recognized when the tab-bar (or mode-line) is updated,
+         which does not normally happen after every command.  */
+      ptrdiff_t nminor = current_minor_maps (NULL, &tmaps);
+      SAFE_NALLOCA (maps, 1, nminor + 4);
+      nmaps = 0;
+      Lisp_Object tem = KVAR (current_kboard, Voverriding_terminal_local_map);
+      if (!NILP (tem) && !NILP (Voverriding_local_map_menu_flag))
+        maps[nmaps++] = tem;
+      if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
+        maps[nmaps++] = tem;
+      if (nminor != 0)
+        {
+          memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
+          nmaps += nminor;
+        }
+      maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
+    }
+
+  /* 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 `tab-bar'.  */
+  for (i = nmaps - 1; i >= 0; --i)
+    if (!NILP (maps[i]))
+      {
+        Lisp_Object keymap;
+
+        keymap = get_keymap (access_keymap (maps[i], Qtab_bar, 1, 0, 1), 0, 1);
+        if (CONSP (keymap))
+          map_keymap (keymap, process_tab_bar_item, Qnil, NULL, 1);
+      }
+
+  Vinhibit_quit = oquit;
+  *nitems = ntab_bar_items / TAB_BAR_ITEM_NSLOTS;
+  SAFE_FREE ();
+  return tab_bar_items_vector;
+}
+
+
+/* Process the definition of KEY which is DEF.  */
+
+static void
+process_tab_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void *args)
+{
+  int i;
+
+  if (EQ (def, Qundefined))
+    {
+      /* If a map has an explicit `undefined' as definition,
+         discard any previously made item.  */
+      for (i = 0; i < ntab_bar_items; i += TAB_BAR_ITEM_NSLOTS)
+        {
+          Lisp_Object *v = XVECTOR (tab_bar_items_vector)->contents + i;
+
+          if (EQ (key, v[TAB_BAR_ITEM_KEY]))
+            {
+              if (ntab_bar_items > i + TAB_BAR_ITEM_NSLOTS)
+                memmove (v, v + TAB_BAR_ITEM_NSLOTS,
+                         ((ntab_bar_items - i - TAB_BAR_ITEM_NSLOTS)
+                          * word_size));
+              ntab_bar_items -= TAB_BAR_ITEM_NSLOTS;
+              break;
+            }
+        }
+    }
+  else if (parse_tab_bar_item (key, def))
+    /* Append a new tab bar item to tab_bar_items_vector.  Accept
+       more than one definition for the same key.  */
+    append_tab_bar_item ();
+}
+
+/* Access slot with index IDX of vector tab_bar_item_properties.  */
+#define PROP(IDX) AREF (tab_bar_item_properties, (IDX))
+static void
+set_prop_tab_bar (ptrdiff_t idx, Lisp_Object val)
+{
+  ASET (tab_bar_item_properties, idx, val);
+}
+
+
+/* Parse a tab bar item specification ITEM for key KEY and return the
+   result in tab_bar_item_properties.  Value is false 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 tab bar item's binding.  Tab-bar items with keymaps
+   as binding are currently ignored.
+
+   The following properties are recognized:
+
+   - `:enable FORM'.
+
+   FORM is evaluated and specifies whether the tab bar item is
+   enabled or disabled.
+
+   - `:visible FORM'
+
+   FORM is evaluated and specifies whether the tab bar 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 tab_bar_item_images.
+
+   - `:help HELP-STRING'.
+
+   Gives a help string to display for the tab bar item.
+
+   - `:label LABEL-STRING'.
+
+   A text label to show with the tab bar button if labels are enabled.  */
+
+static bool
+parse_tab_bar_item (Lisp_Object key, Lisp_Object item)
+{
+  Lisp_Object filter = Qnil;
+  Lisp_Object caption;
+  int i;
+
+  /* Definition looks like `(menu-item CAPTION BINDING PROPS...)'.
+     Rule out items that aren't lists, don't start with
+     `menu-item' or whose rest following `tab-bar-item' is not a
+     list.  */
+  if (!CONSP (item))
+    return 0;
+
+  /* As an exception, allow old-style menu separators.  */
+  if (STRINGP (XCAR (item)))
+    item = list1 (XCAR (item));
+  else if (!EQ (XCAR (item), Qmenu_item)
+           || (item = XCDR (item), !CONSP (item)))
+    return 0;
+
+  /* Create tab_bar_item_properties vector if necessary.  Reset it to
+     defaults.  */
+  if (VECTORP (tab_bar_item_properties))
+    {
+      for (i = 0; i < TAB_BAR_ITEM_NSLOTS; ++i)
+        set_prop_tab_bar (i, Qnil);
+    }
+  else
+    tab_bar_item_properties = make_nil_vector (TAB_BAR_ITEM_NSLOTS);
+
+  /* Set defaults.  */
+  set_prop_tab_bar (TAB_BAR_ITEM_KEY, key);
+  set_prop_tab_bar (TAB_BAR_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;
+    }
+  set_prop_tab_bar (TAB_BAR_ITEM_CAPTION, caption);
+
+  /* If the rest following the caption is not a list, the menu item is
+     either a separator, or invalid.  */
+  item = XCDR (item);
+  if (!CONSP (item))
+    {
+      if (menu_separator_name_p (SSDATA (caption)))
+        {
+          set_prop_tab_bar (TAB_BAR_ITEM_ENABLED_P, Qnil);
+          set_prop_tab_bar (TAB_BAR_ITEM_SELECTED_P, Qnil);
+          set_prop_tab_bar (TAB_BAR_ITEM_CAPTION, Qnil);
+          return 1;
+        }
+      return 0;
+    }
+
+  /* Store the binding.  */
+  set_prop_tab_bar (TAB_BAR_ITEM_BINDING, XCAR (item));
+  item = XCDR (item);
+
+  /* Ignore cached key binding, if any.  */
+  if (CONSP (item) && CONSP (XCAR (item)))
+    item = XCDR (item);
+
+  /* Process the rest of the properties.  */
+  for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
+    {
+      Lisp_Object ikey, value;
+
+      ikey = XCAR (item);
+      value = XCAR (XCDR (item));
+
+      if (EQ (ikey, QCenable))
+        {
+          /* `:enable FORM'.  */
+          if (!NILP (Venable_disabled_menus_and_buttons))
+            set_prop_tab_bar (TAB_BAR_ITEM_ENABLED_P, Qt);
+          else
+            set_prop_tab_bar (TAB_BAR_ITEM_ENABLED_P, value);
+        }
+      else if (EQ (ikey, 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 (ikey, QChelp))
+        /* `:help HELP-STRING'.  */
+        set_prop_tab_bar (TAB_BAR_ITEM_HELP, value);
+      else if (EQ (ikey, QCfilter))
+        /* ':filter FORM'.  */
+        filter = value;
+      else if (EQ (ikey, QCbutton) && CONSP (value))
+        {
+          /* `:button (TYPE . SELECTED)'.  */
+          Lisp_Object type, selected;
+
+          type = XCAR (value);
+          selected = XCDR (value);
+          if (EQ (type, QCtoggle) || EQ (type, QCradio))
+            {
+              set_prop_tab_bar (TAB_BAR_ITEM_SELECTED_P, selected);
+            }
+        }
+    }
+
+  /* If got a filter apply it on binding.  */
+  if (!NILP (filter))
+    set_prop_tab_bar (TAB_BAR_ITEM_BINDING,
+              (menu_item_eval_property
+               (list2 (filter,
+                       list2 (Qquote,
+                              PROP (TAB_BAR_ITEM_BINDING))))));
+
+  /* See if the binding is a keymap.  Give up if it is.  */
+  if (CONSP (get_keymap (PROP (TAB_BAR_ITEM_BINDING), 0, 1)))
+    return 0;
+
+  /* Enable or disable selection of item.  */
+  if (!EQ (PROP (TAB_BAR_ITEM_ENABLED_P), Qt))
+    set_prop_tab_bar (TAB_BAR_ITEM_ENABLED_P,
+              menu_item_eval_property (PROP (TAB_BAR_ITEM_ENABLED_P)));
+
+  /* Handle radio buttons or toggle boxes.  */
+  if (!NILP (PROP (TAB_BAR_ITEM_SELECTED_P)))
+    set_prop_tab_bar (TAB_BAR_ITEM_SELECTED_P,
+              menu_item_eval_property (PROP (TAB_BAR_ITEM_SELECTED_P)));
+
+  return 1;
+
+#undef PROP
+}
+
+
+/* Initialize tab_bar_items_vector.  REUSE, if non-nil, is a vector
+   that can be reused.  */
+
+static void
+init_tab_bar_items (Lisp_Object reuse)
+{
+  if (VECTORP (reuse))
+    tab_bar_items_vector = reuse;
+  else
+    tab_bar_items_vector = make_nil_vector (64);
+  ntab_bar_items = 0;
+}
+
+
+/* Append parsed tab bar item properties from
+   tab_bar_item_properties */
+
+static void
+append_tab_bar_item (void)
+{
+  ptrdiff_t incr
+    = (ntab_bar_items
+       - (ASIZE (tab_bar_items_vector) - TAB_BAR_ITEM_NSLOTS));
+
+  /* Enlarge tab_bar_items_vector if necessary.  */
+  if (incr > 0)
+    tab_bar_items_vector = larger_vector (tab_bar_items_vector, incr, -1);
+
+  /* Append entries from tab_bar_item_properties to the end of
+     tab_bar_items_vector.  */
+  vcopy (tab_bar_items_vector, ntab_bar_items,
+         XVECTOR (tab_bar_item_properties)->contents, TAB_BAR_ITEM_NSLOTS);
+  ntab_bar_items += TAB_BAR_ITEM_NSLOTS;
+}
+
+
+
+
+
+/***********************************************************************
                                Tool-bars
  ***********************************************************************/
 
@@ -8402,6 +8803,7 @@ read_char_x_menu_prompt (Lisp_Object map,
      use a real menu for mouse selection.  */
   if (EVENT_HAS_PARAMETERS (prev_event)
       && !EQ (XCAR (prev_event), Qmenu_bar)
+      && !EQ (XCAR (prev_event), Qtab_bar)
       && !EQ (XCAR (prev_event), Qtool_bar))
     {
       /* Display the menu and get the selection.  */
@@ -9377,7 +9779,7 @@ read_key_sequence (Lisp_Object *keybuf, Lisp_Object prompt,
               posn = POSN_POSN (xevent_start (key));
               /* Handle menu-bar events:
                  insert the dummy prefix event `menu-bar'.  */
-              if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
+              if (EQ (posn, Qmenu_bar) || EQ (posn, Qtab_bar) || EQ (posn, Qtool_bar))
                 {
                   if (READ_KEY_ELTS - t <= 1)
                     error ("Key sequence too long");
@@ -10237,7 +10639,8 @@ On such systems, Emacs starts a subshell instead of suspending.  */)
   get_tty_size (fileno (CURTTY ()->input), &width, &height);
   if (width != old_width || height != old_height)
     change_frame_size (SELECTED_FRAME (), width,
-                       height - FRAME_MENU_BAR_LINES (SELECTED_FRAME ()),
+                       height - FRAME_MENU_BAR_LINES (SELECTED_FRAME ())
+                       - FRAME_TAB_BAR_LINES (SELECTED_FRAME ()),
                        0, 0, 0, 0);
 
   run_hook (intern ("suspend-resume-hook"));
@@ -11057,6 +11460,11 @@ syms_of_keyboard (void)
   staticpro (&item_properties);
   item_properties = Qnil;
 
+  staticpro (&tab_bar_item_properties);
+  tab_bar_item_properties = Qnil;
+  staticpro (&tab_bar_items_vector);
+  tab_bar_items_vector = Qnil;
+
   staticpro (&tool_bar_item_properties);
   tool_bar_item_properties = Qnil;
   staticpro (&tool_bar_items_vector);
@@ -11610,6 +12018,12 @@ See also `pre-command-hook'.  */);
 The elements of the list are event types that may have menu bar bindings.  */);
   Vmenu_bar_final_items = Qnil;
 
+  DEFVAR_LISP ("tab-bar-separator-image-expression", Vtab_bar_separator_image_expression,
+    doc: /* Expression evaluating to the image spec for a tab-bar separator.
+This is used internally by graphical displays that do not render
+tab-bar separators natively.  Otherwise it is unused (e.g. on GTK).  */);
+  Vtab_bar_separator_image_expression = Qnil;
+
   DEFVAR_LISP ("tool-bar-separator-image-expression", Vtool_bar_separator_image_expression,
     doc: /* Expression evaluating to the image spec for a tool-bar separator.
 This is used internally by graphical displays that do not render