Emacs için tarayıcı tarzı 'sekmeler'?


22

Firefox gibi sekmeler istiyorum ama emacs için.

Bunu buldum: http://emacswiki.org/emacs/TabBarMode

Ancak , şu anda açık arabellekleri gösteren yalnızca bir arabellek ( Emacs terminolojisindeki pencere ) ekler .

Bir sekmenin, istediğiniz gibi bölebileceğim birden fazla arabellek ( Emacs teminology'deki pencereler ) tutabilmesini istiyorum. Yani her sekme bir "pencere durumuna" (anlamında window-state-get) karşılık gelmelidir .

Görevlerim için bir sekme, kod için bir kod, web okuma için bir tane daha var.

Mümkün mü? Tabbar bunu yapmak için uyarlanabilir mi?

[değiştir2]
Bu soru beklediğimden daha fazla dikkat çekti. Bir çözüm var gibi gözüküyor, ancak biraz araştırma ve ince ayar gerektirecek bir çözüm var. Bu / gelecek hafta benim için biraz meşgul olsa da, cevapları çözeceğim ve işe yarayan bir şey inşa etmeye çalışacağım ve sonra bu soruyu bulgularımı yansıtacak şekilde düzenleyeceğim. Lütfen bekle =)

[düzenle]
Benzer şekilde sırala:
/programming/24157754/make-frames-in-emacs-gui-behaves-like-frames-in-terminal

Aynı zamanda tek bir GUI oturumunda birden fazla kareyle anlaşmak istiyorum.


2
"Bir sekmenin, istediğiniz gibi bölebileceğim birden fazla arabellek tutabilmesini istiyorum." Birden fazla pencere mi demek istiyorsun ?
Malabarba

1
Daha çok dinamik sekmelere sahip olmak isterdim. Onları yaratır ve sonra pencereleri doldururum. Yani bir sekmenin kare olmasını istiyorum. Sonra yeni bir sekme yeni bir çerçeve. Her sekmenin / çerçevenin içinde istenen pencereleri / (tamponları) açabilirim. Bu yapılabilir mi? (
Başka bir deyişle

1
Belirli pencerelerle ilişkili bir değişken var, ancak bir ya da iki ay oldu, bu konu hakkında bir konu belirdi ve ne denir diye bilmiyorum. Bir listenin, bir çerçeveyle ilişkili arabellekleri tuttuğu ve bu listenin çerçeve parametresine dahil edildiği çerçeve oluşturuculara benzer bir sistem kullanmak isteyebilirsiniz. Belirli bir pencereyle ilişkilendirilmiş değişkeni kullanabilir ve bir liste yapabilir, listeye tamponlar ekleyebilir / çıkartabilirsiniz - bu liste tabbar tarafından kullanılacak bir tampon-grup olacaktır. Bunların hepsi teorik, ama işe yarayacağına inanıyorum.
kanun listesi 17:15

1
Bence başvurabilirsin: stackoverflow.com/questions/24157754/… ancak bu
yazının

1
Elscreen paketine bir göz atmanızı tavsiye ederim.
blarghmatey

Yanıtlar:


8

Tamponları gruplara ayırma

Tabbar ile mümkündür. Grup arabelleklerine gruplar halinde kurallar ekleyebilirsiniz. İşte temel bir snippet:

(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"
     ))))

