lisp/ediff-wind.el

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