ui/tabbar: rewrite

Not that you should use this module. It is now more of an experiment to
get more conventional tab-like functionality in Emacs, without the help
of tabbar-mode, which doesn't actually do what we want.

Over time I may improve this (or not).

modules/ui/tabbar/README.org

@@ -1,5 +1,7 @@
 #+TITLE: :ui tabbar
 
-This module adds a tabbar to the Emacs UI.
+This module adds an Atom-esque tab bar to the Emacs UI.
 
-I don't recommend you use this module. It is here for reference, is unstable and doesn't integrate with Doom's UI well. I find ivy, helm or even ~buffer-menu~ to be better suited for buffer management.
+I don't recommend you use this module. It is here for reference, is unstable and
+may be removed some day. I find ivy, helm or even ~buffer-menu~ to be better
+suited for buffer management.

modules/ui/tabbar/config.el

@@ -1,37 +1,92 @@
 ;;; ui/tabbar/config.el -*- lexical-binding: t; -*-
 
-;; This is here for reference. I don't use tabbar because it's unstable and not
+;; This is here for reference. It is incomplete, buggy, and may be removed one
-;; very useful (all it does is show a buffer list on top of *every* window). I
+;; day. It shows window-local buffer lists.
-;; find ivy (or helm) or even `buffer-menu' is better suited for this purpose.
 
-(def-package! tabbar
+(defvar +tabbar-mode-map
-  :hook (doom-init-ui . tabbar-mode)
+  (let ((map (make-sparse-keymap)))
-  :config
+    (define-key map [remap delete-window] #'+tabbar/close-tab-or-window)
-  (setq tabbar-use-images nil)
+    (define-key map [remap +workspace/close-window-or-workspace] #'+tabbar/close-tab-or-window)
+    map)
+  "TODO")
 
-  (defun +tabbar|disable-in-popups ()
+(after! persp-mode
-    (when (and +popup-buffer-mode tabbar-mode)
+  (define-key persp-mode-map [remap delete-window] #'+tabbar/close-tab-or-window)
-      (tabbar-local-mode -1)
+  (define-key persp-mode-map [remap +workspace/close-window-or-workspace] #'+tabbar/close-tab-or-window))
-      (setq-local header-line-format nil)))
-  (add-hook '+popup-buffer-mode-hook #'+tabbar|disable-in-popups)
 
-  (defun +tabbar-display-tab (tab)
+(define-minor-mode +tabbar-mode
-    "Return a label for TAB that resembles tabs in Atom."
+  "TODO"
-    (let ((label (if tabbar--buffer-show-groups
+  :global t
-                     (format "[%s]" (tabbar-tab-tabset tab))
+  :keymap +tabbar-mode-map
-                   (format "%s" (tabbar-tab-value tab))))
+  (if +tabbar-mode
-          (bar-color (face-background 'doom-modeline-bar nil t))
+      (setq-default header-line-format '((:eval (+tabbar-line))))
-          (bar-height 25)
+    (setq-default header-line-format nil)))
-          (bar-width 3)
+(+tabbar-mode +1)
-          (selected-p (eq tab (tabbar-selected-tab (tabbar-current-tabset)))))
+
-      (concat (when (and (display-graphic-p) selected-p)
+
-                (+doom-modeline--make-xpm bar-color bar-height bar-width))
+;;
-              " "
+(add-hook! 'doom-load-theme-hook
-              (if tabbar-auto-scroll-flag
+  (defconst +tabbar-bar (make-xpm (face-background 'highlight) 3 26))
-                  label
+  (defconst +tabbar-hidden-bar (make-xpm nil 1 26))
-                (tabbar-shorten
+  (setq-default header-line-format `(,+tabbar-hidden-bar (:eval (+tabbar-line))))
-                 label (max 1 (/ (window-width)
+
-                                 (length (tabbar-view
+  (add-to-list 'default-frame-alist '(buffer-predicate . +tabbar-buffer-predicate))
-                                          (tabbar-current-tabset)))))))
+  (dolist (frame (frame-list))
-              " ")))
+    (set-frame-parameter frame 'buffer-predicate #'+tabbar-buffer-predicate)))
-  (setq tabbar-tab-label-function #'+tabbar-display-tab))
+
+(defun +tabbar-buffer-predicate (buffer)
+  (or (memq buffer (window-parameter nil 'tabbar-buffers))
+      (eq buffer (doom-fallback-buffer))))
+
+
+(defun +tabbar-line ()
+  (unless (or (window-dedicated-p)
+              (null mode-line-format))
+    (concat (cl-loop for buf in (window-parameter nil 'tabbar-buffers)
+                     if (eq (get-buffer buf) (current-buffer))
+                     concat (propertize (format "%s  %s  " +tabbar-bar buf)
+                                        'face 'default)
+                     else
+                     concat (propertize (format "  %s  " buf) 'face 'mode-line-inactive))
+            +tabbar-hidden-bar)))
+
+(defun +tabbar*bury-buffer (orig-fn &rest args)
+  (let ((b (current-buffer)))
+    (apply orig-fn args)
+    (unless (eq b (current-buffer))
+      (with-current-buffer b
+        (+tabbar|remove-buffer)))))
+(advice-add #'bury-buffer :around #'+tabbar*bury-buffer)
+
+(defun +tabbar*kill-this-buffer (&rest _)
+  (+tabbar|remove-buffer))
+(advice-add #'kill-this-buffer :before #'+tabbar*kill-this-buffer)
+
+(defun +tabbar|remove-buffer ()
+  (set-window-parameter
+   nil
+   'tabbar-buffers (delete (current-buffer) (window-parameter nil 'tabbar-buffers))))
+
+(defun +tabbar/close-tab-or-window ()
+  (interactive)
+  (call-interactively
+   (cond ((cdr (window-parameter nil 'tabbar-buffers))
+          #'kill-this-buffer)
+         ((fboundp '+workspace/close-window-or-workspace)
+          #'+workspace/close-window-or-workspace)
+         (#'delete-window))))
+
+(defun +tabbar|add-buffer ()
+  (when (doom-real-buffer-p (current-buffer))
+    (let* ((this-buf (current-buffer))
+           (buffers (window-parameter nil 'tabbar-buffers)))
+      (unless (memq this-buf buffers)
+        (setq buffers (append buffers (list this-buf))))
+      (add-hook 'kill-buffer-hook #'+tabbar|remove-buffer nil t)
+      (set-window-parameter nil 'tabbar-buffers buffers))))
+(add-hook 'doom-switch-buffer-hook #'+tabbar|add-buffer)
+
+(defun +tabbar|new-window ()
+  (unless (window-parameter nil 'tabbar-buffers)
+    (+tabbar|add-buffer)))
+(add-hook 'doom-switch-window-hook #'+tabbar|new-window)

modules/ui/tabbar/packages.el

@@ -1,4 +1,2 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; ui/tabbar/packages.el
-
-(package! tabbar)