Cambiar entre diseños de ventana

Cuando configuro un diseño personalizado y luego solo necesito mirar temporalmente en un archivo a pantalla completa y una vez que quiero recuperar ese diseño, necesito volver a aplicarlo manualmente.

Me gustaría un código de complemento / elisp para guardar mis diseños y poder cambiar entre diseños guardados.

ACTUALIZAR

Gracias a todos.

La sugerencia abo-abo para usar el modo ganador es realmente agradable y lo hice funcionar en cero tiempo.

wasamasa sugirió un montón de excelentes complementos que nunca había escuchado y proporcionó información sobre cómo usar los registros.

Jordon Biondo me explicó cómo usar los registros y esto es en realidad lo que quería de la manera más simple.

Gracias a todos.

La forma integrada de hacer esto es con registros.

Por ejemplo, use C-xrwapara guardar la configuración de ventana actual para registrar a.

Luego puede usar el enlace incorporado C-x1para ejecutardelete-other-windows

una vez que haya terminado de mirar el archivo único, use C-xrjapara volver a la configuración de ventana guardada en el registro a.

En breve:

C-xrwa (guardar configuración en el registro)

C-x1 (eliminar otras ventanas)

C-xrja (vuelva a aplicar la configuración de la ventana guardada)

Sin embargo, creo que los registros son difíciles de manejar, uso una pila de configuración de ventana personalizada para administrar mis configuraciones.

Tengo dos enlaces que empujan la configuración actual a la pila, y hacen estallar y aplican la configuración superior.

Entonces, en su escenario, realizaría mi enlace push, luego Cx 1, luego realizaría mi enlace pop.

Aquí está el código:

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

A continuación, puede unirse winstack-pusha algo así C-cC-u, y winstack-popal C-cC-osaltar fácilmente alrededor.

Yo uso winner-mode. Aquí está mi configuración:

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

No sé si hay una manera de marcar un diseño o algo así, pero ser capaz de cambiar continuamente al diseño anterior es suficiente para mí.

Emacs ofrece registros para guardar y aplicar datos como la configuración de su ventana actual, esto se puede hacer con C-x r wy C-x r j. Sin embargo, este enfoque se vuelve difícil de manejar ya que debe recordar los registros de la ventana.

Hay algunos paquetes para mejorar esto. iregister hace que esta característica básica sea más inspeccionable e interactiva. Los otros que conozco lo usan sin afectar los registros, como elscreen y escreen que usan la barra de encabezado para mostrar las pestañas. Los grupos de trabajo y los grupos de trabajo2 son dos enfoques más nuevos y más amplios para este problema. Personalmente, tampoco me gustó y, por lo tanto, escribí el mío que está en algún punto intermedio y es de esperar que tenga menos errores y complejidad.

Puede guardar el diseño de la ventana actual en un registro y luego restaurarlo usando jump-to-register. El comando window-configuration-to-registerestá vinculado C-x r wde forma predeterminada.

Por ejemplo, cuando tiene sus ventanas organizadas de una manera útil, puede guardarlas para registrarlas iusando: C-x r w iy restaurar el diseño más tarde usando C-x r j i.

Zygospore proporciona una solución rápida para la situación en la que tiene varias ventanas abiertas y desea maximizar temporalmente una de ellas. Modifica el comportamiento de C-x 1. Cuando tiene varias ventanas abiertas, se comporta como el predeterminado delete-other-windowsy elimina todas las ventanas excepto la que está viendo. Cuando lo golpeas de nuevo, restaura las otras ventanas.

El modo ganador proporciona una solución más general, pero zygospore es excelente para hacer zoom temporalmente en una sola ventana en un marco. Lo mejor es que no utiliza ninguna combinación de teclas nueva: se redefine C-x 1de una manera muy intuitiva, por lo que no hay nuevas combinaciones para aprender.

Esta es una pregunta interesante. Hace varios años investigué todas las soluciones. Solo workgroups2.el es lo suficientemente pesado como para cubrir todas las esquinas.

Pero la interfaz de usuario de workgroups2 es un desastre. Por ejemplo, si habilita el modo de grupo de trabajo (como sugiere el archivo README), el diseño anterior se cargará automáticamente durante el inicio de emacs. Eso hace que el inicio sea extremadamente lento CADA vez.

Mi solución es tratar los grupos de trabajo2 como una colección de API en lugar de una herramienta utilizable lista para usar. Así que cambio su interacción de UI predeterminada usando el modo ivy ( https://github.com/abo-abo/swiper ) de @ abo-abo

Alternar la ventana completa es fácil, usar las API del modo ganador es suficiente.

Aquí está el código completo (solo uso M-x toggle-full-window, M-x wg-create-workgroupy M-x my-wg-switch-workgrouptambién necesita instalar swiper, como mencioné anteriormente),

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