lisp/ediff-init.el

   1 ;;; ediff-init.el --- Macros, variables, and defsubsts used by Ediff
   2
   3 ;; Copyright (C) 1994, 1995, 1996, 1997, 2000 Free Software Foundation, Inc.
   4
   5 ;; Author: Michael Kifer <kifer@cs.sunysb.edu>
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 ;; Boston, MA 02111-1307, USA.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 ;; Start compiler pacifier
  29 (defvar ediff-metajob-name)
  30 (defvar ediff-meta-buffer)
  31 (defvar pm-color-alist)
  32 (defvar ediff-grab-mouse)
  33 (defvar ediff-mouse-pixel-position)
  34 (defvar ediff-mouse-pixel-threshold)
  35 (defvar ediff-whitespace)
  36 (defvar ediff-multiframe)
  37 (defvar ediff-use-toolbar-p)
  38
  39 (and noninteractive
  40      (eval-when-compile
  41          (load "ange-ftp" 'noerror)))
  42 ;; end pacifier
  43
  44 ;; Is it XEmacs?
  45 (defconst ediff-xemacs-p (string-match "XEmacs" emacs-version))
  46 ;; Is it Emacs?
  47 (defconst ediff-emacs-p (not ediff-xemacs-p))
  48
  49 (defvar ediff-force-faces nil
  50   "If t, Ediff will think that it is running on a display that supports faces.
  51 This is provided as a temporary relief for users of face-capable displays
  52 that Ediff doesn't know about.")
  53
  54 ;; Are we running as a window application or on a TTY?
  55 (defsubst ediff-device-type ()
  56   (if ediff-emacs-p
  57       window-system
  58     (device-type (selected-device))))
  59
  60 ;; in XEmacs: device-type is tty on tty and stream in batch.
  61 (defun ediff-window-display-p ()
  62   (and (ediff-device-type) (not (memq (ediff-device-type) '(tty pc stream)))))
  63
  64 ;; test if supports faces
  65 (defun ediff-has-face-support-p ()
  66   (cond ((ediff-window-display-p))
  67         (ediff-force-faces)
  68         ((ediff-color-display-p))
  69         (ediff-emacs-p (memq (ediff-device-type) '(pc)))
  70         (ediff-xemacs-p (memq (ediff-device-type) '(tty pc)))))
  71
  72 (defun ediff-has-toolbar-support-p ()
  73   (and ediff-xemacs-p
  74        (featurep 'toolbar)
  75        (console-on-window-system-p)))
  76
  77 (defun ediff-use-toolbar-p ()
  78   (and (ediff-has-toolbar-support-p)    ;Can it do it ?
  79        (boundp 'ediff-use-toolbar-p)
  80        ediff-use-toolbar-p))            ;Does the user want it ?
  81
  82 ;; Defines SYMBOL as an advertised local variable.
  83 ;; Performs a defvar, then executes `make-variable-buffer-local' on
  84 ;; the variable.  Also sets the `permanent-local' property,
  85 ;; so that `kill-all-local-variables' (called by major-mode setting
  86 ;; commands) won't destroy Ediff control variables.
  87 ;;
  88 ;; Plagiarised from `emerge-defvar-local' for XEmacs.
  89 (defmacro ediff-defvar-local (var value doc)
  90   `(progn
  91      (defvar ,var ,value ,doc)
  92      (make-variable-buffer-local ',var)
  93      (put ',var 'permanent-local t)))
  94
  95
  96
  97 ;; Variables that control each Ediff session---local to the control buffer.
  98
  99 ;; Mode variables
 100 ;; The buffer in which the A variant is stored.
 101 (ediff-defvar-local ediff-buffer-A nil "")
 102 ;; The buffer in which the B variant is stored.
 103 (ediff-defvar-local ediff-buffer-B nil "")
 104 ;; The buffer in which the C variant is stored or where the merge buffer lives.
 105 (ediff-defvar-local ediff-buffer-C nil "")
 106 ;; Ancestor buffer
 107 (ediff-defvar-local ediff-ancestor-buffer nil "")
 108 ;; The Ediff control buffer
 109 (ediff-defvar-local ediff-control-buffer nil "")
 110
 111
 112 ;; Association between buff-type and ediff-buffer-*
 113 (defconst ediff-buffer-alist
 114   '((?A . ediff-buffer-A)
 115     (?B . ediff-buffer-B)
 116     (?C . ediff-buffer-C)))
 117
 118 ;;; Macros
 119 (defmacro ediff-odd-p (arg)
 120   `(eq (logand ,arg 1) 1))
 121
 122 (defmacro ediff-buffer-live-p (buf)
 123   `(and ,buf (get-buffer ,buf) (buffer-name (get-buffer ,buf))))
 124
 125 (defmacro ediff-get-buffer (arg)
 126   `(cond ((eq ,arg 'A) ediff-buffer-A)
 127          ((eq ,arg 'B) ediff-buffer-B)
 128          ((eq ,arg 'C) ediff-buffer-C)
 129          ((eq ,arg 'Ancestor) ediff-ancestor-buffer)
 130          ))
 131
 132 (defmacro ediff-get-value-according-to-buffer-type (buf-type list)
 133   `(cond ((eq ,buf-type 'A) (nth 0 ,list))
 134          ((eq ,buf-type 'B) (nth 1 ,list))
 135          ((eq ,buf-type 'C) (nth 2 ,list))
 136          ))
 137
 138 (defmacro ediff-char-to-buftype (arg)
 139   `(cond ((memq ,arg '(?a ?A)) 'A)
 140          ((memq ,arg '(?b ?B)) 'B)
 141          ((memq ,arg '(?c ?C)) 'C)
 142          ))
 143
 144
 145 ;; A-list is supposed to be of the form (A . symb) (B . symb)...)
 146 ;; where the first part of any association is a buffer type and the second is
 147 ;; an appropriate symbol.  Given buffer-type, this function returns the
 148 ;; symbol.  This is used to avoid using `intern'
 149 (defsubst ediff-get-symbol-from-alist (buf-type alist)
 150   (cdr (assoc buf-type alist)))
 151
 152 (defconst ediff-difference-vector-alist
 153   '((A . ediff-difference-vector-A)
 154     (B . ediff-difference-vector-B)
 155     (C . ediff-difference-vector-C)
 156     (Ancestor . ediff-difference-vector-Ancestor)))
 157
 158 (defmacro ediff-get-difference (n buf-type)
 159   `(aref
 160     (symbol-value
 161      (ediff-get-symbol-from-alist
 162       ,buf-type ediff-difference-vector-alist))
 163     ,n))
 164
 165 ;; Tell if it has been previously determined that the region has
 166 ;; no diffs other than the white space and newlines
 167 ;; The argument, N, is the diff region number used by Ediff to index the
 168 ;; diff vector.  It is 1 less than the number seen by the user.
 169 ;; Returns:
 170 ;;              t  if the diffs are whitespace in all buffers
 171 ;;              'A (in 3-buf comparison only) if there are only whitespace
 172 ;;                 diffs in bufs B and C
 173 ;;              'B (in 3-buf comparison only) if there are only whitespace
 174 ;;                 diffs in bufs A and C
 175 ;;              'C (in 3-buf comparison only) if there are only whitespace
 176 ;;                 diffs in bufs A and B
 177 ;;
 178 ;; A Difference Vector has the form:
 179 ;; [diff diff diff ...]
 180 ;; where each diff has the form:
 181 ;; [overlay fine-diff-vector no-fine-diffs-flag state-of-difference]
 182 ;; fine-diff-vector is a vector [fine-diff fine-diff fine-diff ...]
 183 ;; no-fine-diffs-flag says if there are fine differences.
 184 ;; state-of-difference is A, B, C, or nil, indicating which buffer is
 185 ;;      different from the other two (used only in 3-way jobs).
 186 (defmacro ediff-no-fine-diffs-p (n)
 187   `(aref (ediff-get-difference ,n 'A) 2))
 188
 189 (defmacro ediff-get-diff-overlay-from-diff-record (diff-rec)
 190   `(aref ,diff-rec 0))
 191
 192 (defmacro ediff-get-diff-overlay (n buf-type)
 193   `(ediff-get-diff-overlay-from-diff-record
 194     (ediff-get-difference ,n ,buf-type)))
 195
 196 (defmacro ediff-get-fine-diff-vector-from-diff-record (diff-rec)
 197   `(aref ,diff-rec 1))
 198
 199 (defmacro ediff-set-fine-diff-vector (n buf-type fine-vec)
 200   `(aset (ediff-get-difference ,n ,buf-type) 1 ,fine-vec))
 201
 202 (defmacro ediff-get-state-of-diff (n buf-type)
 203   `(if (ediff-buffer-live-p ediff-buffer-C)
 204        (aref (ediff-get-difference ,n ,buf-type) 3)))
 205 (defmacro ediff-set-state-of-diff (n buf-type val)
 206   `(aset (ediff-get-difference ,n ,buf-type) 3 ,val))
 207
 208 (defmacro ediff-get-state-of-merge (n)
 209   `(if ediff-state-of-merge
 210        (aref (aref ediff-state-of-merge ,n) 0)))
 211 (defmacro ediff-set-state-of-merge (n val)
 212   `(if ediff-state-of-merge
 213        (aset (aref ediff-state-of-merge ,n) 0 ,val)))
 214
 215 (defmacro ediff-get-state-of-ancestor (n)
 216   `(if ediff-state-of-merge
 217        (aref (aref ediff-state-of-merge ,n) 1)))
 218
 219 ;; if flag is t, puts a mark on diff region saying that
 220 ;; the differences are in white space only.  If flag is nil,
 221 ;; the region is marked as essential (i.e., differences are
 222 ;; not just in the white space and newlines.)
 223 (defmacro ediff-mark-diff-as-space-only (n flag)
 224   `(aset (ediff-get-difference ,n 'A) 2 ,flag))
 225
 226 (defmacro ediff-get-fine-diff-vector (n buf-type)
 227   `(ediff-get-fine-diff-vector-from-diff-record
 228     (ediff-get-difference ,n ,buf-type)))
 229
 230 ;; Macro to switch to BUFFER, evaluate BODY, returns to original buffer.
 231 ;; Doesn't save the point and mark.
 232 ;; This is `with-current-buffer' with the added test for live buffers."
 233 (defmacro ediff-with-current-buffer (buffer &rest body)
 234   `(if (ediff-buffer-live-p ,buffer)
 235        (save-current-buffer
 236          (set-buffer ,buffer)
 237          ,@body)
 238      (or (eq this-command 'ediff-quit)
 239          (error ediff-KILLED-VITAL-BUFFER))
 240      ))
 241
 242
 243 (defsubst ediff-multiframe-setup-p ()
 244   (and (ediff-window-display-p) ediff-multiframe))
 245
 246 (defmacro ediff-narrow-control-frame-p ()
 247   `(and (ediff-multiframe-setup-p)
 248         (equal ediff-help-message ediff-brief-message-string)))
 249
 250 (defmacro ediff-3way-comparison-job ()
 251   `(memq
 252     ediff-job-name
 253     '(ediff-files3 ediff-buffers3)))
 254 (ediff-defvar-local ediff-3way-comparison-job nil "")
 255
 256 (defmacro ediff-merge-job ()
 257   `(memq
 258     ediff-job-name
 259     '(ediff-merge-files
 260       ediff-merge-buffers
 261       ediff-merge-files-with-ancestor
 262       ediff-merge-buffers-with-ancestor
 263       ediff-merge-revisions
 264       ediff-merge-revisions-with-ancestor)))
 265 (ediff-defvar-local ediff-merge-job nil "")
 266
 267 (defmacro ediff-merge-with-ancestor-job ()
 268   `(memq
 269     ediff-job-name
 270     '(ediff-merge-files-with-ancestor
 271       ediff-merge-buffers-with-ancestor
 272       ediff-merge-revisions-with-ancestor)))
 273 (ediff-defvar-local ediff-merge-with-ancestor-job nil "")
 274
 275 (defmacro ediff-3way-job ()
 276   `(or ediff-3way-comparison-job ediff-merge-job))
 277 (ediff-defvar-local ediff-3way-job nil "")
 278
 279 ;; A diff3 job is like a 3way job, but ediff-merge doesn't require the use
 280 ;; of diff3.
 281 (defmacro ediff-diff3-job ()
 282   `(or ediff-3way-comparison-job
 283        ediff-merge-with-ancestor-job))
 284 (ediff-defvar-local ediff-diff3-job nil "")
 285
 286 (defmacro ediff-windows-job ()
 287   `(memq ediff-job-name '(ediff-windows-wordwise ediff-windows-linewise)))
 288 (ediff-defvar-local ediff-windows-job nil "")
 289
 290 (defmacro ediff-word-mode-job ()
 291   `(memq ediff-job-name '(ediff-windows-wordwise ediff-regions-wordwise)))
 292 (ediff-defvar-local ediff-word-mode-job nil "")
 293
 294 (defmacro ediff-narrow-job ()
 295   `(memq ediff-job-name '(ediff-windows-wordwise
 296                           ediff-regions-wordwise
 297                           ediff-windows-linewise
 298                           ediff-regions-linewise)))
 299 (ediff-defvar-local ediff-narrow-job nil "")
 300
 301 ;; Note: ediff-merge-directory-revisions-with-ancestor is not treated as an
 302 ;; ancestor metajob, since it behaves differently.
 303 (defsubst ediff-ancestor-metajob (&optional metajob)
 304   (memq (or metajob ediff-metajob-name)
 305         '(ediff-merge-directories-with-ancestor
 306           ediff-merge-filegroups-with-ancestor)))
 307 (defsubst ediff-revision-metajob (&optional metajob)
 308   (memq (or metajob ediff-metajob-name)
 309         '(ediff-directory-revisions
 310           ediff-merge-directory-revisions
 311           ediff-merge-directory-revisions-with-ancestor)))
 312 (defsubst ediff-patch-metajob (&optional metajob)
 313   (memq (or metajob ediff-metajob-name)
 314         '(ediff-multifile-patch)))
 315 ;; metajob involving only one group of files, such as multipatch or directory
 316 ;; revision
 317 (defsubst ediff-one-filegroup-metajob (&optional metajob)
 318   (or (ediff-revision-metajob metajob)
 319       (ediff-patch-metajob metajob)
 320       ;; add more here
 321       ))
 322 (defsubst ediff-collect-diffs-metajob (&optional metajob)
 323   (memq (or metajob ediff-metajob-name)
 324         '(ediff-directories
 325           ediff-directory-revisions
 326           ediff-merge-directories
 327           ediff-merge-directories-with-ancestor
 328           ediff-merge-directory-revisions
 329           ediff-merge-directory-revisions-with-ancestor
 330           ;; add more here
 331           )))
 332 (defsubst ediff-merge-metajob (&optional metajob)
 333   (memq (or metajob ediff-metajob-name)
 334         '(ediff-merge-directories
 335           ediff-merge-directories-with-ancestor
 336           ediff-merge-directory-revisions
 337           ediff-merge-directory-revisions-with-ancestor
 338           ediff-merge-filegroups-with-ancestor
 339           ;; add more here
 340           )))
 341
 342 (defsubst ediff-metajob3 (&optional metajob)
 343   (memq (or metajob ediff-metajob-name)
 344         '(ediff-merge-directories-with-ancestor
 345           ediff-merge-filegroups-with-ancestor
 346           ediff-directories3
 347           ediff-filegroups3)))
 348 (defsubst ediff-comparison-metajob3 (&optional metajob)
 349   (memq (or metajob ediff-metajob-name)
 350         '(ediff-directories3 ediff-filegroups3)))
 351
 352 ;; with no argument, checks if we are in ediff-control-buffer
 353 ;; with argument, checks if we are in ediff-meta-buffer
 354 (defun ediff-in-control-buffer-p (&optional meta-buf-p)
 355   (and (boundp 'ediff-control-buffer)
 356        (eq (if meta-buf-p ediff-meta-buffer ediff-control-buffer)
 357            (current-buffer))))
 358
 359 (defsubst ediff-barf-if-not-control-buffer (&optional meta-buf-p)
 360   (or (ediff-in-control-buffer-p meta-buf-p)
 361       (error "%S: This command runs in Ediff Control Buffer only!"
 362              this-command)))
 363
 364 (defgroup ediff-highlighting nil
 365   "Hilighting of difference regions in Ediff"
 366   :prefix "ediff-"
 367   :group 'ediff)
 368
 369 (defgroup ediff-merge nil
 370   "Merging utilities"
 371   :prefix "ediff-"
 372   :group 'ediff)
 373
 374 (defgroup ediff-hook nil
 375   "Hooks run by Ediff"
 376   :prefix "ediff-"
 377   :group 'ediff)
 378
 379 ;; Hook variables
 380
 381 (defcustom ediff-before-setup-hook nil
 382   "*Hooks to run before Ediff begins to set up windows and buffers.
 383 This hook can be used to save the previous window config, which can be restored
 384 on ediff-quit or ediff-suspend."
 385   :type 'hook
 386   :group 'ediff-hook)
 387 (defcustom ediff-before-setup-windows-hook nil
 388   "*Hooks to run before Ediff sets its window configuration.
 389 This hook is run every time when Ediff arranges its windows.
 390 This happens each time Ediff detects that the windows were messed up by the
 391 user."
 392   :type 'hook
 393   :group 'ediff-hook)
 394 (defcustom ediff-after-setup-windows-hook nil
 395   "*Hooks to run after Ediff sets its window configuration.
 396 This can be used to set up control window or icon in a desired place."
 397   :type 'hook
 398   :group 'ediff-hook)
 399 (defcustom ediff-before-setup-control-frame-hook nil
 400   "*Hooks run before setting up the frame to display Ediff Control Panel.
 401 Can be used to change control frame parameters to position it where it
 402 is desirable."
 403   :type 'hook
 404   :group 'ediff-hook)
 405 (defcustom ediff-after-setup-control-frame-hook nil
 406   "*Hooks run after setting up the frame to display Ediff Control Panel.
 407 Can be used to move the frame where it is desired."
 408   :type 'hook
 409   :group 'ediff-hook)
 410 (defcustom ediff-startup-hook nil
 411   "*Hooks to run in the control buffer after Ediff has been set up and is ready for the job."
 412   :type 'hook
 413   :group 'ediff-hook)
 414 (defcustom ediff-select-hook nil
 415   "*Hooks to run after a difference has been selected."
 416   :type 'hook
 417   :group 'ediff-hook)
 418 (defcustom ediff-unselect-hook nil
 419   "*Hooks to run after a difference has been unselected."
 420   :type 'hook
 421   :group 'ediff-hook)
 422 (defcustom ediff-prepare-buffer-hook  nil
 423   "*Hooks run after buffers A, B, and C are set up.
 424 For each buffer, the hooks are run with that buffer made current."
 425   :type 'hook
 426   :group 'ediff-hook)
 427 (defcustom ediff-load-hook nil
 428   "*Hook run after Ediff is loaded.  Can be used to change defaults."
 429   :type 'hook
 430   :group 'ediff-hook)
 431
 432 (defcustom ediff-mode-hook nil
 433   "*Hook run just after ediff-mode is set up in the control buffer.
 434 This is done before any windows or frames are created.  One can use it to
 435 set local variables that determine how the display looks like."
 436   :type 'hook
 437   :group 'ediff-hook)
 438 (defcustom ediff-keymap-setup-hook nil
 439   "*Hook run just after the default bindings in Ediff keymap are set up."
 440   :type 'hook
 441   :group 'ediff-hook)
 442
 443 (defcustom ediff-display-help-hook nil
 444   "*Hooks run after preparing the help message."
 445   :type 'hook
 446   :group 'ediff-hook)
 447
 448 (defcustom ediff-suspend-hook nil
 449   "*Hooks to run in the Ediff control buffer when Ediff is suspended."
 450   :type 'hook
 451   :group 'ediff-hook)
 452 (defcustom ediff-quit-hook nil
 453   "*Hooks to run in the Ediff control buffer after finishing Ediff."
 454   :type 'hook
 455   :group 'ediff-hook)
 456 (defcustom ediff-cleanup-hook nil
 457   "*Hooks to run on exiting Ediff but before killing the control and variant buffers."
 458   :type 'hook
 459   :group 'ediff-hook)
 460
 461 ;; Error messages
 462 (defconst ediff-KILLED-VITAL-BUFFER
 463   "You have killed a vital Ediff buffer---you must leave Ediff now!")
 464 (defconst ediff-NO-DIFFERENCES
 465   "Sorry, comparison of identical variants is not what I am made for...")
 466 (defconst ediff-BAD-DIFF-NUMBER
 467   ;; %S stands for this-command, %d - diff number, %d - max diff
 468   "%S: Bad diff region number, %d.  Valid numbers are 1 to %d")
 469 (defconst ediff-BAD-INFO (format "
 470 *** The Info file for Ediff, a part of the standard distribution
 471 *** of %sEmacs, does not seem to be properly installed.
 472 ***
 473 *** Please contact your system administrator. "
 474                                  (if ediff-xemacs-p "X" "")))
 475
 476 ;; Selective browsing
 477
 478 (ediff-defvar-local ediff-skip-diff-region-function 'ediff-show-all-diffs
 479   "Function that determines the next/previous diff region to show.
 480 Should return t for regions to be ignored and nil otherwise.
 481 This function gets a region number as an argument.  The region number
 482 is the one used internally by Ediff.  It is 1 less than the number seen
 483 by the user.")
 484
 485 (ediff-defvar-local ediff-hide-regexp-matches-function
 486   'ediff-hide-regexp-matches
 487   "Function to use in determining which regions to hide.
 488 See the documentation string of `ediff-hide-regexp-matches' for details.")
 489 (ediff-defvar-local ediff-focus-on-regexp-matches-function
 490   'ediff-focus-on-regexp-matches
 491   "Function to use in determining which regions to focus on.
 492 See the documentation string of `ediff-focus-on-regexp-matches' for details.")
 493
 494 ;; Regexp that determines buf A regions to focus on when skipping to diff
 495 (ediff-defvar-local ediff-regexp-focus-A "" "")
 496 ;; Regexp that determines buf B regions to focus on when skipping to diff
 497 (ediff-defvar-local ediff-regexp-focus-B "" "")
 498 ;; Regexp that determines buf C regions to focus on when skipping to diff
 499 (ediff-defvar-local ediff-regexp-focus-C "" "")
 500 ;; connective that determines whether to focus regions that match both or
 501 ;; one of the regexps
 502 (ediff-defvar-local ediff-focus-regexp-connective 'and "")
 503
 504 ;; Regexp that determines buf A regions to ignore when skipping to diff
 505 (ediff-defvar-local ediff-regexp-hide-A "" "")
 506 ;; Regexp that determines buf B regions to ignore when skipping to diff
 507 (ediff-defvar-local ediff-regexp-hide-B "" "")
 508 ;; Regexp that determines buf C regions to ignore when skipping to diff
 509 (ediff-defvar-local ediff-regexp-hide-C "" "")
 510 ;; connective that determines whether to hide regions that match both or
 511 ;; one of the regexps
 512 (ediff-defvar-local ediff-hide-regexp-connective 'and "")
 513
 514
 515 ;;; Copying difference regions between buffers.
 516
 517 ;; A list of killed diffs.
 518 ;; A diff is saved here if it is replaced by a diff
 519 ;; from another buffer.  This alist has the form:
 520 ;; \((num (buff-object . diff) (buff-object . diff) (buff-object . diff)) ...),
 521 ;; where some buffer-objects may be missing.
 522 (ediff-defvar-local ediff-killed-diffs-alist nil "")
 523
 524 ;; Syntax table to use in ediff-forward-word-function
 525 ;; This is chosen by a heuristic. The important thing is for all buffers to
 526 ;; have the same syntax table. Which is not too important.
 527 (ediff-defvar-local ediff-syntax-table nil "")
 528
 529
 530 ;; Highlighting
 531 (defcustom ediff-before-flag-bol (if ediff-xemacs-p (make-glyph "->>") "->>")
 532   "*Flag placed before a highlighted block of differences, if block starts at beginning of a line."
 533   :type 'string
 534   :tag  "Region before-flag at beginning of line"
 535   :group 'ediff)
 536
 537 (defcustom ediff-after-flag-eol  (if ediff-xemacs-p (make-glyph "<<-") "<<-")
 538   "*Flag placed after a highlighted block of differences, if block ends at end of a line."
 539   :type 'string
 540   :tag  "Region after-flag at end of line"
 541   :group 'ediff)
 542
 543 (defcustom ediff-before-flag-mol (if ediff-xemacs-p (make-glyph "->>") "->>")
 544   "*Flag placed before a highlighted block of differences, if block starts in mid-line."
 545   :type 'string
 546   :tag  "Region before-flag in the middle of line"
 547   :group 'ediff)
 548 (defcustom ediff-after-flag-mol  (if ediff-xemacs-p (make-glyph "<<-") "<<-")
 549   "*Flag placed after a highlighted block of differences, if block ends in mid-line."
 550   :type 'string
 551   :tag  "Region after-flag in the middle of line"
 552   :group 'ediff)
 553
 554
 555 (ediff-defvar-local ediff-use-faces t "")
 556 (defcustom ediff-use-faces t
 557   "If t, differences are highlighted using faces, if device supports faces.
 558 If nil, differences are highlighted using ASCII flags, ediff-before-flag
 559 and ediff-after-flag.  On a non-window system, differences are always
 560 highlighted using ASCII flags."
 561   :type 'boolean
 562   :group 'ediff-highlighting)
 563
 564 ;; this indicates that diff regions are word-size, so fine diffs are
 565 ;; permanently nixed; used in ediff-windows-wordwise and ediff-regions-wordwise
 566 (ediff-defvar-local ediff-word-mode nil "")
 567 ;; Name of the job (ediff-files, ediff-windows, etc.)
 568 (ediff-defvar-local ediff-job-name nil "")
 569
 570 ;; Narrowing and ediff-region/windows support
 571 ;; This is a list (overlay-A overlay-B overlay-C)
 572 ;; If set, Ediff compares only those parts of buffers A/B/C that lie within
 573 ;; the bounds of these overlays.
 574 (ediff-defvar-local ediff-narrow-bounds nil "")
 575
 576 ;; List (overlay-A overlay-B overlay-C), where each overlay spans the
 577 ;; entire corresponding buffer.
 578 (ediff-defvar-local ediff-wide-bounds nil "")
 579
 580 ;; Current visibility boundaries in buffers A, B, and C.
 581 ;; This is also a list of overlays.  When the user toggles narrow/widen,
 582 ;; this list changes from ediff-wide-bounds to ediff-narrow-bounds.
 583 ;; and back.
 584 (ediff-defvar-local ediff-visible-bounds nil "")
 585
 586 (ediff-defvar-local ediff-start-narrowed t
 587   "Non-nil means start narrowed, if doing ediff-windows-* or ediff-regions-*")
 588 (ediff-defvar-local ediff-quit-widened t
 589   "*Non-nil means: when finished, Ediff widens buffers A/B.
 590 Actually, Ediff restores the scope of visibility that existed at startup.")
 591
 592 (defcustom ediff-keep-variants t
 593   "*Nil means that non-modified variant buffers should be removed at the end of the session after some interrogation.
 594 Supplying a prefix argument to the quit command `q' temporarily reverses the
 595 meaning of this variable."
 596   :type 'boolean
 597   :group 'ediff)
 598
 599 (ediff-defvar-local ediff-highlight-all-diffs t "")
 600 (defcustom ediff-highlight-all-diffs t
 601   "If nil, only the selected differences are highlighted.
 602 Otherwise, all difference regions are highlighted, but the selected region is
 603 shown in brighter colors."
 604   :type 'boolean
 605   :group 'ediff-highlighting)
 606
 607 ;; A var local to each control panel buffer.  Indicates highlighting style
 608 ;; in effect for this buffer: `face', `ascii', nil -- temporarily
 609 ;; unhighlighted, `off' -- turned off \(on a dumb terminal only\).
 610 (ediff-defvar-local ediff-highlighting-style nil "")
 611
 612
 613 ;; The suffix of the control buffer name.
 614 (ediff-defvar-local ediff-control-buffer-suffix nil "")
 615 ;; Same as ediff-control-buffer-suffix, but without <,>.
 616 ;; It's a number rather than string.
 617 (ediff-defvar-local ediff-control-buffer-number nil "")
 618
 619
 620 ;; The original values of ediff-protected-variables for buffer A
 621 (ediff-defvar-local ediff-buffer-values-orig-A nil "")
 622 ;; The original values of ediff-protected-variables for buffer B
 623 (ediff-defvar-local ediff-buffer-values-orig-B nil "")
 624 ;; The original values of ediff-protected-variables for buffer C
 625 (ediff-defvar-local ediff-buffer-values-orig-C nil "")
 626 ;; The original values of ediff-protected-variables for buffer Ancestor
 627 (ediff-defvar-local ediff-buffer-values-orig-Ancestor nil "")
 628
 629 ;; association between buff-type and ediff-buffer-values-orig-*
 630 (defconst ediff-buffer-values-orig-alist
 631   '((A . ediff-buffer-values-orig-A)
 632     (B . ediff-buffer-values-orig-B)
 633     (C . ediff-buffer-values-orig-C)
 634     (Ancestor . ediff-buffer-values-orig-Ancestor)))
 635
 636 ;; Buffer-local variables to be saved then restored during Ediff sessions
 637 (defconst ediff-protected-variables '(
 638                                       ;;buffer-read-only
 639                                       mode-line-format))
 640
 641 ;; Vector of differences between the variants.  Each difference is
 642 ;; represented by a vector of two overlays plus a vector of fine diffs,
 643 ;; plus a no-fine-diffs flag.  The first overlay spans the
 644 ;; difference region in the A buffer and the second overlays the diff in
 645 ;; the B buffer.  If a difference section is empty, the corresponding
 646 ;; overlay's endpoints coincide.
 647 ;;
 648 ;; The precise form of a Difference Vector for one buffer is:
 649 ;; [diff diff diff ...]
 650 ;; where each diff has the form:
 651 ;; [diff-overlay fine-diff-vector no-fine-diffs-flag state-of-diff]
 652 ;; fine-diff-vector is a vector [fine-diff-overlay fine-diff-overlay ...]
 653 ;; no-fine-diffs-flag says if there are fine differences.
 654 ;; state-of-difference is A, B, C, or nil, indicating which buffer is
 655 ;;      different from the other two (used only in 3-way jobs.
 656 (ediff-defvar-local ediff-difference-vector-A nil "")
 657 (ediff-defvar-local ediff-difference-vector-B nil "")
 658 (ediff-defvar-local ediff-difference-vector-C nil "")
 659 (ediff-defvar-local ediff-difference-vector-Ancestor nil "")
 660 ;; A-list of diff vector types associated with buffer types
 661 (defconst ediff-difference-vector-alist
 662   '((A . ediff-difference-vector-A)
 663     (B . ediff-difference-vector-B)
 664     (C . ediff-difference-vector-C)
 665     (Ancestor . ediff-difference-vector-Ancestor)))
 666
 667 ;; [ status status status ...]
 668 ;; Each status: [state-of-merge state-of-ancestor]
 669 ;; state-of-merge is default-A, default-B, prefer-A, or prefer-B.  It
 670 ;; indicates the way a diff region was created in buffer C.
 671 ;; state-of-ancestor says if the corresponding region in ancestor buffer is
 672 ;; empty.
 673 (ediff-defvar-local ediff-state-of-merge nil "")
 674
 675 ;; The difference that is currently selected.
 676 (ediff-defvar-local ediff-current-difference -1 "")
 677 ;; Number of differences found.
 678 (ediff-defvar-local ediff-number-of-differences nil "")
 679
 680 ;; Buffer containing the output of diff, which is used by Ediff to step
 681 ;; through files.
 682 (ediff-defvar-local ediff-diff-buffer nil "")
 683 ;; Like ediff-diff-buffer, but contains context diff.  It is not used by
 684 ;; Ediff, but it is saved in a file, if user requests so.
 685 (ediff-defvar-local ediff-custom-diff-buffer nil "")
 686 ;; Buffer used for diff-style fine differences between regions.
 687 (ediff-defvar-local ediff-fine-diff-buffer nil "")
 688 ;; Temporary buffer used for computing fine differences.
 689 (defconst ediff-tmp-buffer " *ediff-tmp*" "")
 690 ;; Buffer used for messages
 691 (defconst ediff-msg-buffer " *ediff-message*" "")
 692 ;; Buffer containing the output of diff when diff returns errors.
 693 (ediff-defvar-local ediff-error-buffer nil "")
 694 ;; Buffer to display debug info
 695 (ediff-defvar-local ediff-debug-buffer "*ediff-debug*" "")
 696
 697 ;; List of ediff control panels associated with each buffer A/B/C/Ancestor.
 698 ;; Not used any more, but may be needed in the future.
 699 (ediff-defvar-local ediff-this-buffer-ediff-sessions  nil "")
 700
 701 ;; to be deleted in due time
 702 ;; List of difference overlays disturbed by working with the current diff.
 703 (defvar ediff-disturbed-overlays nil "")
 704
 705 ;; Priority of non-selected overlays.
 706 (defvar ediff-shadow-overlay-priority  100 "")
 707
 708 (defcustom ediff-version-control-package 'vc
 709   "Version control package used.
 710 Currently, Ediff supports vc.el, rcs.el, pcl-cvs.el, and generic-sc.el.  The
 711 standard Emacs interface to RCS, CVS, SCCS, etc., is vc.el.  However, some
 712 people find the other two packages more convenient.  Set this variable to the
 713 appropriate symbol: `rcs', `pcl-cvs', or `generic-sc' if you so desire."
 714   :type 'symbol
 715   :group 'ediff)
 716
 717 (defcustom ediff-coding-system-for-read 'raw-text
 718   "*The coding system for read to use when running the diff program as a subprocess.
 719 In most cases, the default will do. However, under certain circumstances in
 720 Windows NT/98/95 you might need to use something like 'raw-text-dos here.
 721 So, if the output that your diff program sends to Emacs contains extra ^M's,
 722 you might need to experiment here, if the default or 'raw-text-dos doesn't
 723 work."
 724   :type 'symbol
 725   :group 'ediff)
 726
 727 (defcustom ediff-coding-system-for-write 'no-conversion
 728   "*The coding system for write to use when writing out difference regions
 729 to temp files when Ediff needs to find fine differences."
 730   :type 'symbol
 731   :group 'ediff)
 732
 733
 734 (if ediff-xemacs-p
 735     (progn
 736       (fset 'ediff-read-event (symbol-function 'next-command-event))
 737       (fset 'ediff-overlayp (symbol-function 'extentp))
 738       (fset 'ediff-make-overlay (symbol-function 'make-extent))
 739       (fset 'ediff-delete-overlay (symbol-function 'delete-extent)))
 740   (fset 'ediff-read-event (symbol-function 'read-event))
 741   (fset 'ediff-overlayp (symbol-function 'overlayp))
 742   (fset 'ediff-make-overlay (symbol-function 'make-overlay))
 743   (fset 'ediff-delete-overlay (symbol-function 'delete-overlay)))
 744
 745 ;; Check the current version against the major and minor version numbers
 746 ;; using op: cur-vers op major.minor If emacs-major-version or
 747 ;; emacs-minor-version are not defined, we assume that the current version
 748 ;; is hopelessly outdated.  We assume that emacs-major-version and
 749 ;; emacs-minor-version are defined.  Otherwise, for Emacs/XEmacs 19, if the
 750 ;; current minor version is < 10 (xemacs) or < 23 (emacs) the return value
 751 ;; will be nil (when op is =, >, or >=) and t (when op is <, <=), which may be
 752 ;; incorrect.  However, this gives correct result in our cases, since we are
 753 ;; testing for sufficiently high Emacs versions.
 754 (defun ediff-check-version (op major minor &optional type-of-emacs)
 755   (if (and (boundp 'emacs-major-version) (boundp 'emacs-minor-version))
 756       (and (cond ((eq type-of-emacs 'xemacs) ediff-xemacs-p)
 757                  ((eq type-of-emacs 'emacs) ediff-emacs-p)
 758                  (t t))
 759            (cond ((eq op '=) (and (= emacs-minor-version minor)
 760                                   (= emacs-major-version major)))
 761                  ((memq op '(> >= < <=))
 762                   (and (or (funcall op emacs-major-version major)
 763                            (= emacs-major-version major))
 764                        (if (= emacs-major-version major)
 765                            (funcall op emacs-minor-version minor)
 766                          t)))
 767                  (t
 768                   (error "%S: Invalid op in ediff-check-version" op))))
 769     (cond ((memq op '(= > >=)) nil)
 770           ((memq op '(< <=)) t))))
 771
 772
 773 (defun ediff-color-display-p ()
 774   (condition-case nil
 775       (if ediff-emacs-p
 776           (if (fboundp 'display-color-p)
 777               (display-color-p)
 778             (x-display-color-p))
 779         (eq (device-class (selected-device)) 'color))
 780     (error
 781      nil)))
 782
 783
 784 (if (ediff-has-face-support-p)
 785     (if ediff-xemacs-p
 786         (progn
 787           (fset 'ediff-valid-color-p (symbol-function 'valid-color-name-p))
 788           (fset 'ediff-get-face (symbol-function 'get-face)))
 789       (fset 'ediff-valid-color-p (symbol-function
 790                                   (if (fboundp 'color-defined-p)
 791                                       'color-defined-p
 792                                     'x-color-defined-p)))
 793       (fset 'ediff-get-face (symbol-function 'internal-get-face))))
 794
 795 (if (ediff-window-display-p)
 796     (if ediff-xemacs-p
 797         (progn
 798           (fset 'ediff-display-pixel-width
 799                 (symbol-function 'device-pixel-width))
 800           (fset 'ediff-display-pixel-height
 801                 (symbol-function 'device-pixel-height)))
 802       (fset 'ediff-display-pixel-width (symbol-function
 803                                         (if (fboundp 'display-pixel-width)
 804                                             'display-pixel-width
 805                                           'x-display-pixel-width)))
 806       (fset 'ediff-display-pixel-height (symbol-function
 807                                          (if (fboundp 'display-pixel-height)
 808                                              'display-pixel-height
 809                                            'x-display-pixel-height)))))
 810
 811 ;; A-list of current-diff-overlay symbols associated with buf types
 812 (defconst ediff-current-diff-overlay-alist
 813   '((A . ediff-current-diff-overlay-A)
 814     (B . ediff-current-diff-overlay-B)
 815     (C . ediff-current-diff-overlay-C)
 816     (Ancestor . ediff-current-diff-overlay-Ancestor)))
 817
 818 ;; A-list of current-diff-face-* symbols associated with buf types
 819 (defconst ediff-current-diff-face-alist
 820   '((A . ediff-current-diff-face-A)
 821     (B . ediff-current-diff-face-B)
 822     (C . ediff-current-diff-face-C)
 823     (Ancestor . ediff-current-diff-face-Ancestor)))
 824
 825
 826 (defun ediff-make-current-diff-overlay (type)
 827   (if (ediff-has-face-support-p)
 828       (let ((overlay (ediff-get-symbol-from-alist
 829                       type ediff-current-diff-overlay-alist))
 830             (buffer (ediff-get-buffer type))
 831             (face (face-name
 832                    (symbol-value
 833                     (ediff-get-symbol-from-alist
 834                      type ediff-current-diff-face-alist)))))
 835         (set overlay
 836              (ediff-make-bullet-proof-overlay (point-max) (point-max) buffer))
 837         (ediff-set-overlay-face (symbol-value overlay) face)
 838         (ediff-overlay-put (symbol-value overlay) 'ediff ediff-control-buffer))
 839     ))
 840
 841 (defun ediff-set-overlay-face (extent face)
 842   (ediff-overlay-put extent 'face face)
 843   (ediff-overlay-put extent 'help-echo 'ediff-region-help-echo))
 844
 845 (defun ediff-region-help-echo (extent-or-window &optional overlay point)
 846   (unless overlay
 847     (setq overlay extent-or-window))
 848   (let ((is-current (ediff-overlay-get overlay 'ediff))
 849         (face (ediff-overlay-get overlay 'face))
 850         (diff-num (ediff-overlay-get overlay 'ediff-diff-num))
 851         face-help)
 852
 853     ;; This happens only for refinement overlays
 854     (if (stringp face)
 855         (setq face (intern face)))
 856     (setq face-help (and face (get face 'ediff-help-echo)))
 857
 858     (cond ((and is-current diff-num)    ; current diff region
 859            (format "Difference region %S -- current" (1+ diff-num)))
 860           (face-help)                   ; refinement of current diff region
 861           (diff-num                     ; non-current
 862            (format "Difference region %S -- non-current" (1+ diff-num)))
 863           (t ""))                       ; none
 864     ))
 865
 866
 867 (defun ediff-set-face-pixmap (face pixmap)
 868   "Set face pixmap on a monochrome display."
 869   (if (and (ediff-window-display-p) (not (ediff-color-display-p)))
 870       (condition-case nil
 871           (set-face-background-pixmap face pixmap)
 872         (error
 873          (message "Pixmap not found for %S: %s" (face-name face) pixmap)
 874          (sit-for 1)))))
 875
 876 (defun ediff-hide-face (face)
 877   (if (and (ediff-has-face-support-p) ediff-emacs-p)
 878       (add-to-list 'facemenu-unlisted-faces face)))
 879
 880
 881
 882 (defface ediff-current-diff-face-A
 883   '((((class color)) (:foreground "firebrick" :background "pale green"))
 884     (t (:inverse-video t)))
 885   "Face for highlighting the selected difference in buffer A."
 886   :group 'ediff-highlighting)
 887 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 888 ;; this variable is set to nil, then again to the appropriate face.
 889 (defvar ediff-current-diff-face-A 'ediff-current-diff-face-A
 890   "Face for highlighting the selected difference in buffer A.
 891 DO NOT CHANGE this variable.  Instead, use the customization
 892 widget to customize the actual face object `ediff-current-diff-face-A'
 893 this variable represents.")
 894 (ediff-hide-face 'ediff-current-diff-face-A)
 895 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 896 ;; This means that some user customization may be trashed.
 897 (if (and ediff-xemacs-p
 898          (ediff-has-face-support-p)
 899          (not (ediff-color-display-p)))
 900     (copy-face 'modeline 'ediff-current-diff-face-A))
 901
 902
 903
 904 (defface ediff-current-diff-face-B
 905   '((((class color)) (:foreground "DarkOrchid" :background "Yellow"))
 906     (t (:inverse-video t)))
 907   "Face for highlighting the selected difference in buffer B."
 908   :group 'ediff-highlighting)
 909 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 910 ;; this variable is set to nil, then again to the appropriate face.
 911 (defvar ediff-current-diff-face-B 'ediff-current-diff-face-B
 912   "Face for highlighting the selected difference in buffer B.
 913  this variable.  Instead, use the customization
 914 widget to customize the actual face `ediff-current-diff-face-B'
 915 this variable represents.")
 916 (ediff-hide-face 'ediff-current-diff-face-B)
 917 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 918 ;; This means that some user customization may be trashed.
 919 (if (and ediff-xemacs-p
 920          (ediff-has-face-support-p)
 921          (not (ediff-color-display-p)))
 922     (copy-face 'modeline 'ediff-current-diff-face-B))
 923
 924
 925 (defface ediff-current-diff-face-C
 926   '((((class color)) (:foreground "Navy" :background "Pink"))
 927     (t (:inverse-video t)))
 928   "Face for highlighting the selected difference in buffer C."
 929   :group 'ediff-highlighting)
 930 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 931 ;; this variable is set to nil, then again to the appropriate face.
 932 (defvar ediff-current-diff-face-C 'ediff-current-diff-face-C
 933   "Face for highlighting the selected difference in buffer C.
 934 DO NOT CHANGE this variable.  Instead, use the customization
 935 widget to customize the actual face object `ediff-current-diff-face-C'
 936 this variable represents.")
 937 (ediff-hide-face 'ediff-current-diff-face-C)
 938 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 939 ;; This means that some user customization may be trashed.
 940 (if (and ediff-xemacs-p
 941          (ediff-has-face-support-p)
 942          (not (ediff-color-display-p)))
 943     (copy-face 'modeline 'ediff-current-diff-face-C))
 944
 945
 946 (defface ediff-current-diff-face-Ancestor
 947   '((((class color)) (:foreground "Black" :background "VioletRed"))
 948     (t (:inverse-video t)))
 949   "Face for highlighting the selected difference in buffer Ancestor."
 950   :group 'ediff-highlighting)
 951 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 952 ;; this variable is set to nil, then again to the appropriate face.
 953 (defvar ediff-current-diff-face-Ancestor 'ediff-current-diff-face-Ancestor
 954   "Face for highlighting the selected difference in buffer Ancestor.
 955 DO NOT CHANGE this variable.  Instead, use the customization
 956 widget to customize the actual face object `ediff-current-diff-face-Ancestor'
 957 this variable represents.")
 958 (ediff-hide-face 'ediff-current-diff-face-Ancestor)
 959 ;; Until custom.el for XEmacs starts supporting :inverse-video we do this.
 960 ;; This means that some user customization may be trashed.
 961 (if (and ediff-xemacs-p
 962          (ediff-has-face-support-p)
 963          (not (ediff-color-display-p)))
 964     (copy-face 'modeline 'ediff-current-diff-face-Ancestor))
 965
 966
 967 (defface ediff-fine-diff-face-A
 968   '((((class color)) (:foreground "Navy" :background "sky blue"))
 969     (t (:underline t :stipple "gray3")))
 970   "Face for highlighting the refinement of the selected diff in buffer A."
 971   :group 'ediff-highlighting)
 972 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 973 ;; this variable is set to nil, then again to the appropriate face.
 974 (defvar ediff-fine-diff-face-A 'ediff-fine-diff-face-A
 975   "Face for highlighting the fine differences in buffer A.
 976 DO NOT CHANGE this variable.  Instead, use the customization
 977 widget to customize the actual face object `ediff-fine-diff-face-A'
 978 this variable represents.")
 979 (ediff-hide-face 'ediff-fine-diff-face-A)
 980
 981 (defface ediff-fine-diff-face-B
 982   '((((class color)) (:foreground "Black" :background "cyan"))
 983     (t (:underline t :stipple "gray3")))
 984   "Face for highlighting the refinement of the selected diff in buffer B."
 985   :group 'ediff-highlighting)
 986 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
 987 ;; this variable is set to nil, then again to the appropriate face.
 988 (defvar ediff-fine-diff-face-B 'ediff-fine-diff-face-B
 989   "Face for highlighting the fine differences in buffer B.
 990 DO NOT CHANGE this variable.  Instead, use the customization
 991 widget to customize the actual face object `ediff-fine-diff-face-B'
 992 this variable represents.")
 993 (ediff-hide-face 'ediff-fine-diff-face-B)
 994
 995 (defface ediff-fine-diff-face-C
 996   '((((class color)) (:foreground "Black" :background "Turquoise"))
 997     (t (:underline t :stipple "gray3")))
 998   "Face for highlighting the refinement of the selected diff in buffer C."
 999   :group 'ediff-highlighting)
1000 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1001 ;; this variable is set to nil, then again to the appropriate face.
1002 (defvar ediff-fine-diff-face-C 'ediff-fine-diff-face-C
1003   "Face for highlighting the fine differences in buffer C.
1004 DO NOT CHANGE this variable.  Instead, use the customization
1005 widget to customize the actual face object `ediff-fine-diff-face-C'
1006 this variable represents.")
1007 (ediff-hide-face 'ediff-fine-diff-face-C)
1008
1009 (defface ediff-fine-diff-face-Ancestor
1010   '((((class color)) (:foreground "Black" :background "Green"))
1011     (t (:underline t :stipple "gray3")))
1012   "Face for highlighting the refinement of the selected diff in the ancestor buffer.
1013 At present, this face is not used and no fine differences are computed for the
1014 ancestor buffer."
1015   :group 'ediff-highlighting)
1016 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1017 ;; this variable is set to nil, then again to the appropriate face.
1018 (defvar ediff-fine-diff-face-Ancestor 'ediff-fine-diff-face-Ancestor
1019   "Face for highlighting the fine differences in buffer Ancestor.
1020 DO NOT CHANGE this variable.  Instead, use the customization
1021 widget to customize the actual face object `ediff-fine-diff-face-Ancestor'
1022 this variable represents.")
1023 (ediff-hide-face 'ediff-fine-diff-face-Ancestor)
1024
1025 ;; Some installs don't have stipple or Stipple. So, try them in turn.
1026 (defvar stipple-pixmap
1027   (cond ((not (ediff-has-face-support-p)) nil)
1028         ((and (boundp 'x-bitmap-file-path)
1029               (locate-library "stipple" t x-bitmap-file-path)) "stipple")
1030         ((and (boundp 'mswindowsx-bitmap-file-path)
1031               (locate-library "stipple" t mswindowsx-bitmap-file-path)) "stipple")
1032         (t "Stipple")))
1033
1034 (defface ediff-even-diff-face-A
1035   `((((class color)) (:foreground "Black" :background "light grey"))
1036     (t (:italic t :stipple ,stipple-pixmap)))
1037   "Face for highlighting even-numbered non-current differences in buffer A."
1038   :group 'ediff-highlighting)
1039 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1040 ;; this variable is set to nil, then again to the appropriate face.
1041 (defvar ediff-even-diff-face-A 'ediff-even-diff-face-A
1042   "Face for highlighting even-numbered non-current differences in buffer A.
1043 DO NOT CHANGE this variable.  Instead, use the customization
1044 widget to customize the actual face object `ediff-even-diff-face-A'
1045 this variable represents.")
1046 (ediff-hide-face 'ediff-even-diff-face-A)
1047
1048 (defface ediff-even-diff-face-B
1049   `((((class color)) (:foreground "White" :background "Grey"))
1050     (t (:italic t :stipple ,stipple-pixmap)))
1051   "Face for highlighting even-numbered non-current differences in buffer B."
1052   :group 'ediff-highlighting)
1053 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1054 ;; this variable is set to nil, then again to the appropriate face.
1055 (defvar ediff-even-diff-face-B 'ediff-even-diff-face-B
1056   "Face for highlighting even-numbered non-current differences in buffer B.
1057 DO NOT CHANGE this variable.  Instead, use the customization
1058 widget to customize the actual face object `ediff-even-diff-face-B'
1059 this variable represents.")
1060 (ediff-hide-face 'ediff-even-diff-face-B)
1061
1062 (defface ediff-even-diff-face-C
1063   `((((class color)) (:foreground "Black" :background "light grey"))
1064     (t (:italic t :stipple ,stipple-pixmap)))
1065   "Face for highlighting even-numbered non-current differences in buffer C."
1066   :group 'ediff-highlighting)
1067 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1068 ;; this variable is set to nil, then again to the appropriate face.
1069 (defvar ediff-even-diff-face-C 'ediff-even-diff-face-C
1070   "Face for highlighting even-numbered non-current differences in buffer C.
1071 DO NOT CHANGE this variable.  Instead, use the customization
1072 widget to customize the actual face object `ediff-even-diff-face-C'
1073 this variable represents.")
1074 (ediff-hide-face 'ediff-even-diff-face-C)
1075
1076 (defface ediff-even-diff-face-Ancestor
1077   `((((class color)) (:foreground "White" :background "Grey"))
1078     (t (:italic t :stipple ,stipple-pixmap)))
1079   "Face for highlighting even-numbered non-current differences in the ancestor buffer."
1080   :group 'ediff-highlighting)
1081 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1082 ;; this variable is set to nil, then again to the appropriate face.
1083 (defvar ediff-even-diff-face-Ancestor 'ediff-even-diff-face-Ancestor
1084   "Face for highlighting even-numbered non-current differences in buffer Ancestor.
1085 DO NOT CHANGE this variable.  Instead, use the customization
1086 widget to customize the actual face object `ediff-even-diff-face-Ancestor'
1087 this variable represents.")
1088 (ediff-hide-face 'ediff-even-diff-face-Ancestor)
1089
1090 ;; Association between buffer types and even-diff-face symbols
1091 (defconst ediff-even-diff-face-alist
1092   '((A . ediff-even-diff-face-A)
1093     (B . ediff-even-diff-face-B)
1094     (C . ediff-even-diff-face-C)
1095     (Ancestor . ediff-even-diff-face-Ancestor)))
1096
1097 (defface ediff-odd-diff-face-A
1098   '((((class color)) (:foreground "White" :background "Grey"))
1099     (t (:italic t :stipple "gray1")))
1100   "Face for highlighting odd-numbered non-current differences in buffer A."
1101   :group 'ediff-highlighting)
1102 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1103 ;; this variable is set to nil, then again to the appropriate face.
1104 (defvar ediff-odd-diff-face-A 'ediff-odd-diff-face-A
1105   "Face for highlighting odd-numbered non-current differences in buffer A.
1106 DO NOT CHANGE this variable.  Instead, use the customization
1107 widget to customize the actual face object `ediff-odd-diff-face-A'
1108 this variable represents.")
1109 (ediff-hide-face 'ediff-odd-diff-face-A)
1110
1111
1112 (defface ediff-odd-diff-face-B
1113   '((((class color)) (:foreground "Black" :background "light grey"))
1114     (t (:italic t :stipple "gray1")))
1115   "Face for highlighting odd-numbered non-current differences in buffer B."
1116   :group 'ediff-highlighting)
1117 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1118 ;; this variable is set to nil, then again to the appropriate face.
1119 (defvar ediff-odd-diff-face-B 'ediff-odd-diff-face-B
1120   "Face for highlighting odd-numbered non-current differences in buffer B.
1121 DO NOT CHANGE this variable.  Instead, use the customization
1122 widget to customize the actual face object `ediff-odd-diff-face-B'
1123 this variable represents.")
1124 (ediff-hide-face 'ediff-odd-diff-face-B)
1125
1126 (defface ediff-odd-diff-face-C
1127   '((((class color)) (:foreground "White" :background "Grey"))
1128     (t (:italic t :stipple "gray1")))
1129   "Face for highlighting odd-numbered non-current differences in buffer C."
1130   :group 'ediff-highlighting)
1131 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1132 ;; this variable is set to nil, then again to the appropriate face.
1133 (defvar ediff-odd-diff-face-C 'ediff-odd-diff-face-C
1134   "Face for highlighting odd-numbered non-current differences in buffer C.
1135 DO NOT CHANGE this variable.  Instead, use the customization
1136 widget to customize the actual face object `ediff-odd-diff-face-C'
1137 this variable represents.")
1138 (ediff-hide-face 'ediff-odd-diff-face-C)
1139
1140 (defface ediff-odd-diff-face-Ancestor
1141   '((((class color)) (:foreground "Black" :background "light grey"))
1142     (t (:italic t :stipple "gray1")))
1143   "Face for highlighting odd-numbered non-current differences in the ancestor buffer."
1144   :group 'ediff-highlighting)
1145 ;; An internal variable.  Ediff takes the face from here.  When unhighlighting,
1146 ;; this variable is set to nil, then again to the appropriate face.
1147 (defvar ediff-odd-diff-face-Ancestor 'ediff-odd-diff-face-Ancestor
1148   "Face for highlighting odd-numbered non-current differences in buffer Ancestor.
1149 DO NOT CHANGE this variable.  Instead, use the customization
1150 widget to customize the actual face object `ediff-odd-diff-face-Ancestor'
1151 this variable represents.")
1152 (ediff-hide-face 'ediff-odd-diff-face-Ancestor)
1153
1154 ;; Association between buffer types and odd-diff-face symbols
1155 (defconst ediff-odd-diff-face-alist
1156   '((A . ediff-odd-diff-face-A)
1157     (B . ediff-odd-diff-face-B)
1158     (C . ediff-odd-diff-face-C)
1159     (Ancestor . ediff-odd-diff-face-Ancestor)))
1160
1161 ;; A-list of fine-diff face symbols associated with buffer types
1162 (defconst ediff-fine-diff-face-alist
1163   '((A . ediff-fine-diff-face-A)
1164     (B . ediff-fine-diff-face-B)
1165     (C . ediff-fine-diff-face-C)
1166     (Ancestor . ediff-fine-diff-face-Ancestor)))
1167
1168 ;; Help echo
1169 (put 'ediff-fine-diff-face-A 'ediff-help-echo
1170      "A `refinement' of the current difference region")
1171 (put 'ediff-fine-diff-face-B 'ediff-help-echo
1172      "A `refinement' of the current difference region")
1173 (put 'ediff-fine-diff-face-C 'ediff-help-echo
1174      "A `refinement' of the current difference region")
1175 (put 'ediff-fine-diff-face-Ancestor 'ediff-help-echo
1176      "A `refinement' of the current difference region")
1177
1178 (add-hook 'ediff-quit-hook 'ediff-cleanup-mess)
1179 (add-hook 'ediff-suspend-hook 'ediff-default-suspend-function)
1180
1181
1182 ;;; Overlays
1183
1184 (ediff-defvar-local ediff-current-diff-overlay-A nil
1185   "Overlay for the current difference region in buffer A.")
1186 (ediff-defvar-local ediff-current-diff-overlay-B nil
1187   "Overlay for the current difference region in buffer B.")
1188 (ediff-defvar-local ediff-current-diff-overlay-C nil
1189   "Overlay for the current difference region in buffer C.")
1190 (ediff-defvar-local ediff-current-diff-overlay-Ancestor nil
1191   "Overlay for the current difference region in the ancestor buffer.")
1192
1193 ;; Compute priority of a current ediff overlay.
1194 (defun ediff-highest-priority (start end buffer)
1195   (let ((pos (max 1 (1- start)))
1196         ovr-list)
1197     (if ediff-xemacs-p
1198         (1+ ediff-shadow-overlay-priority)
1199       (ediff-with-current-buffer buffer
1200         (while (< pos (min (point-max) (1+ end)))
1201           (setq ovr-list (append (overlays-at pos) ovr-list))
1202           (setq pos (next-overlay-change pos)))
1203         (+ 1 ediff-shadow-overlay-priority
1204            (apply 'max
1205                   (mapcar
1206                    (lambda (ovr)
1207                      (if (and ovr
1208                               ;; exclude ediff overlays from priority
1209                               ;; calculation, or else priority will keep
1210                               ;; increasing
1211                               (null (ediff-overlay-get ovr 'ediff))
1212                               (null (ediff-overlay-get ovr 'ediff-diff-num)))
1213                          ;; use the overlay priority or 0
1214                          (or (ediff-overlay-get ovr 'priority) 0)
1215                        0))
1216                    ovr-list)
1217                   ))
1218         ))))
1219
1220
1221 (defvar ediff-toggle-read-only-function nil
1222   "*Specifies the function to be used to toggle read-only.
1223 If nil, Ediff tries to deduce the function from the binding of C-x C-q.
1224 Normally, this is the `toggle-read-only' function, but, if version
1225 control is used, it could be `vc-toggle-read-only' or `rcs-toggle-read-only'.")
1226
1227 (defcustom ediff-make-buffers-readonly-at-startup nil
1228   "*Make all variant buffers read-only when Ediff starts up.
1229 This property can be toggled interactively."
1230   :type 'boolean
1231   :group 'ediff)
1232
1233
1234 ;;; Misc
1235
1236 ;; if nil, this silences some messages
1237 (defconst ediff-verbose-p t)
1238
1239 (defcustom ediff-autostore-merges  'group-jobs-only
1240   "*Save the results of merge jobs automatically.
1241 Nil means don't save automatically.  t means always save.  Anything but nil or t
1242 means save automatically only if the merge job is part of a group of jobs, such
1243 as `ediff-merge-directory' or `ediff-merge-directory-revisions'."
1244   :type '(choice (const nil) (const t) (const group-jobs-only))
1245   :group 'ediff-merge)
1246 (make-variable-buffer-local 'ediff-autostore-merges)
1247
1248 ;; file where the result of the merge is to be saved.  used internally
1249 (ediff-defvar-local ediff-merge-store-file nil "")
1250
1251 (defcustom ediff-merge-filename-prefix "merge_"
1252   "*Prefix to be attached to saved merge buffers."
1253   :type 'string
1254   :group 'ediff-merge)
1255
1256 (defcustom ediff-no-emacs-help-in-control-buffer nil
1257   "*Non-nil means C-h should not invoke Emacs help in control buffer.
1258 Instead, C-h would jump to previous difference."
1259   :type 'boolean
1260   :group 'ediff)
1261
1262 ;; This is the same as temporary-file-directory from Emacs 20.3.
1263 ;; Copied over here because XEmacs doesn't have this variable.
1264 (defcustom ediff-temp-file-prefix
1265   (file-name-as-directory
1266    (cond ((boundp 'temporary-file-directory) temporary-file-directory)
1267          ((fboundp 'temp-directory) (temp-directory))
1268          (t "/tmp/")))
1269 ;;;  (file-name-as-directory
1270 ;;;   (cond ((memq system-type '(ms-dos windows-nt))
1271 ;;;       (or (getenv "TEMP") (getenv "TMPDIR") (getenv "TMP") "c:/temp"))
1272 ;;;      ((memq system-type '(vax-vms axp-vms))
1273 ;;;       (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "SYS$SCRATCH:"))
1274 ;;;      (t
1275 ;;;       (or (getenv "TMPDIR") (getenv "TMP") (getenv "TEMP") "/tmp"))))
1276   "*Prefix to put on Ediff temporary file names.
1277 Do not start with `~/' or `~USERNAME/'."
1278   :type 'string
1279   :group 'ediff)
1280
1281 (defcustom ediff-temp-file-mode 384     ; u=rw only
1282   "*Mode for Ediff temporary files."
1283   :type 'integer
1284   :group 'ediff)
1285
1286 ;; Metacharacters that have to be protected from the shell when executing
1287 ;; a diff/diff3 command.
1288 (defcustom ediff-metachars "[ \t\n!\"#$&'()*;<=>?[\\^`{|~]"
1289   "Regexp that matches characters that must be quoted with `\\' in shell command line.
1290 This default should work without changes."
1291   :type 'string
1292   :group 'ediff)
1293
1294 ;; needed to simulate frame-char-width in XEmacs.
1295 (defvar ediff-H-glyph (if ediff-xemacs-p (make-glyph "H")))
1296
1297
1298 ;; Temporary file used for refining difference regions in buffer A.
1299 (ediff-defvar-local ediff-temp-file-A nil "")
1300 ;; Temporary file used for refining difference regions in buffer B.
1301 (ediff-defvar-local ediff-temp-file-B nil "")
1302 ;; Temporary file used for refining difference regions in buffer C.
1303 (ediff-defvar-local ediff-temp-file-C nil "")
1304
1305
1306 ;;; In-line functions
1307
1308 ;; If file-remote-p is defined (as in XEmacs, use it. Otherwise, check
1309 ;; if find-file-name-handler is defined for 'file-local-copy
1310 (defun ediff-file-remote-p (file-name)
1311   (or (and (fboundp 'file-remote-p) (file-remote-p file-name))
1312       (find-file-name-handler file-name 'file-local-copy)))
1313
1314 ;; File for which we can get attributes, such as size or date
1315 (defun ediff-listable-file (file-name)
1316   (let ((handler (find-file-name-handler file-name 'file-local-copy)))
1317     (or (null handler) (eq handler 'dired-handler-fn))))
1318
1319
1320 (defsubst ediff-frame-unsplittable-p (frame)
1321   (cdr (assq 'unsplittable (frame-parameters frame))))
1322
1323 (defsubst ediff-get-next-window (wind prev-wind)
1324   (or (window-live-p wind)
1325       (setq wind (if prev-wind
1326                      (next-window wind)
1327                    (selected-window)))))
1328
1329
1330 (defsubst ediff-kill-buffer-carefully (buf)
1331   "Kill buffer BUF if it exists."
1332   (if (ediff-buffer-live-p buf)
1333       (kill-buffer (get-buffer buf))))
1334
1335 (defsubst ediff-background-face (buf-type dif-num)
1336   ;; The value of dif-num is always 1- the one that user sees.
1337   ;; This is why even face is used when dif-num is odd.
1338   (ediff-get-symbol-from-alist
1339    buf-type (if (ediff-odd-p dif-num)
1340                 ediff-even-diff-face-alist
1341               ediff-odd-diff-face-alist)
1342    ))
1343
1344
1345 ;; activate faces on diff regions in buffer
1346 (defun ediff-paint-background-regions-in-one-buffer (buf-type unhighlight)
1347   (let ((diff-vector
1348          (eval (ediff-get-symbol-from-alist
1349                 buf-type ediff-difference-vector-alist)))
1350         overl diff-num)
1351     (mapcar (lambda (rec)
1352               (setq overl (ediff-get-diff-overlay-from-diff-record rec)
1353                     diff-num (ediff-overlay-get overl 'ediff-diff-num))
1354               (if (ediff-overlay-buffer overl)
1355                   ;; only if overlay is alive
1356                   (ediff-set-overlay-face
1357                    overl
1358                    (if (not unhighlight)
1359                        (ediff-background-face buf-type diff-num))))
1360               )
1361             diff-vector)))
1362
1363
1364 ;; activate faces on diff regions in all buffers
1365 (defun ediff-paint-background-regions (&optional unhighlight)
1366   (ediff-paint-background-regions-in-one-buffer
1367    'A unhighlight)
1368   (ediff-paint-background-regions-in-one-buffer
1369    'B unhighlight)
1370   (ediff-paint-background-regions-in-one-buffer
1371    'C unhighlight)
1372   (ediff-paint-background-regions-in-one-buffer
1373    'Ancestor unhighlight))
1374
1375 (defun ediff-highlight-diff-in-one-buffer (n buf-type)
1376   (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
1377       (let* ((buff (ediff-get-buffer buf-type))
1378              (last (ediff-with-current-buffer buff (point-max)))
1379              (begin (ediff-get-diff-posn buf-type 'beg n))
1380              (end (ediff-get-diff-posn buf-type 'end n))
1381              (xtra (if (equal begin end) 1 0))
1382              (end-hilit (min last (+ end xtra)))
1383              (current-diff-overlay
1384               (symbol-value
1385                (ediff-get-symbol-from-alist
1386                 buf-type ediff-current-diff-overlay-alist))))
1387
1388         (if ediff-xemacs-p
1389             (ediff-move-overlay current-diff-overlay begin end-hilit)
1390           (ediff-move-overlay current-diff-overlay begin end-hilit buff))
1391         (ediff-overlay-put current-diff-overlay 'priority
1392                            (ediff-highest-priority begin end-hilit buff))
1393         (ediff-overlay-put current-diff-overlay 'ediff-diff-num n)
1394
1395         ;; unhighlight the background overlay for diff n so it won't
1396         ;; interfere with the current diff overlay
1397         (ediff-set-overlay-face (ediff-get-diff-overlay n buf-type) nil)
1398         )))
1399
1400
1401 (defun ediff-unhighlight-diff-in-one-buffer (buf-type)
1402   (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
1403       (let ((current-diff-overlay
1404              (symbol-value
1405               (ediff-get-symbol-from-alist
1406                buf-type ediff-current-diff-overlay-alist)))
1407             (overlay
1408              (ediff-get-diff-overlay ediff-current-difference buf-type))
1409             )
1410
1411         (ediff-move-overlay current-diff-overlay 1 1)
1412
1413         ;; rehighlight the overlay in the background of the
1414         ;; current difference region
1415         (ediff-set-overlay-face
1416          overlay
1417          (if (and (ediff-has-face-support-p)
1418                   ediff-use-faces ediff-highlight-all-diffs)
1419              (ediff-background-face buf-type ediff-current-difference)))
1420         )))
1421
1422 (defun ediff-unhighlight-diffs-totally-in-one-buffer (buf-type)
1423   (ediff-unselect-and-select-difference -1)
1424   (if (and (ediff-has-face-support-p) ediff-use-faces)
1425       (let* ((inhibit-quit t)
1426              (current-diff-overlay-var
1427               (ediff-get-symbol-from-alist
1428                buf-type ediff-current-diff-overlay-alist))
1429              (current-diff-overlay (symbol-value current-diff-overlay-var)))
1430         (ediff-paint-background-regions 'unhighlight)
1431         (if (ediff-overlayp current-diff-overlay)
1432             (ediff-delete-overlay current-diff-overlay))
1433         (set current-diff-overlay-var nil)
1434         )))
1435
1436
1437 (defsubst ediff-highlight-diff (n)
1438   "Put face on diff N.  Invoked for X displays only."
1439   (ediff-highlight-diff-in-one-buffer n 'A)
1440   (ediff-highlight-diff-in-one-buffer n 'B)
1441   (ediff-highlight-diff-in-one-buffer n 'C)
1442   (ediff-highlight-diff-in-one-buffer n 'Ancestor)
1443   )
1444
1445
1446 (defsubst ediff-unhighlight-diff ()
1447   "Remove overlays from buffers A, B, and C."
1448   (ediff-unhighlight-diff-in-one-buffer 'A)
1449   (ediff-unhighlight-diff-in-one-buffer 'B)
1450   (ediff-unhighlight-diff-in-one-buffer 'C)
1451   (ediff-unhighlight-diff-in-one-buffer 'Ancestor)
1452   )
1453
1454 ;; delete highlighting overlays, restore faces to their original form
1455 (defsubst ediff-unhighlight-diffs-totally ()
1456   (ediff-unhighlight-diffs-totally-in-one-buffer 'A)
1457   (ediff-unhighlight-diffs-totally-in-one-buffer 'B)
1458   (ediff-unhighlight-diffs-totally-in-one-buffer 'C)
1459   (ediff-unhighlight-diffs-totally-in-one-buffer 'Ancestor)
1460   )
1461
1462
1463 ;; arg is a record for a given diff in a difference vector
1464 ;; this record is itself a vector
1465 (defsubst ediff-clear-fine-diff-vector (diff-record)
1466   (if diff-record
1467       (mapcar 'ediff-delete-overlay
1468               (ediff-get-fine-diff-vector-from-diff-record diff-record))))
1469
1470 (defsubst ediff-clear-fine-differences-in-one-buffer (n buf-type)
1471   (ediff-clear-fine-diff-vector (ediff-get-difference n buf-type))
1472   (ediff-set-fine-diff-vector n buf-type nil))
1473
1474 (defsubst ediff-clear-fine-differences (n)
1475   (ediff-clear-fine-differences-in-one-buffer n 'A)
1476   (ediff-clear-fine-differences-in-one-buffer n 'B)
1477   (if ediff-3way-job
1478       (ediff-clear-fine-differences-in-one-buffer n 'C)))
1479
1480
1481 (defsubst ediff-convert-fine-diffs-to-overlays (diff-list region-num)
1482   (ediff-set-fine-overlays-in-one-buffer 'A diff-list region-num)
1483   (ediff-set-fine-overlays-in-one-buffer 'B diff-list region-num)
1484   (if ediff-3way-job
1485       (ediff-set-fine-overlays-in-one-buffer 'C diff-list region-num)
1486     ))
1487
1488 (defsubst ediff-mouse-event-p (event)
1489   (if ediff-xemacs-p
1490       (button-event-p event)
1491     (string-match "mouse" (format "%S" (event-basic-type event)))
1492     ))
1493
1494
1495 (defsubst ediff-key-press-event-p (event)
1496   (if ediff-xemacs-p
1497       (key-press-event-p event)
1498     (or (char-or-string-p event) (symbolp event))))
1499
1500 (defun ediff-event-point (event)
1501   (cond ((ediff-mouse-event-p event)
1502          (if ediff-xemacs-p
1503              (event-point event)
1504            (posn-point (event-start event))))
1505         ((ediff-key-press-event-p event)
1506          (point))
1507         (t (error))))
1508
1509 (defun ediff-event-buffer (event)
1510   (cond ((ediff-mouse-event-p event)
1511          (if ediff-xemacs-p
1512              (event-buffer event)
1513            (window-buffer (posn-window (event-start event)))))
1514         ((ediff-key-press-event-p event)
1515          (current-buffer))
1516         (t (error))))
1517
1518
1519 (defsubst ediff-frame-iconified-p (frame)
1520   (if (and (ediff-window-display-p) (frame-live-p frame))
1521       (if ediff-xemacs-p
1522           (frame-iconified-p frame)
1523         (eq (frame-visible-p frame) 'icon))))
1524
1525 (defsubst ediff-window-visible-p (wind)
1526   ;; under TTY, window-live-p also means window is visible
1527   (and (window-live-p wind)
1528        (or (not (ediff-window-display-p))
1529            (frame-visible-p (window-frame wind)))))
1530
1531
1532 (defsubst ediff-frame-char-width (frame)
1533   (if ediff-xemacs-p
1534       (/ (frame-pixel-width frame) (frame-width frame))
1535     (frame-char-width frame)))
1536
1537 (defun ediff-reset-mouse (&optional frame do-not-grab-mouse)
1538   (or frame (setq frame (selected-frame)))
1539   (if (ediff-window-display-p)
1540       (let ((frame-or-wind frame))
1541         (if ediff-xemacs-p
1542             (setq frame-or-wind (frame-selected-window frame)))
1543         (or do-not-grab-mouse
1544             ;; don't set mouse if the user said to never do this
1545             (not ediff-grab-mouse)
1546             ;; Don't grab on quit, if the user doesn't want to.
1547             ;; If ediff-grab-mouse = t, then mouse won't be grabbed for
1548             ;; sessions that are not part of a group (this is done in
1549             ;; ediff-recenter).  The condition below affects only terminating
1550             ;; sessions in session groups (in which case mouse is warped into
1551             ;; a meta buffer).
1552             (and (eq ediff-grab-mouse 'maybe)
1553                  (memq this-command '(ediff-quit ediff-update-diffs)))
1554             (set-mouse-position frame-or-wind 1 0))
1555         )))
1556
1557 (defsubst ediff-spy-after-mouse ()
1558   (setq ediff-mouse-pixel-position (mouse-pixel-position)))
1559
1560 ;; It is not easy to find out when the user grabs the mouse, since emacs and
1561 ;; xemacs behave differently when mouse is not in any frame.  Also, this is
1562 ;; sensitive to when the user grabbed mouse.  Not used for now.
1563 (defun ediff-user-grabbed-mouse ()
1564   (if ediff-mouse-pixel-position
1565       (cond ((not (eq (car ediff-mouse-pixel-position)
1566                       (car (mouse-pixel-position)))))
1567             ((and (car (cdr ediff-mouse-pixel-position))
1568                   (car (cdr (mouse-pixel-position)))
1569                   (cdr (cdr ediff-mouse-pixel-position))
1570                   (cdr (cdr (mouse-pixel-position))))
1571              (not (and (< (abs (- (car (cdr ediff-mouse-pixel-position))
1572                                   (car (cdr (mouse-pixel-position)))))
1573                           ediff-mouse-pixel-threshold)
1574                        (< (abs (- (cdr (cdr ediff-mouse-pixel-position))
1575                                   (cdr (cdr (mouse-pixel-position)))))
1576                           ediff-mouse-pixel-threshold))))
1577             (t nil))))
1578
1579 (defsubst ediff-frame-char-height (frame)
1580   (if ediff-xemacs-p
1581       (glyph-height ediff-H-glyph (selected-window frame))
1582     (frame-char-height frame)))
1583
1584 ;; Some overlay functions
1585
1586 (defsubst ediff-overlay-start (overl)
1587   (if (ediff-overlayp overl)
1588       (if ediff-emacs-p
1589           (overlay-start overl)
1590         (extent-start-position overl))))
1591
1592 (defsubst ediff-overlay-end  (overl)
1593   (if (ediff-overlayp overl)
1594       (if ediff-emacs-p
1595           (overlay-end overl)
1596         (extent-end-position overl))))
1597
1598 (defsubst ediff-empty-overlay-p (overl)
1599   (= (ediff-overlay-start overl) (ediff-overlay-end overl)))
1600
1601 ;; like overlay-buffer in Emacs.  In XEmacs, returns nil if the extent is
1602 ;; dead.  Otherwise, works like extent-buffer
1603 (defun ediff-overlay-buffer (overl)
1604   (if ediff-emacs-p
1605       (overlay-buffer overl)
1606     (and (extent-live-p overl) (extent-object overl))))
1607
1608 ;; like overlay-get in Emacs.  In XEmacs, returns nil if the extent is
1609 ;; dead.  Otherwise, like extent-property
1610 (defun ediff-overlay-get (overl property)
1611   (if ediff-emacs-p
1612       (overlay-get overl property)
1613     (and (extent-live-p overl) (extent-property overl property))))
1614
1615
1616 ;; These two functions are here because XEmacs refuses to
1617 ;; handle overlays whose buffers were deleted.
1618 (defun ediff-move-overlay (overlay beg end &optional buffer)
1619   "Calls `move-overlay' in Emacs and `set-extent-endpoints' in Lemacs.
1620 Checks if overlay's buffer exists before actually doing the move."
1621   (let ((buf (and overlay (ediff-overlay-buffer overlay))))
1622     (if (ediff-buffer-live-p buf)
1623         (if ediff-xemacs-p
1624             (set-extent-endpoints overlay beg end)
1625           (move-overlay overlay beg end buffer))
1626       ;; buffer's dead
1627       (if overlay
1628           (ediff-delete-overlay overlay)))))
1629
1630 (defun ediff-overlay-put (overlay prop value)
1631   "Calls `overlay-put' or `set-extent-property' depending on Emacs version.
1632 Checks if overlay's buffer exists."
1633   (if (ediff-buffer-live-p (ediff-overlay-buffer overlay))
1634       (if ediff-xemacs-p
1635           (set-extent-property overlay prop value)
1636         (overlay-put overlay prop value))
1637     (ediff-delete-overlay overlay)))
1638
1639 ;; Some diff region tests
1640
1641 ;; t if diff region is empty.
1642 ;; In case of buffer C, t also if it is not a 3way
1643 ;; comparison job (merging jobs return t as well).
1644 (defun ediff-empty-diff-region-p (n buf-type)
1645   (if (eq buf-type 'C)
1646       (or (not ediff-3way-comparison-job)
1647           (= (ediff-get-diff-posn 'C 'beg n)
1648              (ediff-get-diff-posn 'C 'end n)))
1649     (= (ediff-get-diff-posn buf-type 'beg n)
1650        (ediff-get-diff-posn buf-type 'end n))))
1651
1652 ;; Test if diff region is white space only.
1653 ;; If 2-way job and buf-type = C, then returns t.
1654 (defun ediff-whitespace-diff-region-p (n buf-type)
1655   (or (and (eq buf-type 'C) (not ediff-3way-job))
1656       (ediff-empty-diff-region-p n buf-type)
1657       (let ((beg (ediff-get-diff-posn buf-type 'beg n))
1658             (end (ediff-get-diff-posn buf-type 'end n)))
1659         (ediff-with-current-buffer (ediff-get-buffer buf-type)
1660           (save-excursion
1661             (goto-char beg)
1662             (skip-chars-forward ediff-whitespace)
1663             (>= (point) end))))))
1664
1665 ;; temporarily uses DIR to abbreviate file name
1666 ;; if DIR is nil, use default-directory
1667 (defun ediff-abbreviate-file-name (file &optional dir)
1668   (cond ((stringp dir)
1669          (let ((directory-abbrev-alist (list (cons dir ""))))
1670            (abbreviate-file-name file)))
1671         (ediff-emacs-p (abbreviate-file-name file))
1672         (t ; XEmacs requires addl argument
1673          (abbreviate-file-name file t))))
1674
1675 ;; Takes a directory and returns the parent directory.
1676 ;; does nothing to `/'.  If the ARG is a regular file,
1677 ;; strip the file AND the last dir.
1678 (defun ediff-strip-last-dir (dir)
1679   (if (not (stringp dir)) (setq dir default-directory))
1680   (setq dir (expand-file-name dir))
1681   (or (file-directory-p dir) (setq dir (file-name-directory dir)))
1682   (let* ((pos (1- (length dir)))
1683          (last-char (aref dir pos)))
1684     (if (and (> pos 0) (= last-char ?/))
1685         (setq dir (substring dir 0 pos)))
1686     (ediff-abbreviate-file-name (file-name-directory dir))))
1687
1688 (defun ediff-truncate-string-left (str newlen)
1689   ;; leave space for ... on the left
1690   (let ((len (length str))
1691         substr)
1692     (if (<= len newlen)
1693         str
1694       (setq newlen (max 0 (- newlen 3)))
1695       (setq substr (substring str (max 0 (- len 1 newlen))))
1696       (concat "..." substr))))
1697
1698 (defsubst ediff-nonempty-string-p (string)
1699   (and (stringp string) (not (string= string ""))))
1700
1701 (unless (fboundp 'subst-char-in-string)
1702   (defun subst-char-in-string (fromchar tochar string &optional inplace)
1703     "Replace FROMCHAR with TOCHAR in STRING each time it occurs.
1704 Unless optional argument INPLACE is non-nil, return a new string."
1705     (let ((i (length string))
1706           (newstr (if inplace string (copy-sequence string))))
1707       (while (> i 0)
1708         (setq i (1- i))
1709         (if (eq (aref newstr i) fromchar)
1710             (aset newstr i tochar)))
1711       newstr)))
1712
1713 (defun ediff-abbrev-jobname (jobname)
1714   (cond ((eq jobname 'ediff-directories)
1715          "Compare two directories")
1716         ((eq jobname 'ediff-files)
1717          "Compare two files")
1718         ((eq jobname 'ediff-buffers)
1719          "Compare two buffers")
1720         ((eq jobname 'ediff-directories3)
1721          "Compare three directories")
1722         ((eq jobname 'ediff-files3)
1723          "Compare three files")
1724         ((eq jobname 'ediff-buffers3)
1725          "Compare three buffers")
1726         ((eq jobname 'ediff-revision)
1727          "Compare file with a version")
1728         ((eq jobname 'ediff-directory-revisions)
1729          "Compare dir files with versions")
1730         ((eq jobname 'ediff-merge-directory-revisions)
1731          "Merge dir files with versions")
1732         ((eq jobname 'ediff-merge-directory-revisions-with-ancestor)
1733          "Merge dir versions via ancestors")
1734         (t
1735          (capitalize
1736           (subst-char-in-string ?- ?\  (substring (symbol-name jobname) 6))))
1737         ))
1738
1739
1740 (defsubst ediff-get-region-contents (n buf-type ctrl-buf &optional start end)
1741   (ediff-with-current-buffer
1742       (ediff-with-current-buffer ctrl-buf (ediff-get-buffer buf-type))
1743     (buffer-substring
1744      (or start (ediff-get-diff-posn buf-type 'beg n ctrl-buf))
1745      (or end (ediff-get-diff-posn buf-type 'end n ctrl-buf)))))
1746
1747 ;; If ediff modified mode line, strip the modification
1748 (defsubst ediff-strip-mode-line-format ()
1749   (if (member (car mode-line-format) '(" A: " " B: " " C: " " Ancestor: "))
1750       (setq mode-line-format (nth 2 mode-line-format))))
1751
1752 ;; Verify that we have a difference selected.
1753 (defsubst ediff-valid-difference-p (&optional n)
1754   (or n (setq n ediff-current-difference))
1755   (and (>= n 0) (< n ediff-number-of-differences)))
1756
1757 (defsubst ediff-show-all-diffs (n)
1758   "Don't skip difference regions."
1759   nil)
1760
1761 (defsubst Xor (a b)
1762   (or (and a (not b)) (and (not a) b)))
1763
1764 (defsubst ediff-message-if-verbose (string &rest args)
1765   (if ediff-verbose-p
1766       (apply 'message string args)))
1767
1768 (defun ediff-file-attributes (filename attr-number)
1769   (if (ediff-listable-file filename)
1770       (nth attr-number (file-attributes filename))
1771     -1)
1772   )
1773
1774 (defsubst ediff-file-size (filename)
1775   (ediff-file-attributes filename 7))
1776 (defsubst ediff-file-modtime (filename)
1777   (ediff-file-attributes filename 5))
1778
1779
1780 (defun ediff-convert-standard-filename (fname)
1781   (if (fboundp 'convert-standard-filename)
1782       (convert-standard-filename fname)
1783     fname))
1784
1785
1786 (if (fboundp 'with-syntax-table)
1787     (fset 'ediff-with-syntax-table 'with-syntax-table)
1788   ;; stolen from subr.el in emacs 21
1789   (defmacro ediff-with-syntax-table (table &rest body)
1790     (let ((old-table (make-symbol "table"))
1791           (old-buffer (make-symbol "buffer")))
1792       `(let ((,old-table (syntax-table))
1793              (,old-buffer (current-buffer)))
1794          (unwind-protect
1795              (progn
1796                (set-syntax-table (copy-syntax-table ,table))
1797                ,@body)
1798            (save-current-buffer
1799              (set-buffer ,old-buffer)
1800              (set-syntax-table ,old-table)))))))
1801
1802
1803
1804 ;;; Local Variables:
1805 ;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
1806 ;;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
1807 ;;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
1808 ;;; End:
1809
1810 (provide 'ediff-init)
1811
1812 ;;; ediff-init.el ends here