Örnek kurallar:

  1. Arabellek adlarını listele:
    ((member (buffer-name)
             '("*scratch*" "*Messages*" "*Help*"))
     "Common" ;; this is a group name
     )
  1. Sık kullanılan tamponlarla ilgili olarak, “Yıldız” ile başlayan her tampon için “Ortak” yazmayı tercih ederim. Bu, bu kural için bir tampon oluşturmaya örnek verir:
    ((string-equal "*" (substring (buffer-name) 0 1))
     "Common"
     )
  1. Ana mod tarafından gruplama tamponlarına bir örnek:
    ((memq major-mode
           '(org-mode text-mode rst-mode))
     "Text"
     )
  1. İşte türetilen moduna göre gruplandırma tamponlarının bir örneği:
    ((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"
     )
  1. İşte regexp'e göre gruplama sekmelerine bir örnek:
    ((string-match "^__" (buffer-name))
     "Templates"
     )
  1. Ana moda göre grup tamponları:
    (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))

Kuralları oluşturduktan sonra, grupları değiştirmek için + veya - tabbar'ın sekme satırında ve ayrıca arabellekler arasında geçiş yapmak için ◀ ve ▶ tuşlarına basabilirsiniz. Veya sadece aşağıdaki yenilikleri bağlayın:

tabbar-forward
tabbar-backward
tabbar-forward-group
tabbar-backward-group

ve klavyeyle sekmeler ve sekme grupları arasında hareket edin.

Şahsen ben sekmeleri gruplandırıyorum, böylece neyin açık olduğunu görebiliyorum, fakat aralarında gezin ido-switch-buffer.

Kural kümesi arasında geçiş yap

Ayrıca, farklı tampon gruplandırma kuralları kümesi tanımlanabilir ve bunlar arasında döngü yapılabilir. İki tampon gruplandırma kuralı grubu arasında bir döngü örneği:

;; 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)

Bu tabbar-buffer-groups-commonve tabbar-buffer-groupssekme gruplama defuns arasında geçiş yapar .

Sekme arabelleklerini ada göre sırala

Sekme arabelleklerini ada göre sıralamanın yararlı olduğunu düşünüyorum. İşte onu almak için nasıl:

(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))))))))))

Detaylı cevap için teşekkür ederim. Yukarıdakileri denemeye çalışacağım ve size en sonunda ~ haber verecek :)
Leo Ufimtsev

Ancak OP "pencere başına bir sekme" istemiyor, çerçeve başına bir sekme istiyor ve sekme içindeki her sekme bir tampondan ziyade "window config" (yani birkaç pencere) temsil etmeli, bu nedenle gruplama arabellekleri sorun değil .
Stefan,

6

ATTRIBUTE: Arabelleklerin çerçeve bazında gruplandırılması, Alp Aker'in geliştirdiği / yazdığı kod kavramlarının doğrudan seçilmesi ve yazılan kod bölümlerinin kütüphane çerçevelerinde uygulanmasıdır: https://github.com/alpaker/Frame-Bufs

Aşağıdakiler, kütüphane tabbar.elve grup sekmelerini / tamponlarını çerçeve başına dinamik olarak, sekmeleri / tamponları ekleyerek C-c C-aveya bunları kaldırarak veya sekmeleri / tamponları kullanarak nasıl kullanacağınıza bir örnektir C-c C-n. Geçerli kareyle (yani "A") ilişkili ve mevcut kareyle (yani ) ilişkilendirilmiş yalnızca iki (2) grup vardır "N". Gruplar kare-yereldir, yani her karenin kendi gruplandırması olabilir. Özel gruplama ile sıfırlanabilir C-c C-r. İle ilişkili ve ilişkili olmayan gruplar arasında geçiş yapın C-tab. Geçerli gruptaki bir sonraki sekmeye / arabelleğe geçin M-s-right. Geçerli gruptaki önceki sekmeye / arabelleğe geçin M-s-left.

Sekmeler / tamponlar my-add-bufferve ile programlı olarak eklenebilir veya kaldırılabilir my-remove-buffer. Seçme karelerde belli tamponlarını açmak için nasıl bir örnek için başlıklı ilgili iplik bakın o açılmadan önce bir dosya yolunu kesmek için nasıl ve hangi çerçeve karar : /programming//a/18371427/2112489 işlevi my-add-buffergerekir Bir kullanıcı bu özelliği uygulamayı seçerse, yukarıdaki linkteki kodun uygun yerlerine dahil edilmelidir.

Kullanıcı mode-line-format, aşağıdaki snippet'i ekleyerek mod satırında geçerli sekme grubunun adını görüntüleyen bir özelde bir giriş oluşturmak isteyebilir : (:eval (when tabbar-mode (format "%s" (tabbar-current-tabset t)))) Bununla birlikte, mod çizgisini daha ayrıntılı bir şekilde özelleştirmek, bu örneğin kapsamı dışındadır.

