Re: master 6a2ee981c3: Add new functions for splitting the root window

[Gregory Heytings <gregory@heytings.org>]

[-- Attachment #1: Type: text/plain, Size: 1811 bytes --]


>
> While I understand the desire to follow the `C-x 2` and `C-x 3` 
> tradition, these numbers don't actually carry much useful intuition. How 
> 'bout `C-x w -` and `C-x w |` instead?
>
> Of course, it'd also be nice to bring together/closer the root and 
> non-root variants of those operations, but I have no good suggestion 
> here, other than to suggest to use a new command which doesn't accept a 
> numeric argument at all and only uses `C-u` to choose between a root 
> split and non-root split.  That's because I personally never use that 
> numeric argument, and prefer to resize the windows afterwards rather 
> than try to guess sizes beforehand.
>

Fully agreed.  I we're going to put window commands on C-x w, I thought I 
might share the part of my configuration that deals with windows (see 
attached), which I adapted to that new prefix.

     C-x w | split-window-right
C-u C-x w | split-root-window-right
     C-x w - split-window-below
C-u C-x w - split-root-window-below
     C-x w d delete-window
     C-x w o delete-other-windows (mnemonic "only")
     C-x w h window-height-adjust with + - = (repeatable)
     C-x w w window-width-adjust with + - = (repeatable)
     C-x w f tear-off-window
     C-x w m maximize-window-toggle
C-u C-x w m minimize-window
     C-x w s window-toggle-side-windows
     C-x w ! window-toggle-dedicated
     C-x w b balance-windows
C-u C-x w b balance-windows-area
     C-x w c window-configuration
             left (winner-undo) right (winner-redo) (repeatable)
             s (save in register) r (restore from register)
     C-x w n/p select-next-window select-previous-window (repeatable)
     C-x w up/down/left/right select-window-{up,down,left,right} (repeatable)
     C-x w M-up/M-down/M-left/M-right swap-windows-{up,down,left,right} (repeatable)

[-- Attachment #2: window-commands.el --]
[-- Type: text/plain, Size: 5878 bytes --]

(defun split-window-or-root-window-right (&optional arg)
  (interactive "P")
  (if arg (split-root-window-right) (split-window-right)))
(defun split-window-or-root-window-below (&optional arg)
  (interactive "P")
  (if arg (split-root-window-below) (split-window-below)))
(global-set-key (kbd "C-x w |") 'split-window-or-root-window-right)
(global-set-key (kbd "C-x w -") 'split-window-or-root-window-below)
(global-set-key (kbd "C-x w d") 'delete-window)
(global-set-key (kbd "C-x w o") 'delete-other-windows)
(defun fit-window-to-buffer-horizontally ()
  (interactive)
  (let ((fit-window-to-buffer-horizontally 'only))
    (fit-window-to-buffer)
    (enlarge-window-horizontally 2)))
(defun window-width-adjust ()
  (interactive)
  (let ((map (make-sparse-keymap)))
    (define-key map "+" 'enlarge-window-horizontally)
    (define-key map "-" 'shrink-window-horizontally)
    (define-key map "=" 'fit-window-to-buffer-horizontally)
    (set-transient-map map t)))
(defun window-height-adjust ()
  (interactive)
  (let ((map (make-sparse-keymap)))
    (define-key map "+" 'enlarge-window)
    (define-key map "-" 'shrink-window)
    (define-key map "=" 'fit-window-to-buffer)
    (set-transient-map map t)))
(global-set-key (kbd "C-x w w") 'window-width-adjust)
(global-set-key (kbd "C-x w h") 'window-height-adjust)
(global-set-key (kbd "C-x w f") 'tear-off-window)
(defun maximize-window-toggle ()
  (let* ((wc (frame-parameter nil 'window-maximized)))
    (if wc
	(progn
	  (set-window-configuration wc)
	  (set-frame-parameter nil 'window-maximized nil))
      (set-frame-parameter nil 'window-maximized
			   (current-window-configuration))
      (delete-other-windows))))
(defun maximize-or-minimize-window (&optional arg)
  (interactive "P")
  (if arg
      (minimize-window)
    (maximize-window-toggle)))
(global-set-key (kbd "C-x w m") 'maximize-or-minimize-window)
(global-set-key (kbd "C-x w s") 'window-toggle-side-windows)
(defun windows-balance (&optional arg)
  (interactive "P")
  (if arg
      (balance-windows-area)
    (balance-windows)))
(global-set-key (kbd "C-x w b") 'windows-balance)
(defun window-toggle-dedicated ()
  (interactive)
  (set-window-dedicated-p nil (not (window-dedicated-p)))
  (message "Window is %sdedicated" (if (window-dedicated-p) "" "not ")))
(global-set-key (kbd "C-x w !") 'window-toggle-dedicated)
(defun window-configuration-from-register (register)
  (interactive
   (list (register-read-with-preview "Window configuration from register: ")))
  (let ((contents (get-register register)))
    (if (and (consp contents)
	     (window-configuration-p (car contents))
	     (markerp (cadr contents)))
      (jump-to-register register)
    (user-error "Register `%c' doesn't contain a window configuration"
		register))))
(defun window-configuration ()
  (interactive)
  (if (and (boundp winner-mode) winner-mode)
      (let ((map (make-sparse-keymap)))
	(define-key map [left] 'winner-undo)
	(define-key map [right] 'winner-redo)
	(define-key map "s" 'window-configuration-to-register)
	(define-key map "r" 'window-configuration-from-register)
	(set-transient-map map t))
    (user-error "Winner mode is not enabled")))
(global-set-key (kbd "C-x w c") 'window-configuration)
(defun select-next-window-do ()
  (interactive)
  (select-window (next-window)))
(defun select-previous-window-do ()
  (interactive)
  (select-window (previous-window)))
(defun select-window-enter ()
  (let ((map (make-sparse-keymap)))
    (define-key map "n" 'select-next-window-do)
    (define-key map "p" 'select-previous-window-do)
    (set-transient-map map t)))
(defun select-next-window ()
  (interactive)
  (select-next-window-do)
  (select-window-enter))
(defun select-previous-window ()
  (interactive)
  (select-previous-window-do)
  (select-window-enter))
(global-set-key (kbd "C-x w n") 'select-next-window)
(global-set-key (kbd "C-x w p") 'select-previous-window)
(defun windmove-enter (fun)
  (if windmove-mode
      (let ((map (make-sparse-keymap)))
	(define-key map [up] 'windmove-up)
	(define-key map [down] 'windmove-down)
	(define-key map [left] 'windmove-left)
	(define-key map [right] 'windmove-right)
	(define-key map [M-up] 'windmove-swap-states-up)
	(define-key map [M-down] 'windmove-swap-states-down)
	(define-key map [M-left] 'windmove-swap-states-left)
	(define-key map [M-right] 'windmove-swap-states-right)
	(call-interactively fun)
	(set-transient-map map t))
    (user-error "Windmove mode is not enabled")))
(defun select-window-up (&optional arg)
  (interactive "P")
  (windmove-enter 'windmove-up))
(defun select-window-down (&optional arg)
  (interactive "P")
  (windmove-enter 'windmove-down))
(defun select-window-left (&optional arg)
  (interactive "P")
  (windmove-enter 'windmove-left))
(defun select-window-right (&optional arg)
  (interactive "P")
  (windmove-enter 'windmove-right))
(defun swap-windows-up (&optional arg)
  (interactive)
  (windmove-enter 'windmove-swap-states-up))
(defun swap-windows-down (&optional arg)
  (interactive)
  (windmove-enter 'windmove-swap-states-down))
(defun swap-windows-left (&optional arg)
  (interactive)
  (windmove-enter 'windmove-swap-states-left))
(defun swap-windows-right (&optional arg)
  (interactive)
  (windmove-enter 'windmove-swap-states-right))
(global-set-key (kbd "C-x w <up>") 'select-window-up)
(global-set-key (kbd "C-x w <down>") 'select-window-down)
(global-set-key (kbd "C-x w <left>") 'select-window-left)
(global-set-key (kbd "C-x w <right>") 'select-window-right)
(global-set-key (kbd "C-x w M-<up>") 'swap-windows-up)
(global-set-key (kbd "C-x w M-<down>") 'swap-windows-down)
(global-set-key (kbd "C-x w M-<left>") 'swap-windows-left)
(global-set-key (kbd "C-x w M-<right>") 'swap-windows-right)