Commutazione tra layout di finestre

Quando configuro un layout personalizzato e poi ho solo bisogno di cercare temporaneamente un file a schermo intero e una volta che voglio quel layout indietro, ho bisogno di ridisegnarlo manualmente.

Vorrei un codice plugin / elisp per salvare i miei layout e poter passare da un layout salvato all'altro.

AGGIORNARE

Grazie a tutti.

il suggerimento di usare la modalità vincitore è davvero bello e l'ho fatto funzionare in tempi zero.

wasamasa mi ha suggerito un sacco di fantastici plugin di cui non ho mai sentito parlare e ha fornito informazioni su come usare i registri.

Jordon Biondo mi ha spiegato come usare i registri e questa roba è in realtà ciò che volevo nel modo più semplice.

Grazie a tutti.

Il modo integrato per farlo è con i registri.

Ad esempio, utilizzare C-xrwaper salvare la configurazione della finestra corrente per registrare a.

Quindi è possibile utilizzare il binding incorporato C-x1per l'esecuzionedelete-other-windows

dopo aver esaminato il singolo file, utilizzare C-xrjaper tornare alla configurazione della finestra salvata nel registro a.

In breve:

C-xrwa (salva la configurazione nel registro)

C-x1 (elimina altre finestre)

C-xrja (riapplica la configurazione della finestra salvata)

Trovo che i registri siano ingombranti, ma uso uno stack di configurazione della finestra personalizzato per gestire le mie configurazioni.

Ho due associazioni che spingono la configurazione corrente nello stack e pop e applicano la configurazione superiore.

Quindi, nel tuo scenario, eseguivo il mio push binding, quindi Cx 1, quindi eseguivo il mio pop binding.

Ecco il codice:

