lisp/ediff-wind.el

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