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

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