Commit 614b38a9 authored by Eli Zaretskii's avatar Eli Zaretskii
Browse files

(bw-get-tree, bw-get-tree-1, bw-find-tree-sub)

(bw-find-tree-sub-1, bw-l, bw-t, bw-r, bw-b, bw-dir, bw-eqdir)
(bw-refresh-edges, bw-adjust-window, bw-balance-sub): New functions.
(balance-windows): Rewrite using the above new functions.
parent a8514f71
2005-12-10 Lennart Borgman <lennart.borgman.073@student.lu.se>
* window.el (bw-get-tree, bw-get-tree-1, bw-find-tree-sub)
(bw-find-tree-sub-1, bw-l, bw-t, bw-r, bw-b, bw-dir, bw-eqdir)
(bw-refresh-edges, bw-adjust-window, bw-balance-sub): New functions.
(balance-windows): Rewrite using the above new functions.
2005-12-10 David Koppelman <koppel@ece.lsu.edu> 2005-12-10 David Koppelman <koppel@ece.lsu.edu>
   
* hi-lock.el: (hi-lock-mode) Renamed from hi-lock-buffer-mode; * hi-lock.el: (hi-lock-mode) Renamed from hi-lock-buffer-mode;
......
...@@ -228,75 +228,201 @@ If WINDOW is nil or omitted, it defaults to the currently selected window." ...@@ -228,75 +228,201 @@ If WINDOW is nil or omitted, it defaults to the currently selected window."
(or (= (nth 2 edges) (nth 2 (window-edges (previous-window)))) (or (= (nth 2 edges) (nth 2 (window-edges (previous-window))))
(= (nth 0 edges) (nth 0 (window-edges (next-window)))))))) (= (nth 0 edges) (nth 0 (window-edges (next-window))))))))
(defun balance-windows () ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
"Make all visible windows the same height (approximately)." ;;; `balance-windows' subroutines using `window-tree'
;;; Translate from internal window tree format
(defun bw-get-tree (&optional window-or-frame)
"Get a window split tree in our format.
WINDOW-OR-FRAME must be nil, a frame, or a window. If it is nil,
then the whole window split tree for `selected-frame' is returned.
If it is a frame, then this is used instead. If it is a window,
then the smallest tree containing that window is returned."
(when window-or-frame
(unless (or (framep window-or-frame)
(windowp window-or-frame))
(error "Not a frame or window: %s" window-or-frame)))
(let ((subtree (bw-find-tree-sub window-or-frame)))
(if (integerp subtree)
nil
(bw-get-tree-1 subtree))))
(defun bw-get-tree-1 (split)
(if (windowp split)
split
(let ((dir (car split))
(edges (car (cdr split)))
(childs (cdr (cdr split))))
(list
(cons 'dir (if dir 'ver 'hor))
(cons 'b (nth 3 edges))
(cons 'r (nth 2 edges))
(cons 't (nth 1 edges))
(cons 'l (nth 0 edges))
(cons 'childs (mapcar #'bw-get-tree-1 childs))))))
(defun bw-find-tree-sub (window-or-frame &optional get-parent)
(let* ((window (when (windowp window-or-frame) window-or-frame))
(frame (when (windowp window) (window-frame window)))
(wt (car (window-tree frame))))
(when (< 1 (length (window-list frame 0)))
(if window
(bw-find-tree-sub-1 wt window get-parent)
wt))))
(defun bw-find-tree-sub-1 (tree win &optional get-parent)
(unless (windowp win) (error "Not a window: %s" win))
(if (memq win tree)
(if get-parent
get-parent
tree)
(let ((childs (cdr (cdr tree)))
child
subtree)
(while (and childs (not subtree))
(setq child (car childs))
(setq childs (cdr childs))
(when (and child (listp child))
(setq subtree (bw-find-tree-sub-1 child win get-parent))))
(if (integerp subtree)
(progn
(if (= 1 subtree)
tree
(1- subtree)))
subtree
))))
;;; Window or object edges
(defun bw-l(obj)
"Left edge of OBJ."
(if (windowp obj) (nth 0 (window-edges obj)) (cdr (assq 'l obj))))
(defun bw-t(obj)
"Top edge of OBJ."
(if (windowp obj) (nth 1 (window-edges obj)) (cdr (assq 't obj))))
(defun bw-r(obj)
"Right edge of OBJ."
(if (windowp obj) (nth 2 (window-edges obj)) (cdr (assq 'r obj))))
(defun bw-b(obj)
"Bottom edge of OBJ."
(if (windowp obj) (nth 3 (window-edges obj)) (cdr (assq 'b obj))))
;;; Split directions
(defun bw-dir(obj)
"Return window split tree direction if OBJ.
If OBJ is a window return 'both. If it is a window split tree
then return its direction."
(if (symbolp obj)
obj
(if (windowp obj)
'both
(let ((dir (cdr (assq 'dir obj))))
(unless (memq dir '(hor ver both))
(error "Can't find dir in %s" obj))
dir))))
(defun bw-eqdir(obj1 obj2)
"Return t if window split tree directions are equal.
OBJ1 and OBJ2 should be either windows or window split trees in
our format. The directions returned by `bw-dir' are compared and
t is returned if they are `eq' or one of them is 'both."
(let ((dir1 (bw-dir obj1))
(dir2 (bw-dir obj2)))
(or (eq dir1 dir2)
(eq dir1 'both)
(eq dir2 'both))))
;;; Building split tree
(defun bw-refresh-edges(obj)
"Refresh the edge information of OBJ and return OBJ."
(unless (windowp obj)
(let ((childs (cdr (assq 'childs obj)))
(ol 1000)
(ot 1000)
(or -1)
(ob -1))
(dolist (o childs)
(when (> ol (bw-l o)) (setq ol (bw-l o)))
(when (> ot (bw-t o)) (setq ot (bw-t o)))
(when (< or (bw-r o)) (setq or (bw-r o)))
(when (< ob (bw-b o)) (setq ob (bw-b o))))
(setq obj (delq 'l obj))
(setq obj (delq 't obj))
(setq obj (delq 'r obj))
(setq obj (delq 'b obj))
(add-to-list 'obj (cons 'l ol))
(add-to-list 'obj (cons 't ot))
(add-to-list 'obj (cons 'r or))
(add-to-list 'obj (cons 'b ob))
))
obj)
;;; Balance windows
(defun balance-windows(&optional window-or-frame)
"Make windows the same heights or widths in window split subtrees.
When called non-interactively WINDOW-OR-FRAME may be either a
window or a frame. It then balances the windows on the implied
frame. If the parameter is a window only the corresponding window
subtree is balanced."
(interactive) (interactive)
(let ((count -1) levels newsizes level-size (let (
;; Don't count the lines that are above the uppermost windows. (wt (bw-get-tree window-or-frame))
;; (These are the menu bar lines, if any.) (w)
(mbl (nth 1 (window-edges (frame-first-window (selected-frame))))) (h)
(last-window (previous-window (frame-first-window (selected-frame)))) (tried-sizes)
;; Don't count the lines that are past the lowest main window. (last-sizes)
total) (windows (window-list nil 0))
;; Bottom edge of last window determines what size we have to work with. (counter 0))
(setq total (when wt
(+ (window-height last-window) (while (not (member last-sizes tried-sizes))
(nth 1 (window-edges last-window)))) (when last-sizes (setq tried-sizes (cons last-sizes tried-sizes)))
(setq last-sizes (mapcar (lambda(w)
;; Find all the different vpos's at which windows start, (window-edges w))
;; then count them. But ignore levels that differ by only 1. windows))
(let (tops (prev-top -2)) (when (eq 'hor (bw-dir wt))
(walk-windows (function (lambda (w) (setq w (- (bw-r wt) (bw-l wt))))
(setq tops (cons (nth 1 (window-edges w)) (when (eq 'ver (bw-dir wt))
tops)))) (setq h (- (bw-b wt) (bw-t wt))))
'nomini) (bw-balance-sub wt w h)))))
(setq tops (sort tops '<))
(while tops (defun bw-adjust-window(window delta horizontal)
(if (> (car tops) (1+ prev-top)) "Wrapper around `adjust-window-trailing-edge' with error checking.
(setq prev-top (car tops) Arguments WINDOW, DELTA and HORIZONTAL are passed on to that function."
count (1+ count))) (condition-case err
(setq levels (cons (cons (car tops) count) levels)) (adjust-window-trailing-edge window delta horizontal)
(setq tops (cdr tops))) (error
(setq count (1+ count))) ;;(message "adjust: %s" (error-message-string err))
;; Subdivide the frame into desired number of vertical levels. )))
(setq level-size (/ (- total mbl) count))
(save-selected-window (defun bw-balance-sub(wt w h)
;; Set up NEWSIZES to map windows to their desired sizes. (setq wt (bw-refresh-edges wt))
;; If a window ends at the bottom level, don't include (unless w (setq w (- (bw-r wt) (bw-l wt))))
;; it in NEWSIZES. Those windows get the right sizes (unless h (setq h (- (bw-b wt) (bw-t wt))))
;; by adjusting the ones above them. (if (windowp wt)
(walk-windows (function (progn
(lambda (w) (when w
(let ((newtop (cdr (assq (nth 1 (window-edges w)) (let ((dw (- w (- (bw-r wt) (bw-l wt)))))
levels))) (when (/= 0 dw)
(newbot (cdr (assq (+ (window-height w) (bw-adjust-window wt dw t))))
(nth 1 (window-edges w))) (when h
levels)))) (let ((dh (- h (- (bw-b wt) (bw-t wt)))))
(if newbot (when (/= 0 dh)
(setq newsizes (bw-adjust-window wt dh nil)))))
(cons (cons w (* level-size (- newbot newtop))) (let* ((childs (cdr (assq 'childs wt)))
newsizes)))))) (lastchild (car (last childs)))
'nomini) (cw (when w (/ w (if (bw-eqdir 'hor wt) (length childs) 1))))
;; Make walk-windows start with the topmost window. (ch (when h (/ h (if (bw-eqdir 'ver wt) (length childs) 1)))))
(select-window (previous-window (frame-first-window (selected-frame)))) (dolist (c childs)
(let (done (count 0)) (bw-balance-sub c cw ch)))))
;; Give each window its precomputed size, or at least try.
;; Keep trying until they all get the intended sizes, ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; but not more than 3 times (to prevent infinite loop).
(while (and (not done) (< count 3))
(setq done t)
(setq count (1+ count))
(walk-windows (function (lambda (w)
(select-window w)
(let ((newsize (cdr (assq w newsizes))))
(when newsize
(enlarge-window (- newsize
(window-height))
nil)
(unless (= (window-height) newsize)
(setq done nil))))))
'nomini))))))
;; I think this should be the default; I think people will prefer it--rms. ;; I think this should be the default; I think people will prefer it--rms.
(defcustom split-window-keep-point t (defcustom split-window-keep-point t
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment