code.delx.au - gnu-emacs/blob - lisp/ediff-wind.el

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