;;; tab-bar.el --- frame-local tabs with named persistent window configurations -*- lexical-binding: t; -*- ;; Copyright (C) 2019-2021 Free Software Foundation, Inc. ;; Author: Juri Linkov ;; Keywords: frames tabs ;; Maintainer: emacs-devel@gnu.org ;; 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 3 of the License, 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. If not, see . ;;; Commentary: ;; Provides `tab-bar-mode' to control display of the tab bar and ;; bindings for the global tab bar. ;; The normal global binding for [tab-bar] (below) uses the value of ;; `tab-bar-map' as the actual keymap to define the tab bar. Modes ;; may either bind items under the [tab-bar] prefix key of the local ;; map to add to the global bar or may set `tab-bar-map' ;; buffer-locally to override it. ;;; Code: (eval-when-compile (require 'cl-lib) (require 'seq)) (defgroup tab-bar nil "Frame-local tabs." :group 'convenience :version "27.1") (defgroup tab-bar-faces '((tab-bar custom-face)) ; tab-bar is defined in faces.el "Faces used in the tab bar." :group 'tab-bar :group 'faces :version "27.1") (defface tab-bar-tab '((default :inherit tab-bar) (((class color) (min-colors 88)) :box (:line-width 1 :style released-button)) (t :inverse-video nil)) "Tab bar face for selected tab." :version "27.1" :group 'tab-bar-faces) (defface tab-bar-tab-inactive '((default :inherit tab-bar-tab) (((class color) (min-colors 88)) :background "grey75") (t :inverse-video t)) "Tab bar face for non-selected tab." :version "27.1" :group 'tab-bar-faces) (defcustom tab-bar-select-tab-modifiers '() "List of modifier keys for selecting a tab by its index digit. Possible modifier keys are `control', `meta', `shift', `hyper', `super' and `alt'. To help you to select a tab by its number, you can customize `tab-bar-tab-hints' that will show tab numbers alongside the tab name." :type '(set :tag "Tab selection modifier keys" (const control) (const meta) (const shift) (const hyper) (const super) (const alt)) :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) ;; Reenable the tab-bar with new keybindings (when tab-bar-mode (tab-bar--undefine-keys) (tab-bar--define-keys))) :group 'tab-bar :version "27.1") (defun tab-bar--define-keys () "Install key bindings for switching between tabs if the user has configured them." (when tab-bar-select-tab-modifiers (global-set-key (vector (append tab-bar-select-tab-modifiers (list ?0))) 'tab-recent) (dotimes (i 8) (global-set-key (vector (append tab-bar-select-tab-modifiers (list (+ i 1 ?0)))) 'tab-bar-select-tab)) (global-set-key (vector (append tab-bar-select-tab-modifiers (list ?9))) 'tab-last)) ;; Don't override user customized key bindings (unless (global-key-binding [(control tab)]) (global-set-key [(control tab)] 'tab-next)) (unless (global-key-binding [(control shift tab)]) (global-set-key [(control shift tab)] 'tab-previous)) (unless (global-key-binding [(control shift iso-lefttab)]) (global-set-key [(control shift iso-lefttab)] 'tab-previous)) ;; Replace default value with a condition that supports displaying ;; global-mode-string in the tab bar instead of the mode line. (when (and (memq 'tab-bar-format-global tab-bar-format) (member '(global-mode-string ("" global-mode-string " ")) mode-line-misc-info)) (setq mode-line-misc-info (append '(global-mode-string ("" (:eval (if (and tab-bar-mode (memq 'tab-bar-format-global tab-bar-format)) "" global-mode-string)) " ")) (remove '(global-mode-string ("" global-mode-string " ")) mode-line-misc-info))))) (defun tab-bar--undefine-keys () "Uninstall key bindings previously bound by `tab-bar--define-keys'." (when (eq (global-key-binding [(control tab)]) 'tab-next) (global-unset-key [(control tab)])) (when (eq (global-key-binding [(control shift tab)]) 'tab-previous) (global-unset-key [(control shift tab)])) (when (eq (global-key-binding [(control shift iso-lefttab)]) 'tab-previous) (global-unset-key [(control shift iso-lefttab)]))) (defun tab-bar--load-buttons () "Load the icons for the tab buttons." (when (and tab-bar-new-button (not (get-text-property 0 'display tab-bar-new-button))) ;; This file is pre-loaded so only here we can use the right data-directory: (add-text-properties 0 (length tab-bar-new-button) `(display (image :type xpm :file "tabs/new.xpm" :margin (2 . 0) :ascent center)) tab-bar-new-button)) (when (and tab-bar-close-button (not (get-text-property 0 'display tab-bar-close-button))) ;; This file is pre-loaded so only here we can use the right data-directory: (add-text-properties 0 (length tab-bar-close-button) `(display (image :type xpm :file "tabs/close.xpm" :margin (2 . 0) :ascent center)) tab-bar-close-button))) (defun tab-bar--tab-bar-lines-for-frame (frame) "Determine and return the value of `tab-bar-lines' for FRAME. Return 0 if `tab-bar-mode' is not enabled. Otherwise return either 1 or 0 depending on the value of the customizable variable `tab-bar-show', which see." (cond ((not tab-bar-mode) 0) ((not tab-bar-show) 0) ((eq tab-bar-show t) 1) ((natnump tab-bar-show) (if (> (length (funcall tab-bar-tabs-function frame)) tab-bar-show) 1 0)))) (defun tab-bar--update-tab-bar-lines (&optional frames) "Update the `tab-bar-lines' frame parameter in FRAMES. If the optional parameter FRAMES is omitted, update only the currently selected frame. If it is `t', update all frames as well as the default for new frames. Otherwise FRAMES should be a list of frames to update." (let ((frame-lst (cond ((null frames) (list (selected-frame))) ((eq frames t) (frame-list)) (t frames)))) ;; Loop over all frames and update `tab-bar-lines' (dolist (frame frame-lst) (unless (frame-parameter frame 'tab-bar-lines-keep-state) (set-frame-parameter frame 'tab-bar-lines (tab-bar--tab-bar-lines-for-frame frame))))) ;; Update `default-frame-alist' (when (eq frames t) (setq default-frame-alist (cons (cons 'tab-bar-lines (if (and tab-bar-mode (eq tab-bar-show t)) 1 0)) (assq-delete-all 'tab-bar-lines default-frame-alist))))) (define-minor-mode tab-bar-mode "Toggle the tab bar in all graphical frames (Tab Bar mode)." :global t ;; It's defined in C/cus-start, this stops the d-m-m macro defining it again. :variable tab-bar-mode ;; Recalculate `tab-bar-lines' for all frames (tab-bar--update-tab-bar-lines t) (when tab-bar-mode (tab-bar--load-buttons)) (if tab-bar-mode (tab-bar--define-keys) (tab-bar--undefine-keys))) (defun tab-bar-handle-mouse (event) "Text-mode emulation of switching tabs on the tab bar. This command is used when you click the mouse in the tab bar on a console which has no window system but does have a mouse." (interactive "e") (let* ((x-position (car (posn-x-y (event-start event)))) (keymap (lookup-key (cons 'keymap (nreverse (current-active-maps))) [tab-bar])) (column 0)) (when x-position (unless (catch 'done (map-keymap (lambda (key binding) (when (eq (car-safe binding) 'menu-item) (when (> (+ column (length (nth 1 binding))) x-position) (if (get-text-property (- x-position column) 'close-tab (nth 1 binding)) (let* ((close-key (vector (intern (format "C-%s" key)))) (close-def (lookup-key keymap close-key))) (when close-def (call-interactively close-def))) (call-interactively (nth 2 binding))) (throw 'done t)) (setq column (+ column (length (nth 1 binding)))))) keymap)) ;; Clicking anywhere outside existing tabs will add a new tab (tab-bar-new-tab))))) (defun toggle-tab-bar-mode-from-frame (&optional arg) "Toggle tab bar on or off, based on the status of the current frame. Used in the Show/Hide menu, to have the toggle reflect the current frame. See `tab-bar-mode' for more information." (interactive (list (or current-prefix-arg 'toggle))) (if (eq arg 'toggle) (tab-bar-mode (if (> (frame-parameter nil 'tab-bar-lines) 0) 0 1)) (tab-bar-mode arg))) (defun toggle-frame-tab-bar (&optional frame) "Toggle tab bar of FRAME. This is useful when you want to enable the tab bar individually on each new frame when the global `tab-bar-mode' is disabled, or when you want to disable the tab bar individually on each new frame when the global `tab-bar-mode' is enabled, by using (add-hook 'after-make-frame-functions 'toggle-frame-tab-bar)" (interactive) (set-frame-parameter frame 'tab-bar-lines (if (> (frame-parameter frame 'tab-bar-lines) 0) 0 1)) (set-frame-parameter frame 'tab-bar-lines-keep-state (not (frame-parameter frame 'tab-bar-lines-keep-state)))) (defvar tab-bar-map (make-sparse-keymap) "Keymap for the tab bar. Define this locally to override the global tab bar.") (global-set-key [tab-bar] `(menu-item ,(purecopy "tab bar") ignore :filter tab-bar-make-keymap)) (defconst tab-bar-keymap-cache (make-hash-table :weakness t :test 'equal)) (defun tab-bar-make-keymap (&optional _ignore) "Generate an actual keymap from `tab-bar-map'. Its main job is to show tabs in the tab bar." (if (= 1 (length tab-bar-map)) (tab-bar-make-keymap-1) (let ((key (cons (frame-terminal) tab-bar-map))) (or (gethash key tab-bar-keymap-cache) (puthash key tab-bar-map tab-bar-keymap-cache))))) (defcustom tab-bar-show t "Defines when to show the tab bar. If t, enable `tab-bar-mode' automatically on using the commands that create new window configurations (e.g. `tab-new'). If the value is `1', then hide the tab bar when it has only one tab, and show it again once more tabs are created. If nil, always keep the tab bar hidden. In this case it's still possible to use persistent named window configurations by relying on keyboard commands `tab-new', `tab-close', `tab-next', `tab-switcher', etc. Setting this variable directly does not take effect; please customize it (see the info node `Easy Customization'), then it will automatically update the tab bar on all frames according to the new value. To enable or disable the tab bar individually on each frame, you can use the command `toggle-frame-tab-bar'." :type '(choice (const :tag "Always" t) (const :tag "When more than one tab" 1) (const :tag "Never" nil)) :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (if val (tab-bar-mode 1) (tab-bar--update-tab-bar-lines t))) :group 'tab-bar :version "27.1") (defcustom tab-bar-new-tab-choice t "Defines what to show in a new tab. If t, start a new tab with the current buffer, i.e. the buffer that was current before calling the command that adds a new tab (this is the same what `make-frame' does by default). If the value is a string, use it as a buffer name to switch to if such buffer exists, or switch to a buffer visiting the file or directory that the string specifies. If the value is a function, call it with no arguments and switch to the buffer that it returns. If nil, duplicate the contents of the tab that was active before calling the command that adds a new tab." :type '(choice (const :tag "Current buffer" t) (string :tag "Buffer" "*scratch*") (directory :tag "Directory" :value "~/") (file :tag "File" :value "~/.emacs") (function :tag "Function") (const :tag "Duplicate tab" nil)) :group 'tab-bar :version "27.1") (defcustom tab-bar-new-button-show t "If non-nil, show the \"New tab\" button in the tab bar. When this is nil, you can create new tabs with \\[tab-new]." :type 'boolean :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (force-mode-line-update)) :group 'tab-bar :version "27.1") (defvar tab-bar-new-button " + " "Button for creating a new tab.") (defcustom tab-bar-close-button-show t "Defines where to show the close tab button. If t, show the close tab button on all tabs. If `selected', show it only on the selected tab. If `non-selected', show it only on non-selected tab. If nil, don't show it at all." :type '(choice (const :tag "On all tabs" t) (const :tag "On selected tab" selected) (const :tag "On non-selected tabs" non-selected) (const :tag "None" nil)) :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (force-mode-line-update)) :group 'tab-bar :version "27.1") (defvar tab-bar-close-button (propertize " x" 'close-tab t :help "Click to close tab") "Button for closing the clicked tab.") (defvar tab-bar-back-button " < " "Button for going back in tab history.") (defvar tab-bar-forward-button " > " "Button for going forward in tab history.") (defcustom tab-bar-history-buttons-show t "Show back and forward buttons when `tab-bar-history-mode' is enabled." :type 'boolean :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (force-mode-line-update)) :group 'tab-bar :version "28.1") (defcustom tab-bar-tab-hints nil "Show absolute numbers on tabs in the tab bar before the tab name. This helps to select the tab by its number using `tab-bar-select-tab' and `tab-bar-select-tab-modifiers'." :type 'boolean :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (force-mode-line-update)) :group 'tab-bar :version "27.1") (defvar tab-bar-separator nil "String that delimits tabs.") (defun tab-bar-separator () (or tab-bar-separator (if window-system " " "|"))) (defcustom tab-bar-tab-name-function #'tab-bar-tab-name-current "Function to get a tab name. Function gets no arguments. The choice is between displaying only the name of the current buffer in the tab name (default), or displaying the names of all buffers from all windows in the window configuration." :type '(choice (const :tag "Selected window buffer" tab-bar-tab-name-current) (const :tag "Selected window buffer with window count" tab-bar-tab-name-current-with-count) (const :tag "Truncated buffer name" tab-bar-tab-name-truncated) (const :tag "All window buffers" tab-bar-tab-name-all) (function :tag "Function")) :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (force-mode-line-update)) :group 'tab-bar :version "27.1") (defun tab-bar-tab-name-current () "Generate tab name from the buffer of the selected window." (buffer-name (window-buffer (minibuffer-selected-window)))) (defun tab-bar-tab-name-current-with-count () "Generate tab name from the buffer of the selected window. Also add the number of windows in the window configuration." (let ((count (length (window-list-1 nil 'nomini))) (name (window-buffer (minibuffer-selected-window)))) (if (> count 1) (format "%s (%d)" name count) (format "%s" name)))) (defun tab-bar-tab-name-all () "Generate tab name from buffers of all windows." (mapconcat #'buffer-name (delete-dups (mapcar #'window-buffer (window-list-1 (frame-first-window) 'nomini))) ", ")) (defcustom tab-bar-tab-name-truncated-max 20 "Maximum length of the tab name from the current buffer. Effective when `tab-bar-tab-name-function' is customized to `tab-bar-tab-name-truncated'." :type 'integer :group 'tab-bar :version "27.1") (defvar tab-bar-tab-name-ellipsis t) (defun tab-bar-tab-name-truncated () "Generate tab name from the buffer of the selected window. Truncate it to the length specified by `tab-bar-tab-name-truncated-max'. Append ellipsis `tab-bar-tab-name-ellipsis' in this case." (let ((tab-name (buffer-name (window-buffer (minibuffer-selected-window))))) (if (< (length tab-name) tab-bar-tab-name-truncated-max) tab-name (propertize (truncate-string-to-width tab-name tab-bar-tab-name-truncated-max nil nil tab-bar-tab-name-ellipsis) 'help-echo tab-name)))) (defvar tab-bar-tabs-function #'tab-bar-tabs "Function to get a list of tabs to display in the tab bar. This function should have one optional argument FRAME, defaulting to the selected frame when nil. It should return a list of alists with parameters that include at least the element (name . TAB-NAME). For example, \\='((tab (name . \"Tab 1\")) (current-tab (name . \"Tab 2\"))) By default, use function `tab-bar-tabs'.") (defun tab-bar-tabs (&optional frame) "Return a list of tabs belonging to the selected frame. Ensure the frame parameter `tabs' is pre-populated. Update the current tab name when it exists. Return its existing value or a new value." (let ((tabs (frame-parameter frame 'tabs))) (if tabs (let* ((current-tab (assq 'current-tab tabs)) (current-tab-name (assq 'name current-tab)) (current-tab-explicit-name (assq 'explicit-name current-tab))) (when (and current-tab-name current-tab-explicit-name (not (cdr current-tab-explicit-name))) (setf (cdr current-tab-name) (funcall tab-bar-tab-name-function)))) ;; Create default tabs (setq tabs (list (tab-bar--current-tab))) (set-frame-parameter frame 'tabs tabs)) tabs)) (defcustom tab-bar-tab-name-format-function #'tab-bar-tab-name-format-default "Function to format a tab name. Function gets two arguments, the tab and its number, and should return the formatted tab name to display in the tab bar." :type 'function :initialize 'custom-initialize-default :set (lambda (sym val) (set-default sym val) (force-mode-line-update)) :group 'tab-bar :version "28.1") (defun tab-bar-tab-name-format-default (tab i) (let ((current-p (eq (car tab) 'current-tab))) (propertize (concat (if tab-bar-tab-hints (format "%d " i) "") (alist-get 'name tab) (or (and tab-bar-close-button-show (not (eq tab-bar-close-button-show (if current-p 'non-selected 'selected))) tab-bar-close-button) "")) 'face (if current-p 'tab-bar-tab 'tab-bar-tab-inactive)))) (defvar tab-bar-format '(tab-bar-format-history tab-bar-format-tabs tab-bar-separator tab-bar-format-add-tab) "Template for displaying tab bar items. Every item in the list is a function that returns a string, or a list of menu-item elements, or nil. When you add more items `tab-bar-format-align-right' and `tab-bar-format-global' to the end, then after enabling `display-time-mode' (or any other mode that uses `global-mode-string') it will display time aligned to the right on the tab bar instead of the mode line.") (defun tab-bar-format-history () (when (and tab-bar-history-mode tab-bar-history-buttons-show) `((sep-history-back menu-item ,(tab-bar-separator) ignore) (history-back menu-item ,tab-bar-back-button tab-bar-history-back :help "Click to go back in tab history") (sep-history-forward menu-item ,(tab-bar-separator) ignore) (history-forward menu-item ,tab-bar-forward-button tab-bar-history-forward :help "Click to go forward in tab history")))) (defun tab-bar-format-tabs () (let ((separator (tab-bar-separator)) (tabs (funcall tab-bar-tabs-function)) (i 0)) (mapcan (lambda (tab) (setq i (1+ i)) (append `((,(intern (format "sep-%i" i)) menu-item ,separator ignore)) (cond ((eq (car tab) 'current-tab) `((current-tab menu-item ,(funcall tab-bar-tab-name-format-function tab i) ignore :help "Current tab"))) (t `((,(intern (format "tab-%i" i)) menu-item ,(funcall tab-bar-tab-name-format-function tab i) ,(or (alist-get 'binding tab) `(lambda () (interactive) (tab-bar-select-tab ,i))) :help "Click to visit tab")))) `((,(if (eq (car tab) 'current-tab) 'C-current-tab (intern (format "C-tab-%i" i))) menu-item "" ,(or (alist-get 'close-binding tab) `(lambda () (interactive) (tab-bar-close-tab ,i))))))) tabs))) (defun tab-bar-format-add-tab () (when (and tab-bar-new-button-show tab-bar-new-button) `((add-tab menu-item ,tab-bar-new-button tab-bar-new-tab :help "New tab")))) (defun tab-bar-format-align-right () "Align the rest of tab bar items to the right." (let* ((rest (cdr (memq 'tab-bar-format-align-right tab-bar-format))) (rest (tab-bar-format-list rest)) (rest (mapconcat (lambda (item) (nth 2 item)) rest "")) (hpos (length rest)) (str (propertize " " 'display `(space :align-to (- right ,hpos))))) `((tab-bar-format-align-right menu-item ,str ignore)))) (defun tab-bar-format-global () "Format `global-mode-string' to display it in the tab bar. When `tab-bar-format-global' is added to `tab-bar-format' (possibly appended after `tab-bar-format-align-right'), then modes that display information on the mode line using `global-mode-string' will display the same text on the tab bar instead." `((tab-bar-format-global menu-item ,(format-mode-line global-mode-string) ignore))) (defun tab-bar-format-list (format-list) (let ((i 0)) (apply #'append (mapcar (lambda (format) (setq i (1+ i)) (cond ((functionp format) (let ((ret (funcall format))) (when (stringp ret) (setq ret `((,(intern (format "str-%i" i)) menu-item ,ret ignore)))) ret)))) format-list)))) (defun tab-bar-make-keymap-1 () "Generate an actual keymap from `tab-bar-map', without caching." (append '(keymap (mouse-1 . tab-bar-handle-mouse)) (tab-bar-format-list tab-bar-format))) ;; Some window-configuration parameters don't need to be persistent. ;; Don't save to the desktop file such tab parameters that are saved ;; as "Unprintable entity" so can't be used after restoring the desktop. ;; Actually tab-bar-select-tab already can handle unprintable entities, ;; but it's better not to waste the desktop file with useless data. (defun frameset-filter-tabs (current _filtered _parameters saving) (if saving (mapcar (lambda (current) (if (consp current) (seq-reduce (lambda (current param) (assq-delete-all param current)) '(wc wc-point wc-bl wc-bbl wc-history-back wc-history-forward) (copy-sequence current)) current)) current) current)) (push '(tabs . frameset-filter-tabs) frameset-filter-alist) (defun tab-bar--tab (&optional frame) (let* ((tab (assq 'current-tab (frame-parameter frame 'tabs))) (tab-explicit-name (alist-get 'explicit-name tab)) (tab-group (alist-get 'group tab)) (bl (seq-filter #'buffer-live-p (frame-parameter frame 'buffer-list))) (bbl (seq-filter #'buffer-live-p (frame-parameter frame 'buried-buffer-list)))) `(tab (name . ,(if tab-explicit-name (alist-get 'name tab) (funcall tab-bar-tab-name-function))) (explicit-name . ,tab-explicit-name) ,@(if tab-group `((group . ,tab-group))) (time . ,(float-time)) (ws . ,(window-state-get (frame-root-window (or frame (selected-frame))) 'writable)) (wc . ,(current-window-configuration)) (wc-point . ,(point-marker)) (wc-bl . ,bl) (wc-bbl . ,bbl) (wc-history-back . ,(gethash (or frame (selected-frame)) tab-bar-history-back)) (wc-history-forward . ,(gethash (or frame (selected-frame)) tab-bar-history-forward))))) (defun tab-bar--current-tab (&optional tab frame) ;; `tab' here is an argument meaning "use tab as template". This is ;; necessary when switching tabs, otherwise the destination tab ;; inherits the current tab's `explicit-name' parameter. (let* ((tab (or tab (assq 'current-tab (frame-parameter frame 'tabs)))) (tab-explicit-name (alist-get 'explicit-name tab)) (tab-group (alist-get 'group tab))) `(current-tab (name . ,(if tab-explicit-name (alist-get 'name tab) (funcall tab-bar-tab-name-function))) (explicit-name . ,tab-explicit-name) ,@(if tab-group `((group . ,tab-group)))))) (defun tab-bar--current-tab-find (&optional tabs frame) (seq-find (lambda (tab) (eq (car tab) 'current-tab)) (or tabs (funcall tab-bar-tabs-function frame)))) (defun tab-bar--current-tab-index (&optional tabs frame) (seq-position (or tabs (funcall tab-bar-tabs-function frame)) 'current-tab (lambda (a b) (eq (car a) b)))) (defun tab-bar--tab-index (tab &optional tabs frame) (seq-position (or tabs (funcall tab-bar-tabs-function frame)) tab #'eq)) (defun tab-bar--tab-index-by-name (name &optional tabs frame) (seq-position (or tabs (funcall tab-bar-tabs-function frame)) name (lambda (a b) (equal (alist-get 'name a) b)))) (defun tab-bar--tab-index-recent (nth &optional tabs frame) (let* ((tabs (or tabs (funcall tab-bar-tabs-function frame))) (sorted-tabs (tab-bar--tabs-recent tabs frame)) (tab (nth (1- nth) sorted-tabs))) (tab-bar--tab-index tab tabs))) (defun tab-bar--tabs-recent (&optional tabs frame) (let* ((tabs (or tabs (funcall tab-bar-tabs-function frame)))) (seq-sort-by (lambda (tab) (alist-get 'time tab)) #'> (seq-remove (lambda (tab) (eq (car tab) 'current-tab)) tabs)))) (defun tab-bar-select-tab (&optional arg) "Switch to the tab by its absolute position ARG in the tab bar. When this command is bound to a numeric key (with a prefix or modifier key using `tab-bar-select-tab-modifiers'), calling it without an argument will translate its bound numeric key to the numeric argument. ARG counts from 1." (interactive "P") (unless (integerp arg) (let ((key (event-basic-type last-command-event))) (setq arg (if (and (characterp key) (>= key ?1) (<= key ?9)) (- key ?0) 1)))) (let* ((tabs (funcall tab-bar-tabs-function)) (from-index (tab-bar--current-tab-index tabs)) (to-index (1- (max 1 (min arg (length tabs)))))) (unless (eq from-index to-index) (let* ((from-tab (tab-bar--tab)) (to-tab (nth to-index tabs)) (wc (alist-get 'wc to-tab)) (ws (alist-get 'ws to-tab))) ;; During the same session, use window-configuration to switch ;; tabs, because window-configurations are more reliable ;; (they keep references to live buffers) than window-states. ;; But after restoring tabs from a previously saved session, ;; its value of window-configuration is unreadable, ;; so restore its saved window-state. (cond ((window-configuration-p wc) (let ((wc-point (alist-get 'wc-point to-tab)) (wc-bl (seq-filter #'buffer-live-p (alist-get 'wc-bl to-tab))) (wc-bbl (seq-filter #'buffer-live-p (alist-get 'wc-bbl to-tab))) (wc-history-back (alist-get 'wc-history-back to-tab)) (wc-history-forward (alist-get 'wc-history-forward to-tab))) (set-window-configuration wc) ;; set-window-configuration does not restore the value of ;; point in the current buffer, so restore it separately. (when (and (markerp wc-point) (marker-buffer wc-point) ;; FIXME: After dired-revert, marker relocates to 1. ;; window-configuration restores point to global point ;; in this dired buffer, not to its window point, ;; but this is slightly better than 1. ;; Maybe better to save dired-filename in each window? (not (eq 1 (marker-position wc-point)))) (goto-char wc-point)) (when wc-bl (set-frame-parameter nil 'buffer-list wc-bl)) (when wc-bbl (set-frame-parameter nil 'buried-buffer-list wc-bbl)) (puthash (selected-frame) (and (window-configuration-p (alist-get 'wc (car wc-history-back))) wc-history-back) tab-bar-history-back) (puthash (selected-frame) (and (window-configuration-p (alist-get 'wc (car wc-history-forward))) wc-history-forward) tab-bar-history-forward))) (ws (window-state-put ws nil 'safe))) (setq tab-bar-history-omit t) (when from-index (setf (nth from-index tabs) from-tab)) (setf (nth to-index tabs) (tab-bar--current-tab (nth to-index tabs))) (unless tab-bar-mode (message "Selected tab '%s'" (alist-get 'name to-tab)))) (force-mode-line-update)))) (defun tab-bar-switch-to-next-tab (&optional arg) "Switch to ARGth next tab." (interactive "p") (unless (integerp arg) (setq arg 1)) (let* ((tabs (funcall tab-bar-tabs-function)) (from-index (or (tab-bar--current-tab-index tabs) 0)) (to-index (mod (+ from-index arg) (length tabs)))) (tab-bar-select-tab (1+ to-index)))) (defun tab-bar-switch-to-prev-tab (&optional arg) "Switch to ARGth previous tab." (interactive "p") (unless (integerp arg) (setq arg 1)) (tab-bar-switch-to-next-tab (- arg))) (defun tab-bar-switch-to-last-tab (&optional arg) "Switch to the last tab or ARGth tab from the end of the tab bar." (interactive "p") (tab-bar-select-tab (- (length (funcall tab-bar-tabs-function)) (1- (or arg 1))))) (defun tab-bar-switch-to-recent-tab (&optional arg) "Switch to ARGth most recently visited tab." (interactive "p") (unless (integerp arg) (setq arg 1)) (let ((tab-index (tab-bar--tab-index-recent arg))) (if tab-index (tab-bar-select-tab (1+ tab-index)) (message "No more recent tabs")))) (defun tab-bar-switch-to-tab (name) "Switch to the tab by NAME. Default values are tab names sorted by recency, so you can use \ \\\\[next-history-element] to get the name of the most recently visited tab, the second most recent, and so on." (interactive (let* ((recent-tabs (mapcar (lambda (tab) (alist-get 'name tab)) (tab-bar--tabs-recent)))) (list (completing-read (format-prompt "Switch to tab by name" (car recent-tabs)) recent-tabs nil nil nil nil recent-tabs)))) (tab-bar-select-tab (1+ (or (tab-bar--tab-index-by-name name) 0)))) (defalias 'tab-bar-select-tab-by-name 'tab-bar-switch-to-tab) (defun tab-bar-move-tab-to (to-index &optional from-index) "Move tab from FROM-INDEX position to new position at TO-INDEX. FROM-INDEX defaults to the current tab index. FROM-INDEX and TO-INDEX count from 1. Negative TO-INDEX counts tabs from the end of the tab bar. Argument addressing is absolute in contrast to `tab-bar-move-tab' where argument addressing is relative." (interactive "P") (let* ((tabs (funcall tab-bar-tabs-function)) (from-index (or from-index (1+ (tab-bar--current-tab-index tabs)))) (from-tab (nth (1- from-index) tabs)) (to-index (if to-index (prefix-numeric-value to-index) 1)) (to-index (if (< to-index 0) (+ (length tabs) (1+ to-index)) to-index)) (to-index (max 0 (min (1- to-index) (1- (length tabs)))))) (setq tabs (delq from-tab tabs)) (cl-pushnew from-tab (nthcdr to-index tabs)) (set-frame-parameter nil 'tabs tabs) (force-mode-line-update))) (defun tab-bar-move-tab (&optional arg) "Move the current tab ARG positions to the right. If a negative ARG, move the current tab ARG positions to the left. Argument addressing is relative in contrast to `tab-bar-move-tab-to' where argument addressing is absolute." (interactive "p") (let* ((tabs (funcall tab-bar-tabs-function)) (from-index (or (tab-bar--current-tab-index tabs) 0)) (to-index (mod (+ from-index arg) (length tabs)))) (tab-bar-move-tab-to (1+ to-index) (1+ from-index)))) (defun tab-bar-move-tab-to-frame (arg &optional from-frame from-index to-frame to-index) "Move tab from FROM-INDEX position to new position at TO-INDEX. FROM-INDEX defaults to the current tab index. FROM-INDEX and TO-INDEX count from 1. FROM-FRAME specifies the source frame and defaults to the selected frame. TO-FRAME specifies the target frame and defaults the next frame. Interactively, ARG selects the ARGth different frame to move to." (interactive "P") (unless from-frame (setq from-frame (selected-frame))) (unless to-frame (dotimes (_ (prefix-numeric-value arg)) (setq to-frame (next-frame to-frame)))) (unless (eq from-frame to-frame) (let* ((from-tabs (funcall tab-bar-tabs-function from-frame)) (from-index (or from-index (1+ (tab-bar--current-tab-index from-tabs)))) (from-tab (nth (1- from-index) from-tabs)) (to-tabs (funcall tab-bar-tabs-function to-frame)) (to-index (max 0 (min (1- (or to-index 1)) (1- (length to-tabs)))))) (cl-pushnew (assq-delete-all 'wc (if (eq (car from-tab) 'current-tab) (tab-bar--tab from-frame) from-tab)) (nthcdr to-index to-tabs)) (with-selected-frame from-frame (let ((inhibit-message t) ; avoid message about deleted tab tab-bar-closed-tabs) (tab-bar-close-tab from-index))) (set-frame-parameter to-frame 'tabs to-tabs) (force-mode-line-update t)))) (defcustom tab-bar-new-tab-to 'right "Defines where to create a new tab. If `leftmost', create as the first tab. If `left', create to the left from the current tab. If `right', create to the right from the current tab. If `rightmost', create as the last tab. If the value is a function, it should return a number as a position on the tab bar specifying where to insert a new tab." :type '(choice (const :tag "First tab" leftmost) (const :tag "To the left" left) (const :tag "To the right" right) (const :tag "Last tab" rightmost) (function :tag "Function")) :group 'tab-bar :version "27.1") (defcustom tab-bar-tab-post-open-functions nil "List of functions to call after creating a new tab. The current tab is supplied as an argument. Any modifications made to the tab argument will be applied after all functions are called." :type '(repeat function) :group 'tab-bar :version "27.1") (defun tab-bar-new-tab-to (&optional to-index) "Add a new tab at the absolute position TO-INDEX. TO-INDEX counts from 1. If no TO-INDEX is specified, then add a new tab at the position specified by `tab-bar-new-tab-to'. Negative TO-INDEX counts tabs from the end of the tab bar. Argument addressing is absolute in contrast to `tab-bar-new-tab' where argument addressing is relative. After the tab is created, the hooks in `tab-bar-tab-post-open-functions' are run." (interactive "P") (let* ((tabs (funcall tab-bar-tabs-function)) (from-index (tab-bar--current-tab-index tabs)) (from-tab (tab-bar--tab))) (when tab-bar-new-tab-choice ;; Handle the case when it's called in the active minibuffer. (when (minibuffer-selected-window) (select-window (minibuffer-selected-window))) (delete-other-windows) ;; Create a new window to get rid of old window parameters ;; (e.g. prev/next buffers) of old window. (split-window) (delete-window) (let ((buffer (if (functionp tab-bar-new-tab-choice) (funcall tab-bar-new-tab-choice) (if (stringp tab-bar-new-tab-choice) (or (get-buffer tab-bar-new-tab-choice) (find-file-noselect tab-bar-new-tab-choice)))))) (when (buffer-live-p buffer) (switch-to-buffer buffer)))) (when from-index (setf (nth from-index tabs) from-tab)) (let* ((to-tab (tab-bar--current-tab)) (to-index (and to-index (prefix-numeric-value to-index))) (to-index (or (if to-index (if (< to-index 0) (+ (length tabs) (1+ to-index)) (1- to-index))) (pcase tab-bar-new-tab-to ('leftmost 0) ('rightmost (length tabs)) ('left (or from-index 1)) ('right (1+ (or from-index 0))) ((pred functionp) (funcall tab-bar-new-tab-to)))))) (setq to-index (max 0 (min (or to-index 0) (length tabs)))) (cl-pushnew to-tab (nthcdr to-index tabs)) (when (eq to-index 0) ;; `pushnew' handles the head of tabs but not frame-parameter (set-frame-parameter nil 'tabs tabs)) (run-hook-with-args 'tab-bar-tab-post-open-functions (nth to-index tabs))) (when tab-bar-show (if (not tab-bar-mode) ;; Turn on `tab-bar-mode' since a tab was created. ;; Note: this also updates `tab-bar-lines'. (tab-bar-mode 1) (tab-bar--update-tab-bar-lines))) (force-mode-line-update) (unless tab-bar-mode (message "Added new tab at %s" tab-bar-new-tab-to)))) (defun tab-bar-new-tab (&optional arg) "Create a new tab ARG positions to the right. If a negative ARG, create a new tab ARG positions to the left. If ARG is zero, create a new tab in place of the current tab. If no ARG is specified, then add a new tab at the position specified by `tab-bar-new-tab-to'. Argument addressing is relative in contrast to `tab-bar-new-tab-to' where argument addressing is absolute." (interactive "P") (if arg (let* ((tabs (funcall tab-bar-tabs-function)) (from-index (or (tab-bar--current-tab-index tabs) 0)) (to-index (+ from-index (prefix-numeric-value arg)))) (tab-bar-new-tab-to (1+ to-index))) (tab-bar-new-tab-to))) (defun tab-bar-duplicate-tab (&optional arg) "Duplicate the current tab to ARG positions to the right. If a negative ARG, duplicate the tab to ARG positions to the left. If ARG is zero, duplicate the tab in place of the current tab." (interactive "P") (let ((tab-bar-new-tab-choice nil)) (tab-bar-new-tab arg))) (defvar tab-bar-closed-tabs nil "A list of closed tabs to be able to undo their closing.") (defcustom tab-bar-close-tab-select 'recent "Defines what tab to select after closing the specified tab. If `left', select the adjacent left tab. If `right', select the adjacent right tab. If `recent', select the most recently visited tab." :type '(choice (const :tag "Select left tab" left) (const :tag "Select right tab" right) (const :tag "Select recent tab" recent)) :group 'tab-bar :version "27.1") (defcustom tab-bar-close-last-tab-choice nil "Defines what to do when the last tab is closed. If nil, do nothing and show a message, like closing the last window or frame. If `delete-frame', delete the containing frame, as a web browser would do. If `tab-bar-mode-disable', disable tab-bar-mode so that tabs no longer show in the frame. If the value is a function, call that function with the tab to be closed as an argument." :type '(choice (const :tag "Do nothing and show message" nil) (const :tag "Close the containing frame" delete-frame) (const :tag "Disable tab-bar-mode" tab-bar-mode-disable) (function :tag "Function")) :group 'tab-bar :version "27.1") (defcustom tab-bar-tab-prevent-close-functions nil "List of functions to call to determine whether to close a tab. The tab to be closed and a boolean indicating whether or not it is the only tab in the frame are supplied as arguments. If any function returns a non-nil value, the tab will not be closed." :type '(repeat function) :group 'tab-bar :version "27.1") (defcustom tab-bar-tab-pre-close-functions nil "List of functions to call before closing a tab. The tab to be closed and a boolean indicating whether or not it is the only tab in the frame are supplied as arguments, respectively." :type '(repeat function) :group 'tab-bar :version "27.1") (defun tab-bar-close-tab (&optional arg to-index) "Close the tab specified by its absolute position ARG. If no ARG is specified, then close the current tab and switch to the tab specified by `tab-bar-close-tab-select'. ARG counts from 1. Optional TO-INDEX could be specified to override the value of `tab-bar-close-tab-select' programmatically with a position of an existing tab to select after closing the current tab. TO-INDEX counts from 1. The functions in `tab-bar-tab-prevent-close-functions' will be run to determine whether or not to close the tab. Just before the tab is closed, the functions in `tab-bar-tab-pre-close-functions' will be run. The base behavior for the last tab on a frame is determined by `tab-bar-close-last-tab-choice'." (interactive "P") (let* ((tabs (funcall tab-bar-tabs-function)) (current-index (tab-bar--current-tab-index tabs)) (close-index (if (integerp arg) (1- arg) current-index)) (last-tab-p (= 1 (length tabs))) (prevent-close (run-hook-with-args-until-success 'tab-bar-tab-prevent-close-functions (nth close-index tabs) last-tab-p))) (unless prevent-close (run-hook-with-args 'tab-bar-tab-pre-close-functions (nth close-index tabs) last-tab-p) (if last-tab-p (pcase tab-bar-close-last-tab-choice ('nil (user-error "Attempt to delete the sole tab in a frame")) ('delete-frame (delete-frame)) ('tab-bar-mode-disable (tab-bar-mode -1)) ((pred functionp) ;; Give the handler function the full extent of the tab's ;; data, not just it's name and explicit-name flag. (funcall tab-bar-close-last-tab-choice (tab-bar--tab)))) ;; More than one tab still open (when (eq current-index close-index) ;; Select another tab before deleting the current tab (let ((to-index (or (if to-index (1- to-index)) (pcase tab-bar-close-tab-select ('left (1- (if (< current-index 1) 2 current-index))) ('right (if (> (length tabs) (1+ current-index)) (1+ current-index) (1- current-index))) ('recent (tab-bar--tab-index-recent 1 tabs)))))) (setq to-index (max 0 (min (or to-index 0) (1- (length tabs))))) (let ((inhibit-message t)) ; avoid message about selected tab (tab-bar-select-tab (1+ to-index))) ;; Re-read tabs after selecting another tab (setq tabs (funcall tab-bar-tabs-function)))) (let ((close-tab (nth close-index tabs))) (push `((frame . ,(selected-frame)) (index . ,close-index) (tab . ,(if (eq (car close-tab) 'current-tab) (tab-bar--tab) close-tab))) tab-bar-closed-tabs) (set-frame-parameter nil 'tabs (delq close-tab tabs))) ;; Recalculate `tab-bar-lines' and update frames (tab-bar--update-tab-bar-lines) (force-mode-line-update) (unless tab-bar-mode (message "Deleted tab and switched to %s" tab-bar-close-tab-select)))))) (defun tab-bar-close-tab-by-name (name) "Close the tab by NAME." (interactive (list (completing-read "Close tab by name: " (mapcar (lambda (tab) (alist-get 'name tab)) (funcall tab-bar-tabs-function))))) (tab-bar-close-tab (1+ (tab-bar--tab-index-by-name name)))) (defun tab-bar-close-other-tabs () "Close all tabs on the selected frame, except the selected one." (interactive) (let* ((tabs (funcall tab-bar-tabs-function)) (current-tab (tab-bar--current-tab-find tabs)) (index 0)) (when current-tab (dolist (tab tabs) (unless (or (eq tab current-tab) (run-hook-with-args-until-success 'tab-bar-tab-prevent-close-functions tab ;; `last-tab-p' logically can't ever be true ;; if we make it this far nil)) (push `((frame . ,(selected-frame)) (index . ,index) (tab . ,tab)) tab-bar-closed-tabs) (run-hook-with-args 'tab-bar-tab-pre-close-functions tab nil) (setq tabs (delq tab tabs))) (setq index (1+ index))) (set-frame-parameter nil 'tabs tabs) ;; Recalculate tab-bar-lines and update frames (tab-bar--update-tab-bar-lines) (force-mode-line-update) (unless tab-bar-mode (message "Deleted all other tabs"))))) (defun tab-bar-undo-close-tab () "Restore the most recently closed tab." (interactive) ;; Pop out closed tabs that were on already deleted frames (while (and tab-bar-closed-tabs (not (frame-live-p (alist-get 'frame (car tab-bar-closed-tabs))))) (pop tab-bar-closed-tabs)) (if tab-bar-closed-tabs (let* ((closed (pop tab-bar-closed-tabs)) (frame (alist-get 'frame closed)) (index (alist-get 'index closed)) (tab (alist-get 'tab closed))) (unless (eq frame (selected-frame)) (select-frame-set-input-focus frame)) (let ((tabs (funcall tab-bar-tabs-function))) (setq index (max 0 (min index (length tabs)))) (cl-pushnew tab (nthcdr index tabs)) (when (eq index 0) ;; pushnew handles the head of tabs but not frame-parameter (set-frame-parameter nil 'tabs tabs)) (tab-bar-select-tab (1+ index)))) (message "No more closed tabs to undo"))) (defun tab-bar-rename-tab (name &optional arg) "Rename the tab specified by its absolute position ARG. If no ARG is specified, then rename the current tab. ARG counts from 1. If NAME is the empty string, then use the automatic name function `tab-bar-tab-name-function'." (interactive (let* ((tabs (funcall tab-bar-tabs-function)) (tab-index (or current-prefix-arg (1+ (tab-bar--current-tab-index tabs)))) (tab-name (alist-get 'name (nth (1- tab-index) tabs)))) (list (read-from-minibuffer "New name for tab (leave blank for automatic naming): " nil nil nil nil tab-name) current-prefix-arg))) (let* ((tabs (funcall tab-bar-tabs-function)) (tab-index (if arg (1- (max 0 (min arg (length tabs)))) (tab-bar--current-tab-index tabs))) (tab-to-rename (nth tab-index tabs)) (tab-explicit-name (> (length name) 0)) (tab-new-name (if tab-explicit-name name (funcall tab-bar-tab-name-function)))) (setf (alist-get 'name tab-to-rename) tab-new-name (alist-get 'explicit-name tab-to-rename) tab-explicit-name) (force-mode-line-update) (unless tab-bar-mode (message "Renamed tab to '%s'" tab-new-name)))) (defun tab-bar-rename-tab-by-name (tab-name new-name) "Rename the tab named TAB-NAME. If NEW-NAME is the empty string, then use the automatic name function `tab-bar-tab-name-function'." (interactive (let ((tab-name (completing-read "Rename tab by name: " (mapcar (lambda (tab) (alist-get 'name tab)) (funcall tab-bar-tabs-function))))) (list tab-name (read-from-minibuffer "New name for tab (leave blank for automatic naming): " nil nil nil nil tab-name)))) (tab-bar-rename-tab new-name (1+ (tab-bar--tab-index-by-name tab-name)))) ;;; Tab groups (defun tab-bar-change-tab-group (group-name &optional arg) "Add the tab specified by its absolute position ARG to GROUP-NAME. If no ARG is specified, then set the GROUP-NAME for the current tab. ARG counts from 1. If GROUP-NAME is the empty string, then remove the tab from any group." (interactive (let* ((tabs (funcall tab-bar-tabs-function)) (tab-index (or current-prefix-arg (1+ (tab-bar--current-tab-index tabs)))) (group-name (alist-get 'group (nth (1- tab-index) tabs)))) (list (completing-read "Group name for tab (leave blank to remove group): " (delete-dups (delq nil (cons group-name (mapcar (lambda (tab) (alist-get 'group tab)) (funcall tab-bar-tabs-function)))))) current-prefix-arg))) (let* ((tabs (funcall tab-bar-tabs-function)) (tab-index (if arg (1- (max 0 (min arg (length tabs)))) (tab-bar--current-tab-index tabs))) (tab (nth tab-index tabs)) (group (assq 'group tab)) (group-new-name (and (> (length group-name) 0) group-name))) (if group (setcdr group group-new-name) (nconc tab `((group . ,group-new-name)))) (force-mode-line-update) (unless tab-bar-mode (message "Set tab group to '%s'" group-new-name)))) (defun tab-bar-close-group-tabs (group-name) "Close all tabs that belong to GROUP-NAME on the selected frame." (interactive (let* ((tabs (funcall tab-bar-tabs-function)) (group-name (alist-get 'group (tab-bar--current-tab-find tabs)))) (list (completing-read "Close all tabs with group name: " (delete-dups (delq nil (cons group-name (mapcar (lambda (tab) (alist-get 'group tab)) (funcall tab-bar-tabs-function))))))))) (let* ((close-group (and (> (length group-name) 0) group-name)) (tab-bar-tab-prevent-close-functions (cons (lambda (tab _last-tab-p) (not (equal (alist-get 'group tab) close-group))) tab-bar-tab-prevent-close-functions))) (tab-bar-close-other-tabs) (let* ((tabs (funcall tab-bar-tabs-function)) (current-tab (tab-bar--current-tab-find tabs))) (when (and current-tab (equal (alist-get 'group current-tab) close-group)) (tab-bar-close-tab))))) ;;; Tab history mode (defvar tab-bar-history-limit 10 "The number of history elements to keep.") (defvar tab-bar-history-omit nil "When non-nil, omit window-configuration changes from the current command.") (defvar tab-bar-history-back (make-hash-table) "History of back changes in every tab per frame.") (defvar tab-bar-history-forward (make-hash-table) "History of forward changes in every tab per frame.") (defvar tab-bar-history-old nil "Window configuration before the current command.") (defvar tab-bar-history-old-minibuffer-depth 0 "Minibuffer depth before the current command.") (defun tab-bar--history-pre-change () (setq tab-bar-history-old-minibuffer-depth (minibuffer-depth)) ;; Store wc before possibly entering the minibuffer (when (zerop tab-bar-history-old-minibuffer-depth) (setq tab-bar-history-old `((wc . ,(current-window-configuration)) (wc-point . ,(point-marker)))))) (defun tab-bar--history-change () (when (and (not tab-bar-history-omit) tab-bar-history-old ;; Store wc before possibly entering the minibuffer (zerop tab-bar-history-old-minibuffer-depth)) (puthash (selected-frame) (seq-take (cons tab-bar-history-old (gethash (selected-frame) tab-bar-history-back)) tab-bar-history-limit) tab-bar-history-back)) (when tab-bar-history-omit (setq tab-bar-history-omit nil))) (defun tab-bar-history-back () "Restore a previous window configuration used in the current tab. This navigates back in the history of window configurations." (interactive) (setq tab-bar-history-omit t) (let* ((history (pop (gethash (selected-frame) tab-bar-history-back))) (wc (alist-get 'wc history)) (wc-point (alist-get 'wc-point history))) (if (window-configuration-p wc) (progn (puthash (selected-frame) (cons tab-bar-history-old (gethash (selected-frame) tab-bar-history-forward)) tab-bar-history-forward) (set-window-configuration wc) (when (and (markerp wc-point) (marker-buffer wc-point)) (goto-char wc-point))) (message "No more tab back history")))) (defun tab-bar-history-forward () "Cancel restoration of the previous window configuration. This navigates forward in the history of window configurations." (interactive) (setq tab-bar-history-omit t) (let* ((history (pop (gethash (selected-frame) tab-bar-history-forward))) (wc (alist-get 'wc history)) (wc-point (alist-get 'wc-point history))) (if (window-configuration-p wc) (progn (puthash (selected-frame) (cons tab-bar-history-old (gethash (selected-frame) tab-bar-history-back)) tab-bar-history-back) (set-window-configuration wc) (when (and (markerp wc-point) (marker-buffer wc-point)) (goto-char wc-point))) (message "No more tab forward history")))) (define-minor-mode tab-bar-history-mode "Toggle tab history mode for the tab bar. Tab history mode remembers window configurations used in every tab, and can restore them." :global t :group 'tab-bar (if tab-bar-history-mode (progn (when (and tab-bar-mode (not (get-text-property 0 'display tab-bar-back-button))) ;; This file is pre-loaded so only here we can use the right data-directory: (add-text-properties 0 (length tab-bar-back-button) `(display (image :type xpm :file "tabs/left-arrow.xpm" :margin (2 . 0) :ascent center)) tab-bar-back-button)) (when (and tab-bar-mode (not (get-text-property 0 'display tab-bar-forward-button))) ;; This file is pre-loaded so only here we can use the right data-directory: (add-text-properties 0 (length tab-bar-forward-button) `(display (image :type xpm :file "tabs/right-arrow.xpm" :margin (2 . 0) :ascent center)) tab-bar-forward-button)) (add-hook 'pre-command-hook 'tab-bar--history-pre-change) (add-hook 'window-configuration-change-hook 'tab-bar--history-change)) (remove-hook 'pre-command-hook 'tab-bar--history-pre-change) (remove-hook 'window-configuration-change-hook 'tab-bar--history-change))) ;;; Non-graphical access to frame-local tabs (named window configurations) (defun tab-switcher () "Display a list of named window configurations. The list is displayed in the buffer `*Tabs*'. It's placed in the center of the frame to resemble a window list displayed by a window switcher in some window managers on Alt+Tab. In this list of window configurations you can delete or select them. Type ? after invocation to get help on commands available. Type q to remove the list of window configurations from the display. The first column shows `D' for a window configuration you have marked for deletion." (interactive) (let ((dir default-directory)) (let ((tab-bar-new-tab-choice t) ;; Don't enable tab-bar-mode if it's disabled (tab-bar-show nil)) (tab-bar-new-tab)) (let ((switch-to-buffer-preserve-window-point nil)) (switch-to-buffer (tab-switcher-noselect))) (setq default-directory dir)) (message "Commands: d, x; RET; q to quit; ? for help.")) (defun tab-switcher-noselect () "Create and return a buffer with a list of window configurations. The list is displayed in a buffer named `*Tabs*'. For more information, see the function `tab-switcher'." (let* ((tabs (seq-remove (lambda (tab) (eq (car tab) 'current-tab)) (funcall tab-bar-tabs-function))) ;; Sort by recency (tabs (sort tabs (lambda (a b) (< (alist-get 'time b) (alist-get 'time a)))))) (with-current-buffer (get-buffer-create (format " *Tabs*<%s>" (or (frame-parameter nil 'window-id) (frame-parameter nil 'name)))) (setq buffer-read-only nil) (erase-buffer) (tab-switcher-mode) ;; Vertical alignment to the center of the frame (insert-char ?\n (/ (- (frame-height) (length tabs) 1) 2)) ;; Horizontal alignment to the center of the frame (setq tab-switcher-column (- (/ (frame-width) 2) 15)) (dolist (tab tabs) (insert (propertize (format "%s %s\n" (make-string tab-switcher-column ?\040) (propertize (alist-get 'name tab) 'mouse-face 'highlight 'help-echo "mouse-2: select this window configuration")) 'tab tab))) (goto-char (point-min)) (goto-char (or (next-single-property-change (point) 'tab) (point-min))) (when (> (length tabs) 1) (tab-switcher-next-line)) (move-to-column tab-switcher-column) (set-buffer-modified-p nil) (setq buffer-read-only t) (current-buffer)))) (defvar-local tab-switcher-column 3) (defvar tab-switcher-mode-map (let ((map (make-keymap))) (suppress-keymap map t) (define-key map "q" 'quit-window) (define-key map "\C-m" 'tab-switcher-select) (define-key map "d" 'tab-switcher-delete) (define-key map "k" 'tab-switcher-delete) (define-key map "\C-d" 'tab-switcher-delete-backwards) (define-key map "\C-k" 'tab-switcher-delete) (define-key map "x" 'tab-switcher-execute) (define-key map " " 'tab-switcher-next-line) (define-key map "n" 'tab-switcher-next-line) (define-key map "p" 'tab-switcher-prev-line) (define-key map "\177" 'tab-switcher-backup-unmark) (define-key map "?" 'describe-mode) (define-key map "u" 'tab-switcher-unmark) (define-key map [mouse-2] 'tab-switcher-mouse-select) (define-key map [follow-link] 'mouse-face) map) "Local keymap for `tab-switcher-mode' buffers.") (define-derived-mode tab-switcher-mode nil "Window Configurations" "Major mode for selecting a window configuration. Each line describes one window configuration in Emacs. Letters do not insert themselves; instead, they are commands. \\ \\[tab-switcher-mouse-select] -- select window configuration you click on. \\[tab-switcher-select] -- select current line's window configuration. \\[tab-switcher-delete] -- mark that window configuration to be deleted, and move down. \\[tab-switcher-delete-backwards] -- mark that window configuration to be deleted, and move up. \\[tab-switcher-execute] -- delete marked window configurations. \\[tab-switcher-unmark] -- remove all kinds of marks from current line. With prefix argument, also move up one line. \\[tab-switcher-backup-unmark] -- back up a line and remove marks." (setq truncate-lines t)) (defun tab-switcher-current-tab (error-if-non-existent-p) "Return window configuration described by this line of the list." (let* ((where (save-excursion (beginning-of-line) (+ 2 (point) tab-switcher-column))) (tab (and (not (eobp)) (get-text-property where 'tab)))) (or tab (if error-if-non-existent-p (user-error "No window configuration on this line") nil)))) (defun tab-switcher-next-line (&optional arg) (interactive "p") (forward-line arg) (beginning-of-line) (move-to-column tab-switcher-column)) (defun tab-switcher-prev-line (&optional arg) (interactive "p") (forward-line (- arg)) (beginning-of-line) (move-to-column tab-switcher-column)) (defun tab-switcher-unmark (&optional backup) "Cancel all requested operations on window configuration on this line and move down. Optional prefix arg means move up." (interactive "P") (beginning-of-line) (move-to-column tab-switcher-column) (let* ((buffer-read-only nil)) (delete-char 1) (insert " ")) (forward-line (if backup -1 1)) (move-to-column tab-switcher-column)) (defun tab-switcher-backup-unmark () "Move up and cancel all requested operations on window configuration on line above." (interactive) (forward-line -1) (tab-switcher-unmark) (forward-line -1) (move-to-column tab-switcher-column)) (defun tab-switcher-delete (&optional arg) "Mark window configuration on this line to be deleted by \\\\[tab-switcher-execute] command. Prefix arg is how many window configurations to delete. Negative arg means delete backwards." (interactive "p") (let ((buffer-read-only nil)) (if (or (null arg) (= arg 0)) (setq arg 1)) (while (> arg 0) (delete-char 1) (insert ?D) (forward-line 1) (setq arg (1- arg))) (while (< arg 0) (delete-char 1) (insert ?D) (forward-line -1) (setq arg (1+ arg))) (move-to-column tab-switcher-column))) (defun tab-switcher-delete-backwards (&optional arg) "Mark window configuration on this line to be deleted by \\\\[tab-switcher-execute] command. Then move up one line. Prefix arg means move that many lines." (interactive "p") (tab-switcher-delete (- (or arg 1)))) (defun tab-switcher-delete-from-list (tab) "Delete the window configuration from both lists." (push `((frame . ,(selected-frame)) (index . ,(tab-bar--tab-index tab)) (tab . ,tab)) tab-bar-closed-tabs) (set-frame-parameter nil 'tabs (delq tab (funcall tab-bar-tabs-function)))) (defun tab-switcher-execute () "Delete window configurations marked with \\\\[tab-switcher-delete] commands." (interactive) (save-excursion (goto-char (point-min)) (let ((buffer-read-only nil)) (while (re-search-forward (format "^%sD" (make-string tab-switcher-column ?\040)) nil t) (forward-char -1) (let ((tab (tab-switcher-current-tab nil))) (when tab (tab-switcher-delete-from-list tab) (beginning-of-line) (delete-region (point) (progn (forward-line 1) (point)))))))) (beginning-of-line) (move-to-column tab-switcher-column) (force-mode-line-update)) (defun tab-switcher-select () "Select this line's window configuration. This command deletes and replaces all the previously existing windows in the selected frame." (interactive) (let* ((to-tab (tab-switcher-current-tab t))) (kill-buffer (current-buffer)) ;; Delete the current window configuration of tab list ;; without storing it in the undo list of closed tabs (let ((inhibit-message t) ; avoid message about deleted tab tab-bar-closed-tabs) (tab-bar-close-tab nil (1+ (tab-bar--tab-index to-tab)))))) (defun tab-switcher-mouse-select (event) "Select the window configuration whose line you click on." (interactive "e") (set-buffer (window-buffer (posn-window (event-end event)))) (goto-char (posn-point (event-end event))) (tab-switcher-select)) (defun tab-bar--reusable-frames (all-frames) (cond ((eq all-frames t) (frame-list)) ((eq all-frames 'visible) (visible-frame-list)) ((framep all-frames) (list all-frames)) (t (list (selected-frame))))) (defun tab-bar-get-buffer-tab (buffer-or-name &optional all-frames ignore-current-tab) "Return a tab owning a window whose buffer is BUFFER-OR-NAME. BUFFER-OR-NAME may be a buffer or a buffer name and defaults to the current buffer. The optional argument ALL-FRAMES specifies the frames to consider: - t means consider all tabs on all existing frames. - `visible' means consider all tabs on all visible frames. - A frame means consider all tabs on that frame only. Any other value of ALL-FRAMES means consider all tabs on the selected frame and no others. When the optional argument IGNORE-CURRENT-TAB is non-nil, don't take into account the buffers in the currently selected tab." (let ((buffer (if buffer-or-name (get-buffer buffer-or-name) (current-buffer)))) (when (bufferp buffer) (seq-some (lambda (frame) (seq-some (lambda (tab) (when (if (eq (car tab) 'current-tab) (unless ignore-current-tab (get-buffer-window buffer frame)) (let* ((state (alist-get 'ws tab)) (buffers (when state (window-state-buffers state)))) (or ;; non-writable window-state (memq buffer buffers) ;; writable window-state (member (buffer-name buffer) buffers)))) (append tab `((index . ,(tab-bar--tab-index tab nil frame)) (frame . ,frame))))) (funcall tab-bar-tabs-function frame))) (tab-bar--reusable-frames all-frames))))) (defun display-buffer-in-tab (buffer alist) "Display BUFFER in a tab. ALIST is an association list of action symbols and values. See Info node `(elisp) Buffer Display Action Alists' for details of such alists. If ALIST contains a `tab-name' entry, it creates a new tab with that name and displays BUFFER in a new tab. If a tab with this name already exists, it switches to that tab before displaying BUFFER. The `tab-name' entry can be a function, then it is called with two arguments: BUFFER and ALIST, and should return the tab name. When a `tab-name' entry is omitted, create a new tab without an explicit name. The ALIST entry `tab-group' (string or function) defines the tab group. If ALIST contains a `reusable-frames' entry, its value determines which frames to search for a reusable tab: nil -- the selected frame (actually the last non-minibuffer frame) A frame -- just that frame `visible' -- all visible frames 0 -- all frames on the current terminal t -- all frames. This is an action function for buffer display, see Info node `(elisp) Buffer Display Action Functions'. It should be called only by `display-buffer' or a function directly or indirectly called by the latter." (let* ((reusable-frames (alist-get 'reusable-frames alist)) (reusable-tab (when reusable-frames (tab-bar-get-buffer-tab buffer reusable-frames)))) (if reusable-tab (let* ((frame (alist-get 'frame reusable-tab)) (index (alist-get 'index reusable-tab))) (when frame (select-frame-set-input-focus frame)) (when index (tab-bar-select-tab (1+ index))) (when (get-buffer-window buffer frame) (select-window (get-buffer-window buffer frame)))) (let ((tab-name (alist-get 'tab-name alist))) (when (functionp tab-name) (setq tab-name (funcall tab-name buffer alist))) (if tab-name (let ((tab-index (tab-bar--tab-index-by-name tab-name))) (if tab-index (progn (tab-bar-select-tab (1+ tab-index)) (when (get-buffer-window buffer) (select-window (get-buffer-window buffer)))) (display-buffer-in-new-tab buffer alist))) (display-buffer-in-new-tab buffer alist)))))) (defun display-buffer-in-new-tab (buffer alist) "Display BUFFER in a new tab. ALIST is an association list of action symbols and values. See Info node `(elisp) Buffer Display Action Alists' for details of such alists. Like `display-buffer-in-tab', but always creates a new tab unconditionally, without checking if a suitable tab already exists. If ALIST contains a `tab-name' entry, it creates a new tab with that name and displays BUFFER in a new tab. The `tab-name' entry can be a function, then it is called with two arguments: BUFFER and ALIST, and should return the tab name. When a `tab-name' entry is omitted, create a new tab without an explicit name. The ALIST entry `tab-group' (string or function) defines the tab group. This is an action function for buffer display, see Info node `(elisp) Buffer Display Action Functions'. It should be called only by `display-buffer' or a function directly or indirectly called by the latter." (let ((tab-bar-new-tab-choice t)) (tab-bar-new-tab) (let ((tab-name (alist-get 'tab-name alist))) (when (functionp tab-name) (setq tab-name (funcall tab-name buffer alist))) (when tab-name (tab-bar-rename-tab tab-name))) (let ((tab-group (alist-get 'tab-group alist))) (when (functionp tab-group) (setq tab-group (funcall tab-group buffer alist))) (when tab-group (tab-bar-change-tab-group tab-group))) (window--display-buffer buffer (selected-window) 'tab alist))) (defun switch-to-buffer-other-tab (buffer-or-name &optional norecord) "Switch to buffer BUFFER-OR-NAME in another tab. Like \\[switch-to-buffer-other-frame] (which see), but creates a new tab." (interactive (list (read-buffer-to-switch "Switch to buffer in other tab: "))) (display-buffer (window-normalize-buffer-to-switch-to buffer-or-name) '((display-buffer-in-tab) (inhibit-same-window . nil)) norecord)) (defun find-file-other-tab (filename &optional wildcards) "Edit file FILENAME, in another tab. Like \\[find-file-other-frame] (which see), but creates a new tab." (interactive (find-file-read-args "Find file in other tab: " (confirm-nonexistent-file-or-buffer))) (let ((value (find-file-noselect filename nil nil wildcards))) (if (listp value) (progn (setq value (nreverse value)) (switch-to-buffer-other-tab (car value)) (mapc 'switch-to-buffer (cdr value)) value) (switch-to-buffer-other-tab value)))) (defun find-file-read-only-other-tab (filename &optional wildcards) "Edit file FILENAME, in another tab, but don't allow changes. Like \\[find-file-other-frame] (which see), but creates a new tab. Like \\[find-file-other-tab], but marks buffer as read-only. Use \\[read-only-mode] to permit editing." (interactive (find-file-read-args "Find file read-only in other tab: " (confirm-nonexistent-file-or-buffer))) (find-file--read-only (lambda (filename wildcards) (window-buffer (find-file-other-tab filename wildcards))) filename wildcards)) (defun other-tab-prefix () "Display the buffer of the next command in a new tab. The next buffer is the buffer displayed by the next command invoked immediately after this command (ignoring reading from the minibuffer). Creates a new tab before displaying the buffer, or switches to the tab that already contains that buffer. When `switch-to-buffer-obey-display-actions' is non-nil, `switch-to-buffer' commands are also supported." (interactive) (display-buffer-override-next-command (lambda (buffer alist) (cons (progn (display-buffer-in-tab buffer (append alist '((inhibit-same-window . nil)))) (selected-window)) 'tab)) nil "[other-tab]") (message "Display next command buffer in a new tab...")) ;;; Short aliases and keybindings (defalias 'tab-new 'tab-bar-new-tab) (defalias 'tab-new-to 'tab-bar-new-tab-to) (defalias 'tab-duplicate 'tab-bar-duplicate-tab) (defalias 'tab-close 'tab-bar-close-tab) (defalias 'tab-close-other 'tab-bar-close-other-tabs) (defalias 'tab-close-group 'tab-bar-close-group-tabs) (defalias 'tab-undo 'tab-bar-undo-close-tab) (defalias 'tab-select 'tab-bar-select-tab) (defalias 'tab-switch 'tab-bar-switch-to-tab) (defalias 'tab-next 'tab-bar-switch-to-next-tab) (defalias 'tab-previous 'tab-bar-switch-to-prev-tab) (defalias 'tab-last 'tab-bar-switch-to-last-tab) (defalias 'tab-recent 'tab-bar-switch-to-recent-tab) (defalias 'tab-move 'tab-bar-move-tab) (defalias 'tab-move-to 'tab-bar-move-tab-to) (defalias 'tab-rename 'tab-bar-rename-tab) (defalias 'tab-group 'tab-bar-change-tab-group) (defalias 'tab-list 'tab-switcher) (define-key tab-prefix-map "n" 'tab-duplicate) (define-key tab-prefix-map "N" 'tab-new-to) (define-key tab-prefix-map "2" 'tab-new) (define-key tab-prefix-map "1" 'tab-close-other) (define-key tab-prefix-map "0" 'tab-close) (define-key tab-prefix-map "u" 'tab-undo) (define-key tab-prefix-map "o" 'tab-next) (define-key tab-prefix-map "O" 'tab-previous) (define-key tab-prefix-map "m" 'tab-move) (define-key tab-prefix-map "M" 'tab-move-to) (define-key tab-prefix-map "G" 'tab-group) (define-key tab-prefix-map "r" 'tab-rename) (define-key tab-prefix-map "\r" 'tab-switch) (define-key tab-prefix-map "b" 'switch-to-buffer-other-tab) (define-key tab-prefix-map "f" 'find-file-other-tab) (define-key tab-prefix-map "\C-f" 'find-file-other-tab) (define-key tab-prefix-map "\C-r" 'find-file-read-only-other-tab) (define-key tab-prefix-map "t" 'other-tab-prefix) (provide 'tab-bar) ;;; tab-bar.el ends here