code.delx.au - gnu-emacs/blob - lisp/ediff-wind.el

   1 ;;; ediff-wind.el --- window manipulation utilities
   2
   3 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   4
   5 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 ;; Boston, MA 02111-1307, USA.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 (provide 'ediff-wind)
  29
  30 ;; Compiler pacifier
  31 (defvar icon-title-format)
  32 (defvar top-toolbar-height)
  33 (defvar bottom-toolbar-height)
  34 (defvar left-toolbar-height)
  35 (defvar right-toolbar-height)
  36 (defvar left-toolbar-width)
  37 (defvar right-toolbar-width)
  38 (defvar default-menubar)
  39 (defvar frame-icon-title-format)
  40 (defvar ediff-diff-status)
  41 (defvar ediff-emacs-p)
  42
  43 (eval-when-compile
  44   (let ((load-path (cons (expand-file-name ".") load-path)))
  45     (or (featurep 'ediff-init)
  46         (load "ediff-init.el" nil nil 'nosuffix))
  47     (or (featurep 'ediff-util)
  48         (load "ediff-util.el" nil nil 'nosuffix))
  49     (or (featurep 'ediff-help)
  50         (load "ediff-help.el" nil nil 'nosuffix))
  51     (or (featurep 'ediff-tbar)
  52         ediff-emacs-p
  53         (load "ediff-tbar.el" 'noerror nil 'nosuffix))
  54     ))
  55 ;; end pacifier
  56
  57 (require 'ediff-init)
  58
  59 ;; be careful with ediff-tbar
  60 (if ediff-xemacs-p
  61     (condition-case nil
  62         (require 'ediff-tbar)
  63       (error
  64        (defun ediff-compute-toolbar-width () 0)))
  65   (defun ediff-compute-toolbar-width () 0))
  66
  67 (defgroup ediff-window nil
  68   "Ediff window manipulation"
  69   :prefix "ediff-"
  70   :group 'ediff
  71   :group 'frames)
  72
  73
  74 (defcustom ediff-window-setup-function (if (ediff-window-display-p)
  75                                         'ediff-setup-windows-multiframe
  76                                       'ediff-setup-windows-plain)
  77   "*Function called to set up windows.
  78 Ediff provides a choice of two functions: `ediff-setup-windows-plain', for
  79 doing everything in one frame, and `ediff-setup-windows-multiframe',
  80 which sets the control panel in a separate frame.  Also, if the latter
  81 function detects that one of the buffers A/B is seen in some other frame,
  82 it will try to keep that buffer in that frame.
  83
  84 If you don't like the two functions provided---write your own one.
  85 The basic guidelines:
  86     1. It should leave the control buffer current and the control window
  87        selected.
  88     2. It should set `ediff-window-A', `ediff-window-B', `ediff-window-C',
  89        and `ediff-control-window' to contain window objects that display
  90        the corresponding buffers.
  91     3. It should accept the following arguments:
  92        buffer-A, buffer-B, buffer-C, control-buffer
  93        Buffer C may not be used in jobs that compare only two buffers.
  94 If you plan to do something fancy, take a close look at how the two
  95 provided functions are written."
  96   :type 'function
  97   :group 'ediff-window)
  98
  99 ;; indicates if we are in a multiframe setup
 100 (ediff-defvar-local ediff-multiframe nil "")
 101
 102 ;; Share of the frame occupied by the merge window (buffer C)
 103 (ediff-defvar-local ediff-merge-window-share 0.45 "")
 104
 105 ;; The control window.
 106 (ediff-defvar-local ediff-control-window nil "")
 107 ;; Official window for buffer A
 108 (ediff-defvar-local ediff-window-A nil "")
 109 ;; Official window for buffer B
 110 (ediff-defvar-local ediff-window-B nil "")
 111 ;; Official window for buffer C
 112 (ediff-defvar-local ediff-window-C nil "")
 113 ;; Ediff's window configuration.
 114 ;; Used to minimize the need to rearrange windows.
 115 (ediff-defvar-local ediff-window-config-saved "" "")
 116
 117 ;; Association between buff-type and ediff-window-*
 118 (defconst ediff-window-alist
 119   '((A . ediff-window-A)
 120     (?A . ediff-window-A)
 121     (B . ediff-window-B)
 122     (?B . ediff-window-B)
 123     (C . ediff-window-C)
 124     (?C . ediff-window-C)))
 125
 126
 127 (defcustom ediff-split-window-function 'split-window-vertically
 128   "*The function used to split the main window between buffer-A and buffer-B.
 129 You can set it to a horizontal split instead of the default vertical split
 130 by setting this variable to `split-window-horizontally'.
 131 You can also have your own function to do fancy splits.
 132 This variable has no effect when buffer-A/B are shown in different frames.
 133 In this case, Ediff will use those frames to display these buffers."
 134   :type 'function
 135   :group 'ediff-window)
 136
 137 (defcustom ediff-merge-split-window-function 'split-window-horizontally
 138   "*The function used to split the main window between buffer-A and buffer-B.
 139 You can set it to a vertical split instead of the default horizontal split
 140 by setting this variable to `split-window-vertically'.
 141 You can also have your own function to do fancy splits.
 142 This variable has no effect when buffer-A/B/C are shown in different frames.
 143 In this case, Ediff will use those frames to display these buffers."
 144   :type 'function
 145   :group 'ediff-window)
 146
 147 (defconst ediff-control-frame-parameters
 148   (list
 149    '(name . "Ediff")
 150    ;;'(unsplittable . t)
 151    '(minibuffer . nil)
 152    '(user-position . t)       ; Emacs only
 153    '(vertical-scroll-bars . nil)  ; Emacs only
 154    '(scrollbar-width . 0)         ; XEmacs only
 155    '(menu-bar-lines . 0)          ; Emacs only
 156    '(tool-bar-lines . 0)          ; Emacs 21+ only
 157    ;; don't lower and auto-raise
 158    '(auto-lower . nil)
 159    '(auto-raise . t)
 160    '(visibility . nil)
 161    ;; make initial frame small to avoid distraction
 162    '(width . 1) '(height . 1)
 163    ;; this blocks queries from  window manager as to where to put
 164    ;; ediff's control frame. we put the frame outside the display,
 165    ;; so the initial frame won't jump all over the screen
 166    (cons 'top  (if (fboundp 'ediff-display-pixel-height)
 167                    (1+ (ediff-display-pixel-height))
 168                  3000))
 169    (cons 'left (if (fboundp 'ediff-display-pixel-width)
 170                    (1+ (ediff-display-pixel-width))
 171                  3000))
 172    )
 173   "Frame parameters for displaying Ediff Control Panel.
 174 Used internally---not a user option.")
 175
 176 ;; position of the mouse; used to decide whether to warp the mouse into ctl
 177 ;; frame
 178 (ediff-defvar-local ediff-mouse-pixel-position nil "")
 179
 180 ;; not used for now
 181 (defvar ediff-mouse-pixel-threshold 30
 182   "If the user moves mouse more than this many pixels, Ediff won't warp mouse into control window.")
 183
 184 (defcustom ediff-grab-mouse t
 185   "*If t, Ediff will always grab the mouse and put it in the control frame.
 186 If 'maybe, Ediff will do it sometimes, but not after operations that require
 187 relatively long time.  If nil, the mouse will be entirely user's
 188 responsibility."
 189   :type 'boolean
 190   :group 'ediff-window)
 191
 192 (defcustom ediff-control-frame-position-function 'ediff-make-frame-position
 193   "Function to call to determine the desired location for the control panel.
 194 Expects three parameters: the control buffer, the desired width and height
 195 of the control frame.  It returns an association list
 196 of the form \(\(top . <position>\) \(left . <position>\)\)"
 197   :type 'function
 198   :group 'ediff-window)
 199
 200 (defcustom ediff-control-frame-upward-shift 42
 201   "*The upward shift of control frame from the top of buffer A's frame.
 202 Measured in pixels.
 203 This is used by the default control frame positioning function,
 204 `ediff-make-frame-position'.  This variable is provided for easy
 205 customization of the default control frame positioning."
 206   :type 'integer
 207   :group 'ediff-window)
 208
 209 (defcustom ediff-narrow-control-frame-leftward-shift (if ediff-xemacs-p 7 3)
 210   "*The leftward shift of control frame from the right edge of buf A's frame.
 211 Measured in characters.
 212 This is used by the default control frame positioning function,
 213 `ediff-make-frame-position' to adjust the position of the control frame
 214 when it shows the short menu.  This variable is provided for easy
 215 customization of the default."
 216   :type 'integer
 217   :group 'ediff-window)
 218
 219 (defcustom ediff-wide-control-frame-rightward-shift 7
 220   "*The rightward shift of control frame from the left edge of buf A's frame.
 221 Measured in characters.
 222 This is used by the default control frame positioning function,
 223 `ediff-make-frame-position' to adjust the position of the control frame
 224 when it shows the full menu.  This variable is provided for easy
 225 customization of the default."
 226   :type 'integer
 227   :group 'ediff-window)
 228
 229
 230 ;; Wide frame display
 231
 232 ;; t means Ediff is using wide display
 233 (ediff-defvar-local ediff-wide-display-p nil "")
 234 ;; keeps frame config for toggling wide display
 235 (ediff-defvar-local ediff-wide-display-orig-parameters nil
 236   "Frame parameters to be restored when the user wants to toggle the wide
 237 display off.")
 238 (ediff-defvar-local ediff-wide-display-frame nil
 239   "Frame to be used for wide display.")
 240 (ediff-defvar-local ediff-make-wide-display-function 'ediff-make-wide-display
 241   "The value is a function that is called to create a wide display.
 242 The function is called without arguments.  It should resize the frame in
 243 which buffers A, B, and C are to be displayed, and it should save the old
 244 frame parameters in `ediff-wide-display-orig-parameters'.
 245 The variable `ediff-wide-display-frame' should be set to contain
 246 the frame used for the wide display.")
 247
 248 ;; Frame used for the control panel in a windowing system.
 249 (ediff-defvar-local ediff-control-frame nil "")
 250
 251 (defcustom ediff-prefer-iconified-control-frame nil
 252   "*If t, keep control panel iconified when help message is off.
 253 This has effect only on a windowing system.
 254 If t, hitting `?' to toggle control panel off iconifies it.
 255
 256 This is only useful in Emacs and only for certain kinds of window managers,
 257 such as TWM and its derivatives, since the window manager must permit
 258 keyboard input to go into icons.  XEmacs completely ignores keyboard input
 259 into icons, regardless of the window manager."
 260   :type 'boolean
 261   :group 'ediff-window)
 262
 263 ;;; Functions
 264
 265 (defun ediff-get-window-by-clicking (wind prev-wind wind-number)
 266   (let (event)
 267     (message
 268      "Select windows by clicking.  Please click on Window %d " wind-number)
 269     (while (not (ediff-mouse-event-p (setq event (ediff-read-event))))
 270       (if (sit-for 1) ; if sequence of events, wait till the final word
 271           (beep 1))
 272       (message "Please click on Window %d " wind-number))
 273     (ediff-read-event) ; discard event
 274     (setq wind (if ediff-xemacs-p
 275                    (event-window event)
 276                  (posn-window (event-start event))))
 277     ))
 278
 279
 280 ;; Select the lowest window on the frame.
 281 (defun ediff-select-lowest-window ()
 282   (if ediff-xemacs-p
 283       (select-window (frame-lowest-window))
 284     (let* ((lowest-window (selected-window))
 285            (bottom-edge (car (cdr (cdr (cdr (window-edges))))))
 286            (last-window (save-excursion
 287                           (other-window -1) (selected-window)))
 288            (window-search t))
 289       (while window-search
 290         (let* ((this-window (next-window))
 291                (next-bottom-edge
 292                 (car (cdr (cdr (cdr (window-edges this-window)))))))
 293           (if (< bottom-edge next-bottom-edge)
 294               (progn
 295                 (setq bottom-edge next-bottom-edge)
 296                 (setq lowest-window this-window)))
 297
 298           (select-window this-window)
 299           (if (eq last-window this-window)
 300               (progn
 301                 (select-window lowest-window)
 302                 (setq window-search nil))))))))
 303
 304
 305 ;;; Common window setup routines
 306
 307 ;; Set up the window configuration.  If POS is given, set the points to
 308 ;; the beginnings of the buffers.
 309 ;; When 3way comparison is added, this will have to choose the appropriate
 310 ;; setup function based on ediff-job-name
 311 (defun ediff-setup-windows (buffer-A buffer-B buffer-C control-buffer)
 312   ;; Make sure we are not in the minibuffer window when we try to delete
 313   ;; all other windows.
 314   (run-hooks 'ediff-before-setup-windows-hook)
 315   (if (eq (selected-window) (minibuffer-window))
 316       (other-window 1))
 317
 318   ;; in case user did a no-no on a tty
 319   (or (ediff-window-display-p)
 320       (setq ediff-window-setup-function 'ediff-setup-windows-plain))
 321
 322   (or (ediff-keep-window-config control-buffer)
 323       (funcall
 324        (ediff-with-current-buffer control-buffer ediff-window-setup-function)
 325        buffer-A buffer-B buffer-C control-buffer))
 326   (run-hooks 'ediff-after-setup-windows-hook))
 327
 328 ;; Just set up 3 windows.
 329 ;; Usually used without windowing systems
 330 ;; With windowing, we want to use dedicated frames.
 331 (defun ediff-setup-windows-plain (buffer-A buffer-B buffer-C control-buffer)
 332   (ediff-with-current-buffer control-buffer
 333     (setq ediff-multiframe nil))
 334   (if ediff-merge-job
 335       (ediff-setup-windows-plain-merge
 336        buffer-A buffer-B buffer-C control-buffer)
 337     (ediff-setup-windows-plain-compare
 338      buffer-A buffer-B buffer-C control-buffer)))
 339
 340 (defun ediff-setup-windows-plain-merge (buf-A buf-B buf-C control-buffer)
 341   ;; skip dedicated and unsplittable frames
 342   (ediff-destroy-control-frame control-buffer)
 343   (let ((window-min-height 1)
 344         split-window-function
 345         merge-window-share merge-window-lines
 346         wind-A wind-B wind-C)
 347     (ediff-with-current-buffer control-buffer
 348       (setq merge-window-share ediff-merge-window-share
 349             ;; this lets us have local versions of ediff-split-window-function
 350             split-window-function ediff-split-window-function))
 351     (delete-other-windows)
 352     (split-window-vertically)
 353     (ediff-select-lowest-window)
 354     (ediff-setup-control-buffer control-buffer)
 355
 356     ;; go to the upper window and split it betw A, B, and possibly C
 357     (other-window 1)
 358     (setq merge-window-lines
 359           (max 2 (round (* (window-height) merge-window-share))))
 360     (switch-to-buffer buf-A)
 361     (setq wind-A (selected-window))
 362
 363     ;; XEmacs used to have a lot of trouble with display
 364     ;; It did't set things right unless we tell it to sit still
 365     ;; 19.12 seems ok.
 366     ;;(if ediff-xemacs-p (sit-for 0))
 367
 368     (split-window-vertically (max 2 (- (window-height) merge-window-lines)))
 369     (if (eq (selected-window) wind-A)
 370         (other-window 1))
 371     (setq wind-C (selected-window))
 372     (switch-to-buffer buf-C)
 373
 374     (select-window wind-A)
 375     (funcall split-window-function)
 376
 377     (if (eq (selected-window) wind-A)
 378         (other-window 1))
 379     (switch-to-buffer buf-B)
 380     (setq wind-B (selected-window))
 381
 382     (ediff-with-current-buffer control-buffer
 383       (setq ediff-window-A wind-A
 384             ediff-window-B wind-B
 385             ediff-window-C wind-C))
 386
 387     (ediff-select-lowest-window)
 388     (ediff-setup-control-buffer control-buffer)
 389     ))
 390
 391
 392 ;; This function handles all comparison jobs, including 3way jobs
 393 (defun ediff-setup-windows-plain-compare (buf-A buf-B buf-C control-buffer)
 394   ;; skip dedicated and unsplittable frames
 395   (ediff-destroy-control-frame control-buffer)
 396   (let ((window-min-height 1)
 397         split-window-function wind-width-or-height
 398         three-way-comparison
 399         wind-A-start wind-B-start wind-A wind-B wind-C)
 400     (ediff-with-current-buffer control-buffer
 401       (setq wind-A-start (ediff-overlay-start
 402                           (ediff-get-value-according-to-buffer-type
 403                            'A ediff-narrow-bounds))
 404             wind-B-start (ediff-overlay-start
 405                           (ediff-get-value-according-to-buffer-type
 406                            'B  ediff-narrow-bounds))
 407             ;; this lets us have local versions of ediff-split-window-function
 408             split-window-function ediff-split-window-function
 409             three-way-comparison ediff-3way-comparison-job))
 410     (delete-other-windows)
 411     (split-window-vertically)
 412     (ediff-select-lowest-window)
 413     (ediff-setup-control-buffer control-buffer)
 414
 415     ;; go to the upper window and split it betw A, B, and possibly C
 416     (other-window 1)
 417     (switch-to-buffer buf-A)
 418     (setq wind-A (selected-window))
 419     (if three-way-comparison
 420         (setq wind-width-or-height
 421               (/ (if (eq split-window-function 'split-window-vertically)
 422                      (window-height wind-A)
 423                    (window-width wind-A))
 424                  3)))
 425
 426     ;; XEmacs used to have a lot of trouble with display
 427     ;; It did't set things right unless we told it to sit still
 428     ;; 19.12 seems ok.
 429     ;;(if ediff-xemacs-p (sit-for 0))
 430
 431     (funcall split-window-function wind-width-or-height)
 432
 433     (if (eq (selected-window) wind-A)
 434         (other-window 1))
 435     (switch-to-buffer buf-B)
 436     (setq wind-B (selected-window))
 437
 438     (if three-way-comparison
 439         (progn
 440           (funcall split-window-function) ; equally
 441           (if (eq (selected-window) wind-B)
 442               (other-window 1))
 443           (switch-to-buffer buf-C)
 444           (setq wind-C (selected-window))))
 445
 446     (ediff-with-current-buffer control-buffer
 447       (setq ediff-window-A wind-A
 448             ediff-window-B wind-B
 449             ediff-window-C wind-C))
 450
 451     ;; It is unlikely that we will want to implement 3way window comparison.
 452     ;; So, only buffers A and B are used here.
 453     (if ediff-windows-job
 454         (progn
 455           (set-window-start wind-A wind-A-start)
 456           (set-window-start wind-B wind-B-start)))
 457
 458     (ediff-select-lowest-window)
 459     (ediff-setup-control-buffer control-buffer)
 460     ))
 461
 462
 463 ;; dispatch an appropriate window setup function
 464 (defun ediff-setup-windows-multiframe (buf-A buf-B buf-C control-buf)
 465   (ediff-with-current-buffer control-buf
 466     (setq ediff-multiframe t))
 467   (if ediff-merge-job
 468       (ediff-setup-windows-multiframe-merge buf-A buf-B buf-C control-buf)
 469     (ediff-setup-windows-multiframe-compare buf-A buf-B buf-C control-buf)))
 470
 471 (defun ediff-setup-windows-multiframe-merge (buf-A buf-B buf-C control-buf)
 472 ;;; Algorithm:
 473 ;;;   1. Never use frames that have dedicated windows in them---it is bad to
 474 ;;;      destroy dedicated windows.
 475 ;;;   2. If A and B are in the same frame but C's frame is different--- use one
 476 ;;;      frame for A and B and use a separate frame for C.
 477 ;;;   3. If C's frame is non-existent, then: if the first suitable
 478 ;;;      non-dedicated frame  is different from A&B's, then use it for C.
 479 ;;;      Otherwise, put A,B, and C in one frame.
 480 ;;;   4. If buffers A, B, C are is separate frames, use them to display these
 481 ;;;      buffers.
 482
 483   ;;   Skip dedicated or iconified frames.
 484   ;;   Unsplittable frames are taken care of later.
 485   (ediff-skip-unsuitable-frames 'ok-unsplittable)
 486
 487   (let* ((window-min-height 1)
 488          (wind-A (ediff-get-visible-buffer-window buf-A))
 489          (wind-B (ediff-get-visible-buffer-window buf-B))
 490          (wind-C (ediff-get-visible-buffer-window buf-C))
 491          (frame-A (if wind-A (window-frame wind-A)))
 492          (frame-B (if wind-B (window-frame wind-B)))
 493          (frame-C (if wind-C (window-frame wind-C)))
 494          ;; on wide display, do things in one frame
 495          (force-one-frame
 496           (ediff-with-current-buffer control-buf ediff-wide-display-p))
 497          ;; this lets us have local versions of ediff-split-window-function
 498          (split-window-function
 499           (ediff-with-current-buffer control-buf ediff-split-window-function))
 500          (orig-wind (selected-window))
 501          (orig-frame (selected-frame))
 502          (use-same-frame (or force-one-frame
 503                              ;; A and C must be in one frame
 504                              (eq frame-A (or frame-C orig-frame))
 505                              ;; B and C must be in one frame
 506                              (eq frame-B (or frame-C orig-frame))
 507                              ;; A or B is not visible
 508                              (not (frame-live-p frame-A))
 509                              (not (frame-live-p frame-B))
 510                              ;; A or B is not suitable for display
 511                              (not (ediff-window-ok-for-display wind-A))
 512                              (not (ediff-window-ok-for-display wind-B))
 513                              ;; A and B in the same frame, and no good frame
 514                              ;; for C
 515                              (and (eq frame-A frame-B)
 516                                   (not (frame-live-p frame-C)))
 517                              ))
 518          ;; use-same-frame-for-AB implies wind A and B are ok for display
 519          (use-same-frame-for-AB (and (not use-same-frame)
 520                                      (eq frame-A frame-B)))
 521          (merge-window-share (ediff-with-current-buffer control-buf
 522                                ediff-merge-window-share))
 523          merge-window-lines
 524          designated-minibuffer-frame
 525          done-A done-B done-C)
 526
 527     ;; buf-A on its own
 528     (if (and (window-live-p wind-A)
 529              (null use-same-frame) ; implies wind-A is suitable
 530              (null use-same-frame-for-AB))
 531         (progn ; bug A on its own
 532           ;; buffer buf-A is seen in live wind-A
 533           (select-window wind-A)
 534           (delete-other-windows)
 535           (setq wind-A (selected-window))
 536           (setq done-A t)))
 537
 538     ;; buf-B on its own
 539     (if (and (window-live-p wind-B)
 540              (null use-same-frame) ; implies wind-B is suitable
 541              (null use-same-frame-for-AB))
 542         (progn ; buf B on its own
 543           ;; buffer buf-B is seen in live wind-B
 544           (select-window wind-B)
 545           (delete-other-windows)
 546           (setq wind-B (selected-window))
 547           (setq done-B t)))
 548
 549     ;; buf-C on its own
 550     (if (and (window-live-p wind-C)
 551              (ediff-window-ok-for-display wind-C)
 552              (null use-same-frame)) ; buf C on its own
 553         (progn
 554           ;; buffer buf-C is seen in live wind-C
 555           (select-window wind-C)
 556           (delete-other-windows)
 557           (setq wind-C (selected-window))
 558           (setq done-C t)))
 559
 560     (if (and use-same-frame-for-AB  ; implies wind A and B are suitable
 561              (window-live-p wind-A))
 562         (progn
 563           ;; wind-A must already be displaying buf-A
 564           (select-window wind-A)
 565           (delete-other-windows)
 566           (setq wind-A (selected-window))
 567
 568           (funcall split-window-function)
 569           (if (eq (selected-window) wind-A)
 570               (other-window 1))
 571           (switch-to-buffer buf-B)
 572           (setq wind-B (selected-window))
 573
 574           (setq done-A t
 575                 done-B t)))
 576
 577     (if use-same-frame
 578         (let ((window-min-height 1))
 579           (if (and (eq frame-A frame-B)
 580                    (eq frame-B frame-C)
 581                    (frame-live-p frame-A))
 582               (select-frame frame-A)
 583             ;; avoid dedicated and non-splittable windows
 584             (ediff-skip-unsuitable-frames))
 585           (delete-other-windows)
 586           (setq merge-window-lines
 587                 (max 2 (round (* (window-height) merge-window-share))))
 588           (switch-to-buffer buf-A)
 589           (setq wind-A (selected-window))
 590
 591           (split-window-vertically
 592            (max 2 (- (window-height) merge-window-lines)))
 593           (if (eq (selected-window) wind-A)
 594               (other-window 1))
 595           (setq wind-C (selected-window))
 596           (switch-to-buffer buf-C)
 597
 598           (select-window wind-A)
 599
 600           (funcall split-window-function)
 601           (if (eq (selected-window) wind-A)
 602               (other-window 1))
 603           (switch-to-buffer buf-B)
 604           (setq wind-B (selected-window))
 605
 606           (setq done-A t
 607                 done-B t
 608                 done-C t)
 609           ))
 610
 611     (or done-A  ; Buf A to be set in its own frame,
 612               ;;; or it was set before because use-same-frame = 1
 613         (progn
 614           ;; Buf-A was not set up yet as it wasn't visible,
 615           ;; and use-same-frame = nil, use-same-frame-for-AB = nil
 616           (select-window orig-wind)
 617           (delete-other-windows)
 618           (switch-to-buffer buf-A)
 619           (setq wind-A (selected-window))
 620           ))
 621     (or done-B  ; Buf B to be set in its own frame,
 622               ;;; or it was set before because use-same-frame = 1
 623         (progn
 624           ;; Buf-B was not set up yet as it wasn't visible
 625           ;; and use-same-frame = nil, use-same-frame-for-AB = nil
 626           (select-window orig-wind)
 627           (delete-other-windows)
 628           (switch-to-buffer buf-B)
 629           (setq wind-B (selected-window))
 630           ))
 631
 632     (or done-C  ; Buf C to be set in its own frame,
 633               ;;; or it was set before because use-same-frame = 1
 634         (progn
 635           ;; Buf-C was not set up yet as it wasn't visible
 636           ;; and use-same-frame = nil
 637           (select-window orig-wind)
 638           (delete-other-windows)
 639           (switch-to-buffer buf-C)
 640           (setq wind-C (selected-window))
 641           ))
 642
 643     (ediff-with-current-buffer control-buf
 644       (setq ediff-window-A wind-A
 645             ediff-window-B wind-B
 646             ediff-window-C wind-C)
 647       (setq frame-A (window-frame ediff-window-A)
 648             designated-minibuffer-frame
 649             (window-frame (minibuffer-window frame-A))))
 650
 651     (ediff-setup-control-frame control-buf designated-minibuffer-frame)
 652     ))
 653
 654
 655 ;; Window setup for all comparison jobs, including 3way comparisons
 656 (defun ediff-setup-windows-multiframe-compare (buf-A buf-B buf-C control-buf)
 657 ;;; Algorithm:
 658 ;;;    If a buffer is seen in a frame, use that frame for that buffer.
 659 ;;;    If it is not seen, use the current frame.
 660 ;;;    If both buffers are not seen, they share the current frame.  If one
 661 ;;;    of the buffers is not seen, it is placed in the current frame (where
 662 ;;;    ediff started).  If that frame is displaying the other buffer, it is
 663 ;;;    shared between the two buffers.
 664 ;;;    However, if we decide to put both buffers in one frame
 665 ;;;    and the selected frame isn't splittable, we create a new frame and
 666 ;;;    put both buffers there, event if one of this buffers is visible in
 667 ;;;    another frame.
 668
 669   ;; Skip dedicated or iconified frames.
 670   ;; Unsplittable frames are taken care of later.
 671   (ediff-skip-unsuitable-frames 'ok-unsplittable)
 672
 673   (let* ((window-min-height 1)
 674          (wind-A (ediff-get-visible-buffer-window buf-A))
 675          (wind-B (ediff-get-visible-buffer-window buf-B))
 676          (wind-C (ediff-get-visible-buffer-window buf-C))
 677          (frame-A (if wind-A (window-frame wind-A)))
 678          (frame-B (if wind-B (window-frame wind-B)))
 679          (frame-C (if wind-C (window-frame wind-C)))
 680          (ctl-frame-exists-p (ediff-with-current-buffer control-buf
 681                                (frame-live-p ediff-control-frame)))
 682          ;; on wide display, do things in one frame
 683          (force-one-frame
 684           (ediff-with-current-buffer control-buf ediff-wide-display-p))
 685          ;; this lets us have local versions of ediff-split-window-function
 686          (split-window-function
 687           (ediff-with-current-buffer control-buf ediff-split-window-function))
 688          (three-way-comparison
 689           (ediff-with-current-buffer control-buf ediff-3way-comparison-job))
 690          (orig-wind (selected-window))
 691          (use-same-frame (or force-one-frame
 692                              (eq frame-A frame-B)
 693                              (not (ediff-window-ok-for-display wind-A))
 694                              (not (ediff-window-ok-for-display wind-B))
 695                              (if three-way-comparison
 696                                  (or (eq frame-A frame-C)
 697                                      (eq frame-B frame-C)
 698                                      (not (ediff-window-ok-for-display wind-C))
 699                                      (not (frame-live-p frame-A))
 700                                      (not (frame-live-p frame-B))
 701                                      (not (frame-live-p frame-C))))
 702                              (and (not (frame-live-p frame-B))
 703                                   (or ctl-frame-exists-p
 704                                       (eq frame-A (selected-frame))))
 705                              (and (not (frame-live-p frame-A))
 706                                   (or ctl-frame-exists-p
 707                                       (eq frame-B (selected-frame))))))
 708          wind-A-start wind-B-start
 709          designated-minibuffer-frame
 710          done-A done-B done-C)
 711
 712     (ediff-with-current-buffer control-buf
 713       (setq wind-A-start (ediff-overlay-start
 714                           (ediff-get-value-according-to-buffer-type
 715                            'A ediff-narrow-bounds))
 716             wind-B-start (ediff-overlay-start
 717                           (ediff-get-value-according-to-buffer-type
 718                            'B ediff-narrow-bounds))))
 719
 720     (if (and (window-live-p wind-A) (null use-same-frame)) ; buf-A on its own
 721         (progn
 722           ;; buffer buf-A is seen in live wind-A
 723           (select-window wind-A) ; must be displaying buf-A
 724           (delete-other-windows)
 725           (setq wind-A (selected-window))
 726           (setq done-A t)))
 727
 728     (if (and (window-live-p wind-B) (null use-same-frame)) ; buf B on its own
 729         (progn
 730           ;; buffer buf-B is seen in live wind-B
 731           (select-window wind-B) ; must be displaying buf-B
 732           (delete-other-windows)
 733           (setq wind-B (selected-window))
 734           (setq done-B t)))
 735
 736     (if (and (window-live-p wind-C) (null use-same-frame)) ; buf C on its own
 737         (progn
 738           ;; buffer buf-C is seen in live wind-C
 739           (select-window wind-C) ; must be displaying buf-C
 740           (delete-other-windows)
 741           (setq wind-C (selected-window))
 742           (setq done-C t)))
 743
 744     (if use-same-frame
 745         (let (wind-width-or-height) ; this affects 3way setups only
 746           (if (and (eq frame-A frame-B) (frame-live-p frame-A))
 747               (select-frame frame-A)
 748             ;; avoid dedicated and non-splittable windows
 749             (ediff-skip-unsuitable-frames))
 750           (delete-other-windows)
 751           (switch-to-buffer buf-A)
 752           (setq wind-A (selected-window))
 753
 754           (if three-way-comparison
 755               (setq wind-width-or-height
 756                     (/
 757                      (if (eq split-window-function 'split-window-vertically)
 758                          (window-height wind-A)
 759                        (window-width wind-A))
 760                      3)))
 761
 762           (funcall split-window-function wind-width-or-height)
 763           (if (eq (selected-window) wind-A)
 764               (other-window 1))
 765           (switch-to-buffer buf-B)
 766           (setq wind-B (selected-window))
 767
 768           (if three-way-comparison
 769               (progn
 770                 (funcall split-window-function) ; equally
 771                 (if (memq (selected-window) (list wind-A wind-B))
 772                     (other-window 1))
 773                 (switch-to-buffer buf-C)
 774                 (setq wind-C (selected-window))))
 775           (setq done-A t
 776                 done-B t
 777                 done-C t)
 778           ))
 779
 780     (or done-A  ; Buf A to be set in its own frame
 781               ;;; or it was set before because use-same-frame = 1
 782         (progn
 783           ;; Buf-A was not set up yet as it wasn't visible,
 784           ;; and use-same-frame = nil
 785           (select-window orig-wind)
 786           (delete-other-windows)
 787           (switch-to-buffer buf-A)
 788           (setq wind-A (selected-window))
 789           ))
 790     (or done-B  ; Buf B to be set in its own frame
 791               ;;; or it was set before because use-same-frame = 1
 792         (progn
 793           ;; Buf-B was not set up yet as it wasn't visible,
 794           ;; and use-same-frame = nil
 795           (select-window orig-wind)
 796           (delete-other-windows)
 797           (switch-to-buffer buf-B)
 798           (setq wind-B (selected-window))
 799           ))
 800
 801     (if three-way-comparison
 802         (or done-C  ; Buf C to be set in its own frame
 803                   ;;; or it was set before because use-same-frame = 1
 804             (progn
 805               ;; Buf-C was not set up yet as it wasn't visible,
 806               ;; and use-same-frame = nil
 807               (select-window orig-wind)
 808               (delete-other-windows)
 809               (switch-to-buffer buf-C)
 810               (setq wind-C (selected-window))
 811               )))
 812
 813     (ediff-with-current-buffer control-buf
 814       (setq ediff-window-A wind-A
 815             ediff-window-B wind-B
 816             ediff-window-C wind-C)
 817
 818       (setq frame-A (window-frame ediff-window-A)
 819             designated-minibuffer-frame
 820             (window-frame (minibuffer-window frame-A))))
 821
 822     ;; It is unlikely that we'll implement a version of ediff-windows that
 823     ;; would compare 3 windows at once.  So, we don't use buffer C here.
 824     (if ediff-windows-job
 825         (progn
 826           (set-window-start wind-A wind-A-start)
 827           (set-window-start wind-B wind-B-start)))
 828
 829     (ediff-setup-control-frame control-buf designated-minibuffer-frame)
 830     ))
 831
 832 ;; skip unsplittable frames and frames that have dedicated windows.
 833 ;; create a new splittable frame if none is found
 834 (defun ediff-skip-unsuitable-frames (&optional ok-unsplittable)
 835   (if (ediff-window-display-p)
 836       ;;(let (last-window)
 837       (let (seen-windows)
 838         ;; (memq ... seen-windows) has quadratic behavior,
 839         ;; but (eq ... last-window) runs into an emacs bug where next-window
 840         ;; gets stuck in a loop if the only frame is the minibuffer.
 841         ;;
 842         ;;(while (and (not (eq (selected-window) last-window))
 843         (while (and (not (memq (selected-window) seen-windows))
 844                     (or
 845                      (ediff-frame-has-dedicated-windows (selected-frame))
 846                      (ediff-frame-iconified-p (selected-frame))
 847                      ;; skip small windows
 848                      (< (window-height (selected-window))
 849                         (* 3 window-min-height))
 850                      (if ok-unsplittable
 851                          nil
 852                        (ediff-frame-unsplittable-p (selected-frame)))))
 853           ;; remember where started
 854           ;;(or last-window (setq last-window (selected-window)))
 855           (setq seen-windows (cons (selected-window) seen-windows))
 856           ;; try new window
 857           (other-window 1 t))
 858         ;;(if (eq (selected-window) last-window)
 859         (if (memq (selected-window) seen-windows)
 860             ;; fed up, no appropriate frame
 861             (progn
 862               (select-frame (make-frame '((unsplittable)))))))))
 863
 864 (defun ediff-frame-has-dedicated-windows (frame)
 865   (let ((cur-fr (selected-frame))
 866         ans)
 867     (select-frame frame)
 868     (walk-windows
 869      (lambda (wind) (if (window-dedicated-p wind)
 870                         (setq ans t)))
 871      'ignore-minibuffer
 872      frame)
 873     (select-frame cur-fr)
 874     ans))
 875
 876 ;; window is ok, if it is only one window on the frame, not counting the
 877 ;; minibuffer, or none of the frame's windows is dedicated.
 878 ;; The idea is that it is bad to destroy dedicated windows while creating an
 879 ;; ediff window setup
 880 (defun ediff-window-ok-for-display (wind)
 881   (and
 882    (window-live-p wind)
 883    (or
 884     ;; only one window
 885     (eq wind (next-window wind 'ignore-minibuffer (window-frame wind)))
 886     ;; none is dedicated
 887     (not (ediff-frame-has-dedicated-windows (window-frame wind)))
 888     )))
 889
 890 ;; Prepare or refresh control frame
 891 (defun ediff-setup-control-frame (ctl-buffer designated-minibuffer-frame)
 892   (let ((window-min-height 1)
 893         ctl-frame-iconified-p dont-iconify-ctl-frame deiconify-ctl-frame
 894         ctl-frame old-ctl-frame lines
 895         ;; user-grabbed-mouse
 896         fheight fwidth adjusted-parameters)
 897
 898     (ediff-with-current-buffer ctl-buffer
 899       (if ediff-xemacs-p (set-buffer-menubar nil))
 900       ;;(setq user-grabbed-mouse (ediff-user-grabbed-mouse))
 901       (run-hooks 'ediff-before-setup-control-frame-hook))
 902
 903     (setq old-ctl-frame (ediff-with-current-buffer ctl-buffer ediff-control-frame))
 904     (ediff-with-current-buffer ctl-buffer
 905       (setq ctl-frame (if (frame-live-p old-ctl-frame)
 906                           old-ctl-frame
 907                         (make-frame ediff-control-frame-parameters))
 908             ediff-control-frame ctl-frame)
 909       ;; protect against undefined face-attribute
 910       (condition-case nil
 911           (when (and ediff-emacs-p (face-attribute 'mode-line :box))
 912             (set-face-attribute 'mode-line ctl-frame :box nil))
 913         (error))
 914       )
 915
 916     (setq ctl-frame-iconified-p (ediff-frame-iconified-p ctl-frame))
 917     (select-frame ctl-frame)
 918     (if (window-dedicated-p (selected-window))
 919         ()
 920       (delete-other-windows)
 921       (switch-to-buffer ctl-buffer))
 922
 923     ;; must be before ediff-setup-control-buffer
 924     ;; just a precaution--we should be in ctl-buffer already
 925     (ediff-with-current-buffer ctl-buffer
 926       (make-local-variable 'frame-title-format)
 927       (make-local-variable 'frame-icon-title-format)    ; XEmacs
 928       (make-local-variable 'icon-title-format))         ; Emacs
 929
 930     (ediff-setup-control-buffer ctl-buffer)
 931     (setq dont-iconify-ctl-frame
 932           (not (string= ediff-help-message ediff-brief-help-message)))
 933     (setq deiconify-ctl-frame
 934           (and (eq this-command 'ediff-toggle-help)
 935                dont-iconify-ctl-frame))
 936
 937     ;; 1 more line for the modeline
 938     (setq lines (1+ (count-lines (point-min) (point-max)))
 939           fheight lines
 940           fwidth (max (+ (ediff-help-message-line-length) 2)
 941                       (ediff-compute-toolbar-width))
 942           adjusted-parameters
 943           (list
 944            ;; possibly change surrogate minibuffer
 945            (cons 'minibuffer
 946                  (minibuffer-window
 947                   designated-minibuffer-frame))
 948            (cons 'width fwidth)
 949            (cons 'height fheight))
 950           )
 951     (if ediff-use-long-help-message
 952         (setq adjusted-parameters
 953               (cons '(auto-raise . nil) adjusted-parameters)))
 954
 955     ;; In XEmacs, buffer menubar needs to be killed before frame parameters
 956     ;; are changed.
 957     (if (ediff-has-toolbar-support-p)
 958         (progn
 959           (set-specifier top-toolbar-height (list ctl-frame 2))
 960           (sit-for 0)
 961           (set-specifier top-toolbar-height (list ctl-frame 0))
 962           ;;(set-specifier bottom-toolbar-height (list ctl-frame 0))
 963           (set-specifier left-toolbar-width (list ctl-frame 0))
 964           (set-specifier right-toolbar-width (list ctl-frame 0))
 965           ))
 966
 967     ;; Under OS/2 (emx) we have to call modify frame parameters twice, in order
 968     ;; to make sure that at least once we do it for non-iconified frame.  If
 969     ;; appears that in the OS/2 port of Emacs, one can't modify frame
 970     ;; parameters of iconified frames.  As a precaution, we do likewise for
 971     ;; windows-nt.
 972     (if (memq system-type '(emx windows-nt windows-95))
 973         (modify-frame-parameters ctl-frame adjusted-parameters))
 974
 975     ;; make or zap toolbar (if not requested)
 976     (ediff-make-bottom-toolbar ctl-frame)
 977
 978     (goto-char (point-min))
 979
 980     (modify-frame-parameters ctl-frame adjusted-parameters)
 981     (make-frame-visible ctl-frame)
 982
 983     ;; This works around a bug in 19.25 and earlier.  There, if frame gets
 984     ;; iconified, the current buffer changes to that of the frame that
 985     ;; becomes exposed as a result of this iconification.
 986     ;; So, we make sure the current buffer doesn't change.
 987     (select-frame ctl-frame)
 988     (ediff-refresh-control-frame)
 989
 990     (cond ((and ediff-prefer-iconified-control-frame
 991                 (not ctl-frame-iconified-p) (not dont-iconify-ctl-frame))
 992            (iconify-frame ctl-frame))
 993           ((or deiconify-ctl-frame (not ctl-frame-iconified-p))
 994            (raise-frame ctl-frame)))
 995
 996     (set-window-dedicated-p (selected-window) t)
 997
 998     ;; Now move the frame.  We must do it separately due to an obscure bug in
 999     ;; XEmacs
1000     (modify-frame-parameters
1001      ctl-frame
1002      (funcall ediff-control-frame-position-function ctl-buffer fwidth fheight))
1003
1004     ;; synchronize so the cursor will move to control frame
1005     ;; per RMS suggestion
1006     (if (ediff-window-display-p)
1007         (let ((count 7))
1008           (sit-for .1)
1009           (while (and (not (frame-visible-p ctl-frame)) (> count 0))
1010             (setq count (1- count))
1011             (sit-for .3))))
1012
1013     (or (ediff-frame-iconified-p ctl-frame)
1014         ;; don't warp the mouse, unless ediff-grab-mouse = t
1015         (ediff-reset-mouse ctl-frame
1016                            (or (eq this-command 'ediff-quit)
1017                                (not (eq ediff-grab-mouse t)))))
1018
1019     (if ediff-xemacs-p
1020         (ediff-with-current-buffer ctl-buffer
1021           (make-local-hook 'select-frame-hook)
1022           (add-hook 'select-frame-hook 'ediff-xemacs-select-frame-hook nil t)
1023           ))
1024
1025     (ediff-with-current-buffer ctl-buffer
1026       (run-hooks 'ediff-after-setup-control-frame-hook))
1027     ))
1028
1029
1030 (defun ediff-destroy-control-frame (ctl-buffer)
1031   (ediff-with-current-buffer ctl-buffer
1032     (if (and (ediff-window-display-p) (frame-live-p ediff-control-frame))
1033         (let ((ctl-frame ediff-control-frame))
1034           (if ediff-xemacs-p
1035               (set-buffer-menubar default-menubar))
1036           (setq ediff-control-frame nil)
1037           (delete-frame ctl-frame)
1038           )))
1039   (ediff-skip-unsuitable-frames)
1040   ;;(ediff-reset-mouse nil)
1041   )
1042
1043
1044 ;; finds a good place to clip control frame
1045 (defun ediff-make-frame-position (ctl-buffer ctl-frame-width ctl-frame-height)
1046   (ediff-with-current-buffer ctl-buffer
1047     (let* ((frame-A (window-frame ediff-window-A))
1048            (frame-A-parameters (frame-parameters frame-A))
1049            (frame-A-top (eval (cdr (assoc 'top frame-A-parameters))))
1050            (frame-A-left (eval (cdr (assoc 'left frame-A-parameters))))
1051            (frame-A-width (frame-width frame-A))
1052            (ctl-frame ediff-control-frame)
1053            horizontal-adjustment upward-adjustment
1054            ctl-frame-top ctl-frame-left)
1055
1056       ;; Multiple control frames are clipped based on the value of
1057       ;; ediff-control-buffer-number.  This is done in order not to obscure
1058       ;; other active control panels.
1059       (setq horizontal-adjustment (* 2 ediff-control-buffer-number)
1060             upward-adjustment (* -14 ediff-control-buffer-number))
1061
1062       (setq ctl-frame-top
1063             (- frame-A-top upward-adjustment ediff-control-frame-upward-shift)
1064             ctl-frame-left
1065             (+ frame-A-left
1066                (if ediff-use-long-help-message
1067                    (* (ediff-frame-char-width ctl-frame)
1068                       (+ ediff-wide-control-frame-rightward-shift
1069                          horizontal-adjustment))
1070                  (- (* frame-A-width (ediff-frame-char-width frame-A))
1071                     (* (ediff-frame-char-width ctl-frame)
1072                        (+ ctl-frame-width
1073                           ediff-narrow-control-frame-leftward-shift
1074                           horizontal-adjustment))))))
1075       (setq ctl-frame-top
1076             (min ctl-frame-top
1077                  (- (ediff-display-pixel-height)
1078                     (* 2 ctl-frame-height
1079                        (ediff-frame-char-height ctl-frame))))
1080             ctl-frame-left
1081             (min ctl-frame-left
1082                  (- (ediff-display-pixel-width)
1083                     (* ctl-frame-width (ediff-frame-char-width ctl-frame)))))
1084       ;; keep ctl frame within the visible bounds
1085       (setq ctl-frame-top (max ctl-frame-top 1)
1086             ctl-frame-left (max ctl-frame-left 1))
1087
1088       (list (cons 'top ctl-frame-top)
1089             (cons 'left ctl-frame-left))
1090       )))
1091
1092 (defun ediff-xemacs-select-frame-hook ()
1093   (if (and (equal (selected-frame) ediff-control-frame)
1094            (not ediff-use-long-help-message))
1095       (raise-frame ediff-control-frame)))
1096
1097 (defun ediff-make-wide-display ()
1098   "Construct an alist of parameters for the wide display.
1099 Saves the old frame parameters in `ediff-wide-display-orig-parameters'.
1100 The frame to be resized is kept in `ediff-wide-display-frame'.
1101 This function modifies only the left margin and the width of the display.
1102 It assumes that it is called from within the control buffer."
1103   (if (not (fboundp 'ediff-display-pixel-width))
1104       (error "Can't determine display width"))
1105   (let* ((frame-A (window-frame ediff-window-A))
1106          (frame-A-params (frame-parameters frame-A))
1107          (cw (ediff-frame-char-width frame-A))
1108          (wd (- (/ (ediff-display-pixel-width) cw) 5)))
1109     (setq ediff-wide-display-orig-parameters
1110           (list (cons 'left (max 0 (eval (cdr (assoc 'left frame-A-params)))))
1111                 (cons 'width (cdr (assoc 'width frame-A-params))))
1112           ediff-wide-display-frame frame-A)
1113     (modify-frame-parameters frame-A (list (cons 'left cw)
1114                                                  (cons 'width wd)))))
1115
1116
1117
1118 ;; Revise the mode line to display which difference we have selected
1119 ;; Also resets modelines of buffers A/B, since they may be clobbered by
1120 ;; anothe invocations of Ediff.
1121 (defun ediff-refresh-mode-lines ()
1122   (let (buf-A-state-diff buf-B-state-diff buf-C-state-diff buf-C-state-merge)
1123
1124     (if (ediff-valid-difference-p)
1125         (setq
1126          buf-C-state-diff (ediff-get-state-of-diff ediff-current-difference 'C)
1127          buf-C-state-merge (ediff-get-state-of-merge ediff-current-difference)
1128          buf-A-state-diff (ediff-get-state-of-diff ediff-current-difference 'A)
1129          buf-B-state-diff (ediff-get-state-of-diff ediff-current-difference 'B)
1130          buf-A-state-diff (if buf-A-state-diff
1131                               (format "[%s] " buf-A-state-diff)
1132                             "")
1133          buf-B-state-diff (if buf-B-state-diff
1134                               (format "[%s] " buf-B-state-diff)
1135                             "")
1136          buf-C-state-diff (if (and (ediff-buffer-live-p ediff-buffer-C)
1137                                    (or buf-C-state-diff buf-C-state-merge))
1138                               (format "[%s%s%s] "
1139                                       (or buf-C-state-diff "")
1140                                       (if buf-C-state-merge
1141                                           (concat " " buf-C-state-merge)
1142                                         "")
1143                                       (if (ediff-get-state-of-ancestor
1144                                            ediff-current-difference)
1145                                           " AncestorEmpty"
1146                                         "")
1147                                       )
1148                             ""))
1149       (setq buf-A-state-diff ""
1150             buf-B-state-diff ""
1151             buf-C-state-diff ""))
1152
1153     ;; control buffer format
1154     (setq mode-line-format
1155           (if (ediff-narrow-control-frame-p)
1156               (list "   " mode-line-buffer-identification)
1157             (list "-- " mode-line-buffer-identification "        Quick Help")))
1158     ;; control buffer id
1159     (setq mode-line-buffer-identification
1160           (if (ediff-narrow-control-frame-p)
1161               (ediff-make-narrow-control-buffer-id 'skip-name)
1162             (ediff-make-wide-control-buffer-id)))
1163     ;; Force mode-line redisplay
1164     (force-mode-line-update)
1165
1166     (if (and (ediff-window-display-p) (frame-live-p ediff-control-frame))
1167         (ediff-refresh-control-frame))
1168
1169     (ediff-with-current-buffer ediff-buffer-A
1170       (setq ediff-diff-status buf-A-state-diff)
1171       (ediff-strip-mode-line-format)
1172       (setq mode-line-format
1173             (list " A: " 'ediff-diff-status mode-line-format))
1174       (force-mode-line-update))
1175     (ediff-with-current-buffer ediff-buffer-B
1176       (setq ediff-diff-status buf-B-state-diff)
1177       (ediff-strip-mode-line-format)
1178       (setq mode-line-format
1179             (list " B: " 'ediff-diff-status mode-line-format))
1180       (force-mode-line-update))
1181     (if ediff-3way-job
1182         (ediff-with-current-buffer ediff-buffer-C
1183           (setq ediff-diff-status buf-C-state-diff)
1184           (ediff-strip-mode-line-format)
1185           (setq mode-line-format
1186                 (list " C: " 'ediff-diff-status mode-line-format))
1187           (force-mode-line-update)))
1188     (if (ediff-buffer-live-p ediff-ancestor-buffer)
1189         (ediff-with-current-buffer ediff-ancestor-buffer
1190           (ediff-strip-mode-line-format)
1191           ;; we keep the second dummy string in the mode line format of the
1192           ;; ancestor, since for other buffers Ediff prepends 2 strings and
1193           ;; ediff-strip-mode-line-format expects that.
1194           (setq mode-line-format
1195                 (list " Ancestor: "
1196                       (cond ((not (stringp buf-C-state-merge))
1197                              "")
1198                             ((string-match "prefer-A" buf-C-state-merge)
1199                              "[=diff(B)] ")
1200                             ((string-match "prefer-B" buf-C-state-merge)
1201                              "[=diff(A)] ")
1202                             (t ""))
1203                       mode-line-format))))
1204     ))
1205
1206
1207 (defun ediff-refresh-control-frame ()
1208   (if ediff-emacs-p
1209       ;; set frame/icon titles for Emacs
1210       (modify-frame-parameters
1211        ediff-control-frame
1212        (list (cons 'title (ediff-make-base-title))
1213              (cons 'icon-name (ediff-make-narrow-control-buffer-id))
1214              ))
1215     ;; set frame/icon titles for XEmacs
1216     (setq frame-title-format (ediff-make-base-title)
1217           frame-icon-title-format (ediff-make-narrow-control-buffer-id))
1218     ;; force an update of the frame title
1219     (modify-frame-parameters ediff-control-frame '(()))))
1220
1221
1222 (defun ediff-make-narrow-control-buffer-id (&optional skip-name)
1223   (concat
1224    (if skip-name
1225        " "
1226      (ediff-make-base-title))
1227    (cond ((< ediff-current-difference 0)
1228           (format " _/%d" ediff-number-of-differences))
1229          ((>= ediff-current-difference ediff-number-of-differences)
1230           (format " $/%d" ediff-number-of-differences))
1231          (t
1232           (format " %d/%d"
1233                   (1+ ediff-current-difference)
1234                   ediff-number-of-differences)))))
1235
1236 (defun ediff-make-base-title ()
1237   (concat
1238    (cdr (assoc 'name ediff-control-frame-parameters))
1239    ediff-control-buffer-suffix))
1240
1241 (defun ediff-make-wide-control-buffer-id ()
1242   (cond ((< ediff-current-difference 0)
1243          (list (format "%%b   At start of %d diffs"
1244                        ediff-number-of-differences)))
1245         ((>= ediff-current-difference ediff-number-of-differences)
1246          (list (format "%%b   At end of %d diffs"
1247                        ediff-number-of-differences)))
1248         (t
1249          (list (format "%%b   diff %d of %d"
1250                        (1+ ediff-current-difference)
1251                        ediff-number-of-differences)))))
1252
1253
1254
1255 ;; If buff is not live, return nil
1256 (defun ediff-get-visible-buffer-window (buff)
1257   (if (ediff-buffer-live-p buff)
1258       (if ediff-xemacs-p
1259           (get-buffer-window buff t)
1260         (get-buffer-window buff 'visible))))
1261
1262
1263 ;;; Functions to decide when to redraw windows
1264
1265 (defun ediff-keep-window-config (control-buf)
1266   (and (eq control-buf (current-buffer))
1267        (/= (buffer-size) 0)
1268        (ediff-with-current-buffer control-buf
1269          (let ((ctl-wind ediff-control-window)
1270                (A-wind ediff-window-A)
1271                (B-wind ediff-window-B)
1272                (C-wind ediff-window-C))
1273
1274            (and
1275             (ediff-window-visible-p A-wind)
1276             (ediff-window-visible-p B-wind)
1277             ;; if buffer C is defined then take it into account
1278             (or (not ediff-3way-job)
1279                 (ediff-window-visible-p C-wind))
1280             (eq (window-buffer A-wind) ediff-buffer-A)
1281             (eq (window-buffer B-wind) ediff-buffer-B)
1282             (or (not ediff-3way-job)
1283                 (eq (window-buffer C-wind) ediff-buffer-C))
1284             (string= ediff-window-config-saved
1285                      (format "%S%S%S%S%S%S%S"
1286                              ctl-wind A-wind B-wind C-wind
1287                              ediff-split-window-function
1288                              (ediff-multiframe-setup-p)
1289                              ediff-wide-display-p)))))))
1290
1291
1292 ;;; Local Variables:
1293 ;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1294 ;;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1295 ;;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1296 ;;; End:
1297
1298 ;;; ediff-wind.el ends here