สไตล์แท็บ 'เบราว์เซอร์สำหรับ emacs?


22

ฉันต้องการแท็บเหมือน Firefox แต่สำหรับ emacs

ฉันพบสิ่งนี้: http://emacswiki.org/emacs/TabBarMode

แต่มันเพิ่มให้กับแต่ละบัฟเฟอร์ ( หน้าต่างในคำศัพท์ของ Emacs) แถบที่แสดงบัฟเฟอร์ที่เปิดอยู่ในปัจจุบัน

ฉันต้องการให้แท็บสามารถเก็บบัฟเฟอร์หลาย ๆ อัน ( windowsใน Emacs teminology) ซึ่งฉันสามารถแยกได้ตามต้องการ คือแต่ละแท็บควรสอดคล้องกับ "สถานะหน้าต่าง" (ในความหมายของwindow-state-get)

ฉันมีแท็บหนึ่งสำหรับงานของฉันส่วนอีกอันสำหรับรหัสส่วนอีกอันสำหรับการอ่านเว็บเป็นต้น

เป็นไปได้ไหม Tabbar สามารถปรับแต่งให้ทำเช่นนี้ได้หรือไม่?

[edit2]
คำถามนี้ดึงดูดความสนใจมากกว่าที่ฉันคาดไว้ ดูเหมือนว่าจะมีวิธีแก้ปัญหา แต่วิธีที่ต้องใช้การวิจัยและการปรับแต่งเล็กน้อย ในขณะที่สัปดาห์นี้ / ถัดไปค่อนข้างยุ่งสำหรับฉันฉันจะแยกวิเคราะห์คำตอบและจะพยายามสร้างสิ่งที่ใช้งานได้แล้วฉันจะแก้ไขคำถามนี้เพื่อสะท้อนสิ่งที่ฉันค้นพบ โปรดกด =)

[แก้ไข]
เรียงคล้ายกับ:
/programming/24157754/make-frames-in-emacs-gui-behaves-like-frames-in-terminal

ฉันจะใช้หลายเฟรมในเซสชัน GUI เดียวด้วย


2
"ฉันต้องการให้แท็บสามารถเก็บหลายบัฟเฟอร์ได้ซึ่งฉันสามารถแยกได้ตามต้องการ" คุณหมายถึงหลายwindowsหรือไม่
Malabarba

1
มันเหมือนว่าฉันต้องการมีแท็บ dyanmic มาก ฉันจะสร้างพวกเขาแล้วเติมพวกเขาด้วยหน้าต่าง นั่นคือฉันต้องการให้แท็บเป็นเฟรม จากนั้นแท็บใหม่จะเป็นเฟรมใหม่ ภายในแต่ละแท็บ / เฟรมฉันสามารถเปิดหน้าต่าง / (บัฟเฟอร์) ที่ต้องการ เป็นไปได้หรือไม่ (เช่นไม่มีชื่อบัฟเฟอร์แบบฮาร์ดโค้ด ฯลฯ )
Leo Ufimtsev

1
มีตัวแปรที่เกี่ยวข้องกับหน้าต่างบางบาน แต่เป็นเดือนหรือสองเดือนตั้งแต่ฉันเห็นเธรดที่พูดถึงมันและฉันไม่รู้ว่ามันเรียกว่าอะไร คุณอาจสนใจใช้ระบบที่คล้ายกับ frame-bufs โดยที่รายการเก็บบัฟเฟอร์ที่เกี่ยวข้องกับเฟรมและรายการนั้นรวมอยู่ในพารามิเตอร์เฟรม คุณสามารถใช้ตัวแปรที่เกี่ยวข้องกับหน้าต่างเฉพาะและทำให้เป็นรายการเพิ่ม / ลบบัฟเฟอร์ออกจากรายการ - รายการนั้นจะเป็นกลุ่มบัฟเฟอร์ที่จะใช้โดย tabbar นี่คือทฤษฎีทั้งหมด แต่ฉันเชื่อว่ามันจะได้ผล
ฏหมาย

1
ฉันคิดว่าคุณอาจหมายถึง: stackoverflow.com/questions/24157754/ … แต่โพสต์นั้นไม่มีคำตอบที่ชัดเจน: - /
Leo Ufimtsev

