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