upgrading from 21.2.1 to 21.3.50.1

[Eric Twietmeyer]

Hello,

I just upgraded my local emacs to version 21.3.50.1 (which may be
cygwin specific, and which according to
http://www.cygwin.com/ml/cygwin/2005-03/msg00529.html is the same as
22.0.50).

The problem I'm having is that a library I have been carrying around
with me for about 10 years now has stopped working as it used to.  It
is a very small thing, but I don't know enough about debugging elisp to
know how to fix it.  Basically it simply defines 3 sparse keymaps for
the f1, f3, and f4 keys so that you can hit "<f1> <up>" for instance
and move to the window in the current frame "above" the currently
active window.

Now that I have upgraded, the <left> and <right> directions work to
move to, create, or delete a window, but the <up> and <down> directions
don't work.  They don't work if I execute the command directly either,
so somehow things changed internally, it isn't something as simple as
the key bindings being screwed up.

Anyway, here is the code.  Any help would be hugely appreciated.
Thanks so much!

-Eric Twietmeyer


;; Brief-like window manipulation
;; Dan Schmidt, 5/6/96
;;
;; F1 plus a direction goes to that window
;; F3 plus a direction creates a window over there
;; F4 plus a direction deletes that window
;;
;; To do:
;;
;; - F2 window resizing
;;
;; - F1 should work across frames, argh

(defun find-nearby-window (dx dy)
  "Return the nearest window in the direction of DX DY,
or nil if there is none."
  (let* ((this-window (selected-window)) ; current window
         (we (window-edges))            ; its coordinates
         (x0 (nth 0 we))
         (y0 (nth 1 we))
         (x1 (nth 2 we))
         (y1 (nth 3 we))
;        (x (/ (+ x0 x1) 2))            ; x-y location of
;        (y (/ (+ y0 y1) 2))            ; center of window
;        (x x0) (y y0)                  ; I think UL of window works
better
         (x (+ x0 (current-column)))
         (y (+ y0
               (if (= (point) (point-max))
                   (+ 1 (count-lines (window-start) (point)))
               (count-lines (window-start) (+ 1 (point))))))
         (new-window))
    (catch 'look
      (while t
        (setq x (+ x dx))               ; keep moving
        (setq y (+ y dy))
        (setq new-window (window-at x y))
        ;; Don't go off-screen, or into the minibuffer unless it's
active.
        (if (or (null new-window)
                (and (window-minibuffer-p new-window)
                     (not (eq new-window (active-minibuffer-window)))))
            (throw 'look nil))          ; off screen
        (if (not (equal new-window this-window))
            (throw 'look new-window)))))) ; found a new one


(defun move-to-nearby-window (dx dy)
  "Move to the nearest window in the direction of DX DY if possible."
  (let ((new-window (find-nearby-window dx dy)))
    (if new-window
        (select-window new-window))))

(defun delete-nearby-window (dx dy)
  "Delete the nearest window in the direction of DX DY if possible."
  (let ((new-window (find-nearby-window dx dy)))
    (if new-window
        (delete-window new-window))))



(defun create-new-window-up ()
  "Create a new window above the current one."
  (interactive)
  (let ((this-window (selected-window))
        (new-window (split-window-vertically)))
    ;; We've split the window vertically, now make sure that
    ;; the new window is above the current one.
    (if (< (nth 1 (window-edges new-window))
           (nth 1 (window-edges this-window)))
        (select-window new-window))))

(defun create-new-window-down ()
  "Create a new window below the current one."
  (interactive)
  (let ((this-window (selected-window))
        (new-window (split-window-vertically)))
    (if (> (nth 1 (window-edges new-window))
           (nth 1 (window-edges this-window)))
        (select-window new-window))))

(defun create-new-window-left ()
  "Create a new window to the left of the current one."
  (interactive)
  (let ((this-window (selected-window))
        (new-window (split-window-horizontally)))
    (if (< (nth 0 (window-edges new-window))
           (nth 0 (window-edges this-window)))
        (select-window new-window))))

(defun create-new-window-right ()
  "Create a new window to the right of the current one."
  (interactive)
  (let ((this-window (selected-window))
        (new-window (split-window-horizontally)))
    (if (> (nth 0 (window-edges new-window))
           (nth 0 (window-edges this-window)))
        (select-window new-window))))



(defun move-up-to-window ()
  "Move up to the next window."
  (interactive)
  (move-to-nearby-window 0 -1))

(defun move-down-to-window ()
  "Move down to the next window."
  (interactive)
  (move-to-nearby-window 0 1))

(defun move-left-to-window ()
  "Move left to the next window."
  (interactive)
  (move-to-nearby-window -1 0))

(defun move-right-to-window ()
  "Move right to the next window."
  (interactive)
  (move-to-nearby-window 1 0))



(defun delete-up-window ()
  "Delete the window above this one."
  (interactive)
  (delete-nearby-window 0 -1))

(defun delete-down-window ()
  "Delete the window below this one."
  (interactive)
  (delete-nearby-window 0 1))

(defun delete-left-window ()
  "Delete the window to the left of this one."
  (interactive)
  (delete-nearby-window -1 0))

(defun delete-right-window ()
  "Delete the window to the right of this one."
  (interactive)
  (delete-nearby-window 1 0))


(defvar f1-map (make-sparse-keymap) "Keymap for F1.")
(define-key global-map [f1]       f1-map)

(define-key f1-map     [up]      'move-up-to-window)
(define-key f1-map     [down]    'move-down-to-window)
(define-key f1-map     [left]    'move-left-to-window)
(define-key f1-map     [right]   'move-right-to-window)


(defvar f3-map (make-sparse-keymap) "Keymap for F3.")
(define-key global-map [f3]       f3-map)

(define-key f3-map     [up]      'create-new-window-up)
(define-key f3-map     [down]    'create-new-window-down)
(define-key f3-map     [left]    'create-new-window-left)
(define-key f3-map     [right]   'create-new-window-right)


(defvar f4-map (make-sparse-keymap) "Keymap for F4.")
(define-key global-map [f4]       f4-map)

(define-key f4-map     [up]      'delete-up-window)
(define-key f4-map     [down]    'delete-down-window)
(define-key f4-map     [left]    'delete-left-window)
(define-key f4-map     [right]   'delete-right-window)