(defvar winstack-stack '()
  "A Stack holding window configurations.
Use `winstack-push' and
`winstack-pop' to modify it.")

(defun winstack-push()
  "Push the current window configuration onto `winstack-stack'."
  (interactive)
  (if (and (window-configuration-p (first winstack-stack))
         (compare-window-configurations (first winstack-stack) (current-window-configuration)))
      (message "Current config already pushed")
    (progn (push (current-window-configuration) winstack-stack)
           (message (concat "pushed " (number-to-string
                                       (length (window-list (selected-frame)))) " frame config")))))

(defun winstack-pop()
  "Pop the last window configuration off `winstack-stack' and apply it."
  (interactive)
  (if (first winstack-stack)
      (progn (set-window-configuration (pop winstack-stack))
             (message "popped"))
    (message "End of window stack")))

È quindi possibile associare winstack-pusha qualcosa come C-cC-u, e winstack-popdi C-cC-osaltare facilmente intorno.

Io uso winner-mode. Ecco la mia configurazione:

(winner-mode)
(global-set-key [f7] 'winner-undo)
(global-set-key [C-f7] 'winner-redo)
(global-set-key [f9] 'delete-other-windows)
(global-set-key [C-f9] 'delete-window)

Non so se c'è un modo per aggiungere un layout a segnalibri o qualcosa del genere, ma essere in grado di tornare continuamente al layout precedente è abbastanza per me.

Emacs offre registri per salvare e applicare dati come l'attuale configurazione della finestra, questo può essere fatto con C-x r we C-x r j. Tuttavia, questo approccio diventa ingombrante poiché è necessario ricordare i registri delle finestre.

Ci sono alcuni pacchetti per migliorare questo. iregister rende questa funzionalità di base più controllabile e interattiva. Gli altri che conosco lo usano senza influire sui registri, come elscreen e escreen che usano la barra di intestazione per visualizzare le schede. gruppi di lavoro e gruppi di lavoro2 sono due approcci più recenti e più ampi a questo problema. Personalmente neanche a me piaceva e quindi ho scritto il mio che è da qualche parte nel mezzo e, si spera, ha meno bug e complessità.

È possibile salvare il layout della finestra corrente in un registro e quindi ripristinarlo utilizzando jump-to-register. Il comando window-configuration-to-registerè associato per C-x r wimpostazione predefinita.

Ad esempio, quando le finestre sono disposte in modo utile, è possibile salvarle per registrarle iutilizzando: C-x r w ie ripristinare il layout in un secondo momento C-x r j i.

Zygospore fornisce una soluzione rapida per la situazione in cui hai più finestre aperte e vuoi massimizzarne temporaneamente una. Modifica il comportamento di C-x 1. Quando hai più finestre aperte, si comporta come l'impostazione predefinita delete-other-windowse rimuove tutte le finestre tranne quella che stai visualizzando. Quando lo colpisci di nuovo, ripristina le altre finestre.

La modalità Winner offre una soluzione più generale, ma zygospore è ottimo per ingrandire temporaneamente una singola finestra in una cornice. La cosa migliore è che non utilizza nuovi tasti di scelta rapida - si ridefinisce C-x 1in modo molto intuitivo, quindi non ci sono nuovi collegamenti da imparare.

Questa è una domanda interessante Diversi anni fa ho studiato tutte le soluzioni. Solo workgroups2.el è abbastanza pesante da coprire tutti i casi angolari.

Ma l'interfaccia utente di workgroups2 è un disastro. Ad esempio, se abiliti la modalità gruppo di lavoro (come suggerito dal suo README), il layout precedente verrà automaticamente caricato all'avvio di emacs. Ciò rende l'avvio estremamente lento OGNI volta.

La mia soluzione è di trattare workgroups2 come una raccolta di API anziché uno strumento utilizzabile pronto all'uso. Quindi cambio l'interazione dell'interfaccia utente predefinita utilizzando la modalità ivy ( https://github.com/abo-abo/swiper ) da @ abo-abo

Attivare la finestra intera è semplice, utilizzare le API dalla modalità vincitore è sufficiente.

Ecco il codice completo (io uso solo M-x toggle-full-window, M-x wg-create-workgroupe M-x my-wg-switch-workgroup, hai anche bisogno di installare swiper, come ho detto sopra),

(defun toggle-full-window()
  "Toggle the full view of selected window"
  (interactive)
  ;; @see http://www.gnu.org/software/emacs/manual/html_node/elisp/Splitting-Windows.html
  (if (window-parent)
      (delete-other-windows)
    (winner-undo)))

(setq wg-use-default-session-file nil)
;; don't open last workgroup automatically in `wg-open-session',
;; I only want to check available workgroups! Nothing more.
(setq wg-load-last-workgroup nil)
(setq wg-open-this-wg nil)

;(workgroups-mode 1) ; put this one at the bottom of .emacs
;; by default, the sessions are saved in "~/.emacs_workgroups"
(autoload 'wg-create-workgroup "workgroups2" nil t)

(defun my-wg-switch-workgroup ()
  (interactive)
  (let (group-names selected-group)
    (unless (featurep 'workgroups2)
      (require 'workgroups2))
    (setq group-names
          (mapcar (lambda (group)
                    ;; re-shape list for the ivy-read
                    (cons (wg-workgroup-name group) group))
                  (wg-session-workgroup-list (read (f-read-text (file-truename wg-session-file))))))
    (ivy-read "work groups" group-names
              :action (lambda (group)
                        (wg-find-session-file wg-default-session-file)
                        (wg-switch-to-workgroup group)))))

(eval-after-load 'workgroups2
  '(progn
     ;; make sure wg-create-workgroup always success
     (defadvice wg-create-workgroup (around wg-create-workgroup-hack activate)
       (unless (file-exists-p (wg-get-session-file))
         (wg-reset t)
         (wg-save-session t))

       (unless wg-current-session
         ;; code extracted from `wg-open-session'.
         ;; open session but do NOT load any workgroup.
         (let ((session (read (f-read-text (file-truename wg-session-file)))))
           (setf (wg-session-file-name session) wg-session-file)
           (wg-reset-internal (wg-unpickel-session-parameters session))))
       ad-do-it
       ;; save the session file in real time
       (wg-save-session t))

     (defadvice wg-reset (after wg-reset-hack activate)
       (wg-save-session t))

     ;; I'm fine to to override the original workgroup
     (defadvice wg-unique-workgroup-name-p (around wg-unique-workgroup-name-p-hack activate)
       (setq ad-return-value t))))