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