lisp/ediff-wind.el

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