Diviser les tampons en groupes
C'est possible avec la barre d'onglets. Vous pouvez ajouter des règles aux tampons de groupe en groupes. Voici un extrait de base:
(defun tabbar-buffer-groups ()
"Returns the list of group names the current buffer belongs to."
(list
(cond
;; ADD RULES TO SPLIT BUFFERS IN GROUPS HERE!
;; if buffer is not grouped by the rules you would add above
;; put it in the "General" group:
(t
"General"
))))
Exemples de règles:
- Liste des noms de tampons:
((member (buffer-name)
'("*scratch*" "*Messages*" "*Help*"))
"Common" ;; this is a group name
)
- En ce qui concerne les tampons communs, je préfère mettre en "Common" chaque tampon dont le nom commence par une étoile. Cela donne un exemple de création d'un tampon pour cette règle:
((string-equal "*" (substring (buffer-name) 0 1))
"Common"
)
- Voici un exemple de regroupement des tampons par mode principal:
((memq major-mode
'(org-mode text-mode rst-mode))
"Text"
)
- Voici un exemple de regroupement des tampons en fonction du mode dont ils sont dérivés:
((or (get-buffer-process (current-buffer))
;; Check if the major mode derives from `comint-mode' or
;; `compilation-mode'.
(tabbar-buffer-mode-derived-p
major-mode '(comint-mode compilation-mode)))
"Process"
)
- Voici un exemple de regroupement des onglets par expression rationnelle:
((string-match "^__" (buffer-name))
"Templates"
)
- Grouper les tampons par mode principal:
(if (and (stringp mode-name)
;; Take care of preserving the match-data because this
;; function is called when updating the header line.
(save-match-data (string-match "[^ ]" mode-name)))
mode-name
(symbol-name major-mode))
Une fois que vous avez composé les règles, vous pouvez appuyer sur + ou - sur la ligne de tabulation de la barre d'onglets pour basculer entre les groupes, et également sur ◀ et ▶ pour basculer entre les tampons. Ou liez simplement les défuns suivants:
tabbar-forward
tabbar-backward
tabbar-forward-group
tabbar-backward-group
et vous déplacer entre les onglets et les groupes d'onglets avec le clavier.
Personnellement, je groupe les onglets, afin de voir ce qui est ouvert, mais de les parcourir ido-switch-buffer.
Basculer entre un ensemble de règles
On peut également définir un ensemble différent de règles de regroupement de tampons et alterner entre celles-ci. Voici un exemple de cycle entre deux ensembles de règles de regroupement de tampons:
;; tab-groups!
(setq tbbr-md "common")
(defun toggle-tabbar-mode ()
"Toggles tabbar modes - all buffers vs. defined in the `tabbar-buffer-groups'."
(interactive)
(if (string= tbbr-md "groups")
(progn ;; then
(setq tabbar-buffer-groups-function 'tabbar-buffer-groups-common)
(setq tbbr-md "common"))
(progn ;; else
(setq tabbar-buffer-groups-function 'tabbar-buffer-groups)
(setq tbbr-md "groups"))))
;; by default - all tabs:
(setq tabbar-buffer-groups-function 'tabbar-buffer-groups-common)
Cela permet de basculer entre les défuns de regroupement tabbar-buffer-groups-commonet de tabbar-buffer-groupstabulation.
Trier les tampons de la barre d'onglets par nom
Je trouve avantageux de trier les tampons de la barre de tabulation par nom. Voici comment l'obtenir:
(defun tabbar-add-tab (tabset object &optional append_ignored)
"Add to TABSET a tab with value OBJECT if there isn't one there yet.
If the tab is added, it is added at the beginning of the tab list,
unless the optional argument APPEND is non-nil, in which case it is
added at the end."
(let ((tabs (tabbar-tabs tabset)))
(if (tabbar-get-tab object tabset)
tabs
(let ((tab (tabbar-make-tab object tabset)))
(tabbar-set-template tabset nil)
(set tabset (sort (cons tab tabs)
(lambda (a b) (string< (buffer-name (car a)) (buffer-name (car b))))))))))