1
ฉันอยากจะแนะนำให้ดูที่แพคเกจอื่น ๆ
blarghmatey

คำตอบ:


8

แบ่งบัฟเฟอร์ในกลุ่ม

มันเป็นไปได้ด้วย tabbar คุณสามารถเพิ่มกฎให้กับกลุ่มบัฟเฟอร์ในกลุ่ม นี่เป็นตัวอย่างพื้นฐาน:

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

ตัวอย่างกฎ:

  1. รายการชื่อบัฟเฟอร์:
    ((member (buffer-name)
             '("*scratch*" "*Messages*" "*Help*"))
     "Common" ;; this is a group name
     )
  1. เกี่ยวกับบัฟเฟอร์ทั่วไปฉันต้องการใส่ "Common" แต่ละบัฟเฟอร์ที่ชื่อขึ้นต้นด้วยดาว นี่เป็นตัวอย่างการสร้างบัฟเฟอร์สำหรับกฎนี้:
    ((string-equal "*" (substring (buffer-name) 0 1))
     "Common"
     )
  1. นี่คือตัวอย่างของการจัดกลุ่มบัฟเฟอร์ตามโหมดหลัก:
    ((memq major-mode
           '(org-mode text-mode rst-mode))
     "Text"
     )
  1. นี่คือตัวอย่างของการจัดกลุ่มบัฟเฟอร์ตามโหมดที่ได้มาจาก:
    ((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. นี่คือตัวอย่างของการจัดกลุ่มแท็บโดย regexp:
    ((string-match "^__" (buffer-name))
     "Templates"
     )
  1. จัดกลุ่มบัฟเฟอร์ตามโหมดหลัก:
    (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))

เมื่อคุณสร้างกฎแล้วคุณสามารถกด + หรือ - บนแถบแท็บของแถบเพื่อสลับกลุ่มและยัง◀และ▶เพื่อสลับระหว่างบัฟเฟอร์ หรือเพียงแค่ผูก defuns ต่อไปนี้:

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

และย้ายระหว่างแท็บและกลุ่มแท็บด้วยคีย์บอร์ด

ส่วนตัวกลุ่มแท็บฉันเพื่อที่ฉันเห็นสิ่งที่อยู่เปิด ido-switch-bufferแต่นำทางพวกเขาด้วย

สลับระหว่างชุดของกฎ

นอกจากนี้ยังสามารถกำหนดกฎการจัดกลุ่มบัฟเฟอร์ที่แตกต่างกันและวงจรระหว่างเหล่านี้ นี่คือตัวอย่างของการวนรอบระหว่างกฎการจัดกลุ่มบัฟเฟอร์สองชุด:

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

สลับไปมาระหว่างtabbar-buffer-groups-commonและtabbar-buffer-groupsการจัดกลุ่มแท็บ defuns

จัดเรียงบัฟเฟอร์แถบแท็บตามชื่อ

ฉันพบว่ามีประโยชน์ในการจัดเรียง tabbar buffer ตามชื่อ นี่คือวิธีที่จะได้รับ:

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

ขอบคุณสำหรับคำตอบโดยละเอียด ฉันจะพยายามทำตามข้างบนและจะแจ้งให้คุณรู้ ~ ในที่สุด :)
Leo Ufimtsev

แต่ OP ไม่ต้องการ "หนึ่ง tabbar ต่อหน้าต่าง" เขาต้องการหนึ่ง tabbar ต่อเฟรมและแต่ละ tab ใน tabbar ควรแทน "window config" (เช่นหลายหน้าต่าง) แทนที่จะเป็น buffer ดังนั้นการจัดกลุ่มบัฟเฟอร์จึงไม่เป็นปัญหา .
Stefan

6

ATTRIBUTE: การจัดกลุ่มของบัฟเฟอร์ในแต่ละเฟรมเป็นการใช้งานโดยตรงของแนวคิดและเลือกส่วนของรหัสที่พัฒนา / เขียนโดย Alp Aker ในไลบรารี frame-bufs: https://github.com/alpaker/Frame-Bufs

ต่อไปนี้เป็นตัวอย่างของวิธีการใช้ห้องสมุดtabbar.elและกลุ่มแท็บ / บัฟเฟอร์แบบไดนามิกบนพื้นฐานต่อกรอบโดยการเพิ่มแท็บ / บัฟเฟอร์ด้วยC-c C-aหรือลบแท็บ / C-c C-nบัฟเฟอร์ด้วย มีเพียงสอง (2) กลุ่ม - เกี่ยวข้องกับเฟรมปัจจุบัน (เช่น, "A"), และไม่เกี่ยวข้องกับเฟรมปัจจุบัน (เช่น, "N") กลุ่มคือเฟรมภายในซึ่งหมายความว่าแต่ละเฟรมสามารถมีการจัดกลุ่มของตัวเอง C-c C-rการจัดกลุ่มที่กำหนดเองสามารถตั้งค่าด้วย C-tabสลับไปมาระหว่างกลุ่มที่เกี่ยวข้องและไม่เกี่ยวข้องกับ สลับไปยังแท็บถัดไป / buffer M-s-rightในกลุ่มในปัจจุบันมี สลับไปยังแท็บก่อนหน้า / M-s-leftกันชนในกลุ่มในปัจจุบันมี

แท็บ / บัฟเฟอร์สามารถเพิ่มหรือลบโปรแกรมด้วยและmy-add-buffer my-remove-bufferสำหรับตัวอย่างของวิธีการเปิดบัฟเฟอร์บางตัวในเฟรมที่เลือกโปรดดูเธรดที่เกี่ยวข้องที่มีชื่อว่าวิธีการสกัดกั้นไฟล์ก่อนที่จะเปิดและตัดสินใจว่าเฟรมใด : /programming//a/18371427/2112489 ฟังก์ชั่นmy-add-bufferจะต้อง จะรวมอยู่ในสถานที่ที่เหมาะสมของรหัสในลิงค์ด้านบนหากผู้ใช้เลือกที่จะใช้คุณลักษณะนั้น

ผู้ใช้อาจต้องการสร้างรายการในแบบกำหนดเองmode-line-formatที่แสดงชื่อของกลุ่มแท็บปัจจุบันในโหมดบรรทัดโดยรวมตัวอย่างต่อไปนี้: การ (:eval (when tabbar-mode (format "%s" (tabbar-current-tabset t)))) ปรับแต่งโหมดบรรทัดในรายละเอียดเพิ่มเติมอย่างไรก็ตามอยู่นอกเหนือขอบเขตของตัวอย่างนี้

ฟังก์ชั่นtabbar-add-tabได้รับการแก้ไขเพื่อให้ตัวอักษรแท็บ / บัฟเฟอร์

ฟังก์ชั่นtabbar-line-tabได้รับการแก้ไขเพื่อให้ใบหน้าที่แตกต่างกันสี่ (4) ขึ้นอยู่กับสถานการณ์ หากแท็บ / บัฟเฟอร์เชื่อมโยงกับเฟรมและเลือกไว้ให้ใช้tabbar-selected-associatedใบหน้า หากแท็บ / บัฟเฟอร์เชื่อมโยงกับเฟรมและไม่ได้เลือกให้ใช้tabbar-unselected-associatedใบหน้า หากแท็บ / บัฟเฟอร์ไม่ได้เชื่อมโยงกับเฟรมและเลือกไว้ให้ใช้tabbar-selected-unassociatedใบหน้า หากแท็บ / บัฟเฟอร์ไม่เชื่อมโยงกับเฟรมและไม่ถูกเลือกให้ใช้tabbar-unselected-unassociatedใบหน้า

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

ภาพหน้าจอต่อไปนี้แสดงให้เห็นถึงการจัดกลุ่มบัฟเฟอร์ / แท็บที่เป็นไปได้สองรายการ: (1) ทางด้านซ้ายเป็นการจัดกลุ่มของบัฟเฟอร์ / แท็บเหล่านั้นที่เกี่ยวข้องกับเฟรมที่ชื่อSYSTEM[แท็บสีเหลืองและสีขาว] โดยใช้ตัวพิมพ์ใหญ่ "A" โหมดสาย และ (2) ทางด้านขวาเป็นการจัดกลุ่มของบัฟเฟอร์ / แท็บที่ไม่เกี่ยวข้องกับเฟรมที่ชื่อSYSTEM[แท็บสีน้ำเงินและสีแดง] โดยมีตัวพิมพ์ใหญ่ "N" ระบุไว้ในโหมดบรรทัด

ตัวอย่าง


แต่ OP ไม่ต้องการ "หนึ่ง tabbar ต่อหน้าต่าง" เขาต้องการ tabbar หนึ่งอันต่อหนึ่งเฟรมและแต่ละ tab ใน tabbar ควรแทน "window config" (เช่นหลายหน้าต่าง) แทนที่จะเป็น buffer
Stefan

5

ลองเช็คเอาท์ที่หน้าจอแม้ว่ามันจะไม่ได้รวมกลุ่มบัฟเฟอร์

สิ่งที่ต้องทำคือหน้าต่างกลุ่มและให้การเข้าถึงหลายเค้าโครง (แท็บ) ที่คุณสามารถเลื่อนไปมาได้อย่างรวดเร็ว เวิร์กโฟลว์ของฉันมักจะมีรหัส Ruby และการทดสอบที่เกี่ยวข้องในหน้าจอเดียวในขณะที่บันทึกสิ่งที่ต้องทำและ Org ของฉันอยู่ในอีกหน้าหนึ่งและบางทีบัฟเฟอร์รอยขีดข่วนสำหรับการร่างแบบสอบถาม SQL เป็นหนึ่งในสาม สิ่งนี้ทำให้ฉันสามารถกระโดดข้ามระหว่างงานและโครงการได้อย่างง่ายดายแม้ว่าแต่ละหน้าจอจะดึงกลุ่มบัฟเฟอร์เดียวกัน


3

วิธีการเกี่ยวกับปลั๊กอิน, เซ็นทอร์แท็บของฉัน? มันมีตัวเลือกการกำหนดค่ามากมายมันใช้งานได้จริงมันได้รับการสนับสนุนโดยธีมยอดนิยมเช่น Kaolin Themes และโดยรวมแล้วเป็นแพคเกจที่ดูดีและสวยงามมาก (ตามความคิดเห็นของผู้ใช้) มีให้บริการใน MELPA และมีลักษณะดังนี้:

ป้อนคำอธิบายรูปภาพที่นี่


สิ่งนี้น่าจะเป็น "แท็บแต่ละแท็บแสดงถึงบัฟเฟอร์และแต่ละหน้าต่างมีแท็บของตนเอง" ไม่ใช่โซลูชัน
Stefan

ฉันเพิ่งเพิ่มการปรับแต่งเพื่อแสดงกลุ่มแท็บแทนชื่อแท็บดังนั้นในฟังก์ชั่นที่คุณสร้างกฎ (เช่นกลุ่ม elisp และเสียงกระเพื่อมในกลุ่มหนึ่งกลุ่ม c และ c ++ ในอีกกลุ่มและอื่น ๆ ) และในแท็บกลุ่มเหล่านั้นจะแสดง
Emmanuel Bustos

มันยังคงไม่ตอบคำถามซึ่งควรมีหนึ่ง tabbar ต่อเฟรม (มากกว่าต่อหน้าต่าง) และแต่ละแท็บแทนการกำหนดค่าหน้าต่าง
Stefan

ตกลงฉันไม่ได้ undestand ฉันจะตรวจสอบและทำงานกับมัน!
Emmanuel Bustos

0

นี่คือการกำหนดค่าของฉันสำหรับสิ่งที่คุ้มค่า มันมี:

  • การดำเนินงานเมาส์บนแท็บ ( mouse-2ที่จะใกล้ชิดเช่นเดียวกับในเบราว์เซอร์ , mouse-3 ป๊อปเปิดในหน้าต่าง Emacs ใหม่เช่นในi3 )
  • แป้นควบคุม ( M-left& แท็บสวิตช์ขวาเช่นในTMux / หน้าจอ )
  • สี (สอดคล้องกับ "ชุดรูปแบบ Moe / moe-dark" รวมอยู่ด้วย)
  • การจัดกลุ่ม (ปัจจุบัน Emacs *buffers*และ "ปกติ")
  • อัปเดตอัตโนมัติ (พร้อมแพ็กเกจใช้ )

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

ภาคผนวก 1 - ธีม Moe

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

ภาคผนวก 2 - สลับบัฟเฟอร์ 2 ตัวสุดท้าย (แมโคร KB)

(define-key global-map [(control tab)] (kbd "C-x b <return>")) 
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.