lisp/ediff-wind.el

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