Emacs, switch to previous window

Question

In Emacs, C-x o takes me to the next window.

What keyboard macro takes me to the previous window in Emacs?

Answer 1

The fastest method I have found for switching to the previous window is to mash a couple keys together as a "key-chord". The following lets you use your left pinky+ring fingers together to go to previous window:

(key-chord-define-global "qw" 'prev-window)
(key-chord-define-global "'y" 'other-window) ; bonus for my colemak, adjust otherwise
(key-chord-define-global ";'" 'other-window) ; probably normal

(This is possible because Emacs key chords are order independent, meaning that qw is the same as wq.)

Answer 2

Personally I prefer to use window-number.el

To select a different window, use Ctrl-x, Ctrl-j n

Where n is the number of the window, the modeline of each window shows it's number, as shown in the screenshot.

Just download window-number.el, place it in your emacs load-path and use the following in your .emacs

 (autoload 'window-number-mode "window-number"
   "A global minor mode that enables selection of windows according to
 numbers with the C-x C-j prefix.  Another mode,
 `window-number-meta-mode' enables the use of the M- prefix."
   t)

There's another similar mode called switch-window.el which gives you big numbers in the windows... (pressing the number switches the window and reverts the display.)

_{(source: tapoueh.org)}

Answer 3

(global-set-key (kbd "C-x a") 'ace-swap-window)  
(global-set-key (kbd "C-x q") 'ace-select-window)

download ace-window from the melpa repo if you don't know how to do that
put this in your .emacs file if you don't have one create it 

(package-initialize)                                                                                                                                                                     

(require 'package)                                                                                                                                                                       
(add-to-list 'package-archives '("melpa" , "http://melpa.org/packages/"))                                                                                                                

(package-initialize) 

then "m-x list-packages"

Answer 4

(global-unset-key (kbd "M-j"))
(global-unset-key (kbd "M-k"))
(global-set-key (kbd "M-j") (lambda () (interactive) (other-window 1)))
(global-set-key (kbd "M-k") (lambda () (interactive) (other-window -1)))

altj and altk will cycle through your visibles buffers. Forwards and backwards, to be exact.

Answer 5

In reference to Nate's answer, I replaced the arrow keys to use the traditional p for going up, n for going down, f for going right and b for going left. I also replaced the Ctrl with Super key as C-p, C-n, C-f and C-b are the default movement keys. This combination with M lets you jump characters and lines instead of going through just one by one after each keystroke. Thus Super key felt the best choice to keep it an easy key binding. Also, now you don't have to take your hand off the home row any more!

(global-set-key (kbd "s-p") `windmove-up)
(global-set-key (kbd "s-n") `windmove-down)
(global-set-key (kbd "s-f") `windmove-right)
(global-set-key (kbd "s-b") `windmove-left)

Hope it helps!

Answer 6

M-n and M-p makes the most sense to me, since they are analogous to C-n (next-line) and C-p (previous-line):

(define-key global-map (kbd "M-p") 'previous-multiframe-window)
(define-key global-map (kbd "M-n") 'other-window)

(inspired by to this and that)

Answer 7

There are some very good and complete answers here, but to answer the question in a minimalist fashion:

 (defun prev-window ()
   (interactive)
   (other-window -1))

 (define-key global-map (kbd "C-x p") 'prev-window)

Answer 8

That'd be C-- C-x o

In other words, C-x o with an argument of -1. You can specify how many windows to move by inserting a numeric argument between C-u and the command, as in C-u 2 C-x o. (C-- is a shortcut for C-u - 1)

Answer 9

Just to add to @Nate, @aspirin and @Troydm's answer I find this to be a very helpful addition if you decide to bind the windmove commands to whatever key combination you choose:

(setq windmove-wrap-around t)

With the default configuration you will get an error when you get to attempt to move to a window that doesn't exist which becomes kind of annoying after a while. However when windmove-wrap-around is set then attempting to move off the bottom of the frame for example will instead select the topmost window in the frame. This may be a more intuitive behaviour for you.

Answer 10

There is already a package that lets you switch windows by using M-. check this website. Add this to your init file:

(require 'windmove)
(windmove-default-keybindings 'meta) ;; or use 'super to use windows key instead alt

Answer 11

If you work with multiple emacs windows (>3) a lot and you will want to save some keystrokes add this to your init file and you'll be better off:

(defun frame-bck()
  (interactive)
  (other-window-or-frame -1)
)
(define-key (current-global-map) (kbd "M-o") 'other-window-or-frame)
(define-key (current-global-map) (kbd "M-O") 'frame-bck)

Now just cycle quickly thru the windows with M-o

Answer 12

Base on idea from @Nate but slightly modified to support backwards cycling between windows

;; Windows Cycling
(defun windmove-up-cycle()
  (interactive)
  (condition-case nil (windmove-up)
    (error (condition-case nil (windmove-down)
         (error (condition-case nil (windmove-right) (error (condition-case nil (windmove-left) (error (windmove-up))))))))))

(defun windmove-down-cycle()
  (interactive)
  (condition-case nil (windmove-down)
    (error (condition-case nil (windmove-up)
         (error (condition-case nil (windmove-left) (error (condition-case nil (windmove-right) (error (windmove-down))))))))))

(defun windmove-right-cycle()
  (interactive)
  (condition-case nil (windmove-right)
    (error (condition-case nil (windmove-left)
         (error (condition-case nil (windmove-up) (error (condition-case nil (windmove-down) (error (windmove-right))))))))))

(defun windmove-left-cycle()
  (interactive)
  (condition-case nil (windmove-left)
    (error (condition-case nil (windmove-right)
         (error (condition-case nil (windmove-down) (error (condition-case nil (windmove-up) (error (windmove-left))))))))))

(global-set-key (kbd "C-x <up>") 'windmove-up-cycle)
(global-set-key (kbd "C-x <down>") 'windmove-down-cycle)
(global-set-key (kbd "C-x <right>") 'windmove-right-cycle)
(global-set-key (kbd "C-x <left>") 'windmove-left-cycle)

Answer 13

You might also want to try using windmove which lets you navigate to the window of your choice based on geometry. I have the following in my .emacs file to change windows using C-x arrow-key.

(global-set-key (kbd "C-x <up>") 'windmove-up)
(global-set-key (kbd "C-x <down>") 'windmove-down)
(global-set-key (kbd "C-x <right>") 'windmove-right)
(global-set-key (kbd "C-x <left>") 'windmove-left)