İşlev tabbar-add-tab, sekmeleri / tamponları alfabetik olarak değiştirecek şekilde değiştirildi.

İşlev tabbar-line-tab, duruma bağlı olarak dört (4) farklı yüz sağlayacak şekilde değiştirildi. Sekme / tampon çerçeve ile ilişkilendirilmişse ve IS seçilmişse, tabbar-selected-associatedyüzünü kullanın . Sekme / tampon çerçeveyle ilişkilendirilmiş ve seçili değilse, tabbar-unselected-associatedyüzünü kullanın . Sekme / tampon çerçeveyle ilişkilendirilmezse ve IS seçilirse, tabbar-selected-unassociatedyüzünü kullanın . Sekme / tampon çerçeveyle ilişkilendirilmezse ve seçili değilse, tabbar-unselected-unassociatedyüzünü kullanın .

;; Download tabbar version 2.0.1 by David Ponce:
;;   https://marmalade-repo.org/packages/tabbar
;; or use package-install for marmalade repositories.

;; Place tabbar-2.0.1.el in the `load-path` -- it is okay to rename it to tabbar.el
;; or add the directory (where `tabbar.el` resides) to the `load-path`.
;; EXAMPLE:  (setq load-path (append '("/Users/HOME/.emacs.d/lisp/") load-path))

(require 'tabbar)

(setq tabbar-cycle-scope 'tabs)

(remove-hook 'kill-buffer-hook 'tabbar-buffer-track-killed)

(defun my-buffer-groups ()
  "Function that gives the group names the current buffer belongs to.
It must return a list of group names, or nil if the buffer has no
group.  Notice that it is better that a buffer belongs to one group."
  (list
    (cond
      ((memq (current-buffer) (my-buffer-list (selected-frame)))
        "A")
      (t
        "N"))))

(setq tabbar-buffer-groups-function 'my-buffer-groups) ;; 'tabbar-buffer-groups

;; redefine tabbar-add-tab so that it alphabetizes / sorts the tabs
(defun tabbar-add-tab (tabset object &optional append)
  "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))
             (tentative-new-tabset
               (if append
                 (append tabs (list tab))
                 (cons tab tabs)))
             (new-tabset
               (sort
                  tentative-new-tabset
                  #'(lambda (e1 e2)
                     (string-lessp
                       (format "%s" (car e1)) (format "%s" (car e2)))))))
        (tabbar-set-template tabset nil)
        (set tabset new-tabset)))))

