lisp/ediff-wind.el

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