;; AUTHOR:  Alp Aker -- https://github.com/alpaker/Frame-Bufs
;; @lawlist extracted/revised the function(ality) from said library.
(defun my-buffer-list (frame)
  ;; Remove dead buffers.
  (set-frame-parameter frame 'frame-bufs-buffer-list
    (delq nil (mapcar #'(lambda (x) (if (buffer-live-p x) x))
      (frame-parameter frame 'frame-bufs-buffer-list))))
  ;; Return the associated-buffer list.
  (frame-parameter frame 'frame-bufs-buffer-list))

(defun my-kill-buffer-fn ()
"This function is attached to a buffer-local `kill-buffer-hook'."
  (let ((frame (selected-frame))
        (current-buffer (current-buffer)))
    (when (memq current-buffer (my-buffer-list frame))
      (my-remove-buffer current-buffer frame))))

;; AUTHOR:  Alp Aker -- https://github.com/alpaker/Frame-Bufs
;; @lawlist extracted/revised the function(ality) from said library.
(defun my-add-buffer (&optional buf frame)
"Add BUF to FRAME's associated-buffer list if not already present."
(interactive)
  (let* ((buf (if buf buf (current-buffer)))
         (frame (if frame frame (selected-frame)))
         (associated-bufs (frame-parameter frame 'frame-bufs-buffer-list)))
    (unless (bufferp buf)
      (signal 'wrong-type-argument (list 'bufferp buf)))
    (unless (memq buf associated-bufs)
      (set-frame-parameter frame 'frame-bufs-buffer-list (cons buf associated-bufs)))
    (with-current-buffer buf
      (add-hook 'kill-buffer-hook 'my-kill-buffer-fn 'append 'local))
    (when tabbar-mode (tabbar-display-update))))

;; AUTHOR:  Alp Aker -- https://github.com/alpaker/Frame-Bufs
;; @lawlist extracted/revised the function(ality) from said library.
(defun my-remove-buffer (&optional buf frame)
"Remove BUF from FRAME's associated-buffer list."
(interactive)
  (let ((buf (if buf buf (current-buffer)))
        (frame (if frame frame (selected-frame))))
    (set-frame-parameter frame 'frame-bufs-buffer-list
      (delq buf (frame-parameter frame 'frame-bufs-buffer-list)))
    (when tabbar-mode (tabbar-display-update))))

;; AUTHOR:  Alp Aker -- https://github.com/alpaker/Frame-Bufs
;; @lawlist extracted/revised the function(ality) from said library.
(defun my-buffer-list-reset ()
    "Wipe the entire slate clean for the selected frame."
  (interactive)
    (modify-frame-parameters (selected-frame) (list (cons 'frame-bufs-buffer-list nil)))
    (when tabbar-mode (tabbar-display-update)))

(defun my-switch-tab-group ()
"Switch between tab group `A` and `N`."
(interactive)
  (let ((current-group (format "%s" (tabbar-current-tabset t)))
        (tab-buffer-list (mapcar
            #'(lambda (b)
                (with-current-buffer b
                  (list (current-buffer)
                        (buffer-name)
                        (funcall tabbar-buffer-groups-function))))
                 (funcall tabbar-buffer-list-function))))
    (catch 'done
      (mapc
        #'(lambda (group)
            (when (not (equal current-group
                          (format "%s" (car (car (cdr (cdr group)))))))
              (throw 'done (switch-to-buffer (car (cdr group))))))
        tab-buffer-list))))

(defface tabbar-selected-associated
  '((t :background "black" :foreground "yellow" :box (:line-width 2 :color "yellow")))
  "Face used for the selected tab -- associated with the `frame-bufs-buffer-list`."
  :group 'tabbar)

(defface tabbar-unselected-associated
  '((t :background "black" :foreground "white" :box (:line-width 2 :color "white")))
  "Face used for unselected tabs  -- associated with the `frame-bufs-buffer-list`."
  :group 'tabbar)

(defface tabbar-selected-unassociated
  '((t :background "black" :foreground "white" :box (:line-width 2 :color "firebrick")))
  "Face used for the selected tab -- UNassociated with the `frame-bufs-buffer-list`."
  :group 'tabbar)

(defface tabbar-unselected-unassociated
  '((t :background "black" :foreground "white" :box (:line-width 2 :color "blue")))
  "Face used for unselected tabs -- UNassociated with the `frame-bufs-buffer-list`."
  :group 'tabbar)

(setq tabbar-background-color "black")

(defsubst tabbar-line-tab (tab)
  "Return the display representation of tab TAB.
That is, a propertized string used as an `header-line-format' template
element.
Call `tabbar-tab-label-function' to obtain a label for TAB."
  (concat
    (propertize
      (if tabbar-tab-label-function
          (funcall tabbar-tab-label-function tab)
        tab)
      'tabbar-tab tab
      'local-map (tabbar-make-tab-keymap tab)
      'help-echo 'tabbar-help-on-tab
      'mouse-face 'tabbar-highlight
      'face
        (cond
          ((and
              (tabbar-selected-p tab (tabbar-current-tabset))
              (memq (current-buffer) (my-buffer-list (selected-frame))))
            'tabbar-selected-associated)
          ((and
              (not (tabbar-selected-p tab (tabbar-current-tabset)))
              (memq (current-buffer) (my-buffer-list (selected-frame))))
            'tabbar-unselected-associated)
          ((and
              (tabbar-selected-p tab (tabbar-current-tabset))
              (not (memq (current-buffer) (my-buffer-list (selected-frame)))))
            'tabbar-selected-unassociated)
          ((and
              (not (tabbar-selected-p tab (tabbar-current-tabset)))
              (not (memq (current-buffer) (my-buffer-list (selected-frame)))))
            'tabbar-unselected-unassociated))
      'pointer 'hand)
    tabbar-separator-value))

(define-key global-map "\C-c\C-r" 'my-buffer-list-reset)

(define-key global-map "\C-c\C-a" 'my-add-buffer)

(define-key global-map "\C-c\C-n" 'my-remove-buffer)

(define-key global-map (kbd "<M-s-right>") 'tabbar-forward)

(define-key global-map (kbd "<M-s-left>") 'tabbar-backward)

(define-key global-map [C-tab] 'my-switch-tab-group)

(tabbar-mode 1)

Aşağıdaki ekran görüntüsü, iki olası tampon / sekme grubunu göstermektedir: (1) soldaki, SYSTEM[sarı ve beyaz sekmeler] ile gösterilen çerçeveyle ilişkilendirilen tamponların / sekmelerin, "A" harfi ile belirtilmiştir. mod hattı; ve sağdaki (2) vardır, bu tampon / sekme gruplama olduğu değil adlı çerçevesi ile ilişkili SYSTEMmodu çizgi ile belirtilen bir büyük harf "N" ile, [mavi ve kırmızı sekme].

Örnek


Ancak OP "pencere başına bir sekme" istemiyor, çerçeve başına bir sekme istiyor ve sekme içindeki her sekme bir tampon yerine "window config" (yani birkaç pencere) göstermelidir.
Stefan,

5

Tamponları gruplandırmasa da , ekrana bakmayı düşünün .

Yaptığı şey, pencereleri gruplamak ve hızlı bir şekilde taşıyabileceğiniz birden çok mizanpaja (sekme) erişim sağlamak. İş akışımda genellikle bir kod üzerinde bazı Ruby kodları ve ilgili testler bulunurken, benim todo ve Org notlarım diğerlerinde ve belki de SQL sorgularını hazırlamak için çizik bir tamponda üçüncü sırada yer alıyor. Bu, her ekran aynı tampon havuzundan çıksa da, görevler ve projeler arasında kolayca atlamamı sağlıyor.


3

Eklentim, centaur-tab'lere ne dersiniz? Bir çok konfigürasyon seçeneğine sahiptir, gerçekten işlevseldir, Kaolin Temaları gibi çok popüler temalar tarafından desteklenir ve genel olarak çok hoş görünümlü ve estetik bir pakettir (kullanıcının geri bildirimlerine göre). MELPA'da mevcut ve şöyle görünüyor:

görüntü tanımını buraya girin


Bu, başka bir şey gibi görünüyor "her sekme bir arabelleği temsil ediyor ve her pencerenin kendi sekme çubuğu var" çözümü değil.
Stefan,

Ben sadece sekme isimleri yerine sekme grupları göstermek için bir özelleştirme ekledim, böylece bir fonksiyonda kurallar (yani bir grupta elisp ve lisp, diğer gruplarda c ve c ++ ve diğer gruplarda elisp ve lisp) ve bu grupların gösterdiği sekmelerde gösterdim.
Emmanuel Bustos

Her soru için kare başına bir sekme (pencere başına değil) olması gerektiği ve her sekme bir pencere konfigürasyonunu temsil ettiği sorusuna hala cevap vermiyor .
Stefan

Tamam anlamadım. Araştırıp üzerinde çalışacağım!
Emmanuel Bustos

0

İşte benim yapılandırmam, buna değer. Bu özellikler:

  • (Sekmelerde Fare operasyon mouse-2sona, tarayıcılarda gibi , mouse-3 olduğu gibi yeni Emacs pencerede aç pop i3 )
  • Klavye kontrolleri ( M-left& TMux / Screen'deki gibi sağ geçiş sekmeleri )
  • Renkler ("Moe teması / moe-dark" yapılandırmasıyla uyumlu )
  • Gruplandırma (şu anda, Emacs *buffers*ve "normal")
  • Otomatik güncelleme ( kullanım paketi ile )

TabBar

(use-package tabbar
  :ensure t
  :bind
  ("<M-left>" . tabbar-backward)
  ("<M-right>" . tabbar-forward)

  :config
  (set-face-attribute
   'tabbar-button nil
   :box '(:line-width 1 :color "gray19"))

  (set-face-attribute
   'tabbar-selected nil
   :foreground "orange"
   :background "gray19"
   :box '(:line-width 1 :color "gray19"))

  (set-face-attribute
   'tabbar-unselected nil
   :foreground "gray75"
   :background "gray25"
   :box '(:line-width 1 :color "gray19"))

  (set-face-attribute
   'tabbar-highlight nil
   :foreground "black"
   :background "orange"
   :underline nil
   :box '(:line-width 1 :color "gray19" :style nil))

  (set-face-attribute
   'tabbar-modified nil
   :foreground "orange red"
   :background "gray25"
   :box '(:line-width 1 :color "gray19"))

  (set-face-attribute
   'tabbar-selected-modified nil
   :foreground "orange red"
   :background "gray19"
   :box '(:line-width 1 :color "gray19"))

  (custom-set-variables
   '(tabbar-separator (quote (0.2))))

  (defun tabbar-buffer-tab-label (tab)
    "Return a label for TAB.
  That is, a string used to represent it on the tab bar."
    (let ((label  (if tabbar--buffer-show-groups
                      (format " [%s] " (tabbar-tab-tabset tab))
                    (format " %s " (tabbar-tab-value tab)))))
      (if tabbar-auto-scroll-flag
          label
        (tabbar-shorten
         label (max 1 (/ (window-width)
                         (length (tabbar-view
                                  (tabbar-current-tabset)))))))))

  (defun px-tabbar-buffer-select-tab (event tab)
    "On mouse EVENT, select TAB."
    (let ((mouse-button (event-basic-type event))
          (buffer (tabbar-tab-value tab)))
      (cond
       ((eq mouse-button 'mouse-2) (with-current-buffer buffer (kill-buffer)))
       ((eq mouse-button 'mouse-3) (pop-to-buffer buffer t))
       (t (switch-to-buffer buffer)))
      (tabbar-buffer-show-groups nil)))

  (defun px-tabbar-buffer-help-on-tab (tab)
    "Return the help string shown when mouse is onto TAB."
    (if tabbar--buffer-show-groups
        (let* ((tabset (tabbar-tab-tabset tab))
               (tab (tabbar-selected-tab tabset)))
          (format "mouse-1: switch to buffer %S in group [%s]"
                  (buffer-name (tabbar-tab-value tab)) tabset))
      (format "\
mouse-1: switch to %S\n\
mouse-2: kill %S\n\
mouse-3: Open %S in another window"
              (buffer-name (tabbar-tab-value tab))
              (buffer-name (tabbar-tab-value tab))
              (buffer-name (tabbar-tab-value tab)))))

  (defun px-tabbar-buffer-groups ()
    "Sort tab groups."
    (list (cond ((or
                  (eq major-mode 'dired-mode)
                  (string-equal "*" (substring (buffer-name) 0 1))) "emacs")
                (t "user"))))
  (setq tabbar-help-on-tab-function 'px-tabbar-buffer-help-on-tab
        tabbar-select-tab-function 'px-tabbar-buffer-select-tab
        tabbar-buffer-groups-function 'px-tabbar-buffer-groups)

  :init
  (tabbar-mode 1))

Ek 1 - Moe Teması

(use-package moe-theme
  :ensure t
  :config
  (progn
    (load-theme 'moe-dark :no-confirm)
    (set-face-attribute 'fringe nil :background "gray19")))

Ek 2 - Son 2 tamponu değiştir (KB makro)

(define-key global-map [(control tab)] (kbd "C-x b <return>")) 
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.