lisp/composite.el

   1 ;;; composite.el --- support character composition
   2
   3 ;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   4 ;;   2008
   5 ;;   National Institute of Advanced Industrial Science and Technology (AIST)
   6 ;;   Registration Number H14PRO021
   7
   8 ;; Keywords: mule, multilingual, character composition
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software; you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation; either version 3, or (at your option)
  15 ;; any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  24 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  25 ;; Boston, MA 02110-1301, USA.
  26
  27 ;;; Commentary:
  28
  29 ;;; Code:
  30
  31 (defconst reference-point-alist
  32   '((tl . 0) (tc . 1) (tr . 2)
  33     (Bl . 3) (Bc . 4) (Br . 5)
  34     (bl . 6) (bc . 7) (br . 8)
  35     (cl . 9) (cc . 10) (cr . 11)
  36     (top-left . 0) (top-center . 1) (top-right . 2)
  37     (base-left . 3) (base-center . 4) (base-right . 5)
  38     (bottom-left . 6) (bottom-center . 7) (bottom-right . 8)
  39     (center-left . 9) (center-center . 10) (center-right . 11)
  40     ;; For backward compatibility...
  41     (ml . 3) (mc . 10) (mr . 5)
  42     (mid-left . 3) (mid-center . 10) (mid-right . 5))
  43   "Alist of symbols vs integer codes of glyph reference points.
  44 A glyph reference point symbol is to be used to specify a composition
  45 rule in COMPONENTS argument to such functions as `compose-region'.
  46
  47 Meanings of glyph reference point codes are as follows:
  48
  49     0----1----2 <---- ascent    0:tl or top-left
  50     |         |                 1:tc or top-center
  51     |         |                 2:tr or top-right
  52     |         |                 3:Bl or base-left     9:cl or center-left
  53     9   10   11 <---- center    4:Bc or base-center  10:cc or center-center
  54     |         |                 5:Br or base-right   11:cr or center-right
  55   --3----4----5-- <-- baseline  6:bl or bottom-left
  56     |         |                 7:bc or bottom-center
  57     6----7----8 <---- descent   8:br or bottom-right
  58
  59 Glyph reference point symbols are to be used to specify composition
  60 rule of the form \(GLOBAL-REF-POINT . NEW-REF-POINT), where
  61 GLOBAL-REF-POINT is a reference point in the overall glyphs already
  62 composed, and NEW-REF-POINT is a reference point in the new glyph to
  63 be added.
  64
  65 For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and
  66 NEW-REF-POINT is `tc' (top-center), the overall glyph is updated as
  67 follows (the point `*' corresponds to both reference points):
  68
  69     +-------+--+ <--- new ascent
  70     |       |  |
  71     | global|  |
  72     | glyph |  |
  73  -- |       |  |-- <--- baseline \(doesn't change)
  74     +----+--*--+
  75     |    | new |
  76     |    |glyph|
  77     +----+-----+ <--- new descent
  78
  79 A composition rule may have the form \(GLOBAL-REF-POINT
  80 NEW-REF-POINT XOFF YOFF), where XOFF and YOFF specifies how much
  81 to shift NEW-REF-POINT from GLOBAL-REF-POINT.  In this case, XOFF
  82 and YOFF are integers in the range -100..100 representing the
  83 shifting percentage against the font size.")
  84
  85
  86 ;;;###autoload
  87 (defun encode-composition-rule (rule)
  88   "Encode composition rule RULE into an integer value.
  89 RULE is a cons of global and new reference point symbols
  90 \(see `reference-point-alist')."
  91
  92   ;; This must be compatible with C macro COMPOSITION_ENCODE_RULE
  93   ;; defined in composite.h.
  94
  95   (if (and (integerp rule) (< rule 144))
  96       ;; Already encoded.
  97       rule
  98     (if (consp rule)
  99         (let ((gref (car rule))
 100               (nref (cdr rule))
 101               xoff yoff)
 102           (if (consp nref)              ; (GREF NREF XOFF YOFF)
 103               (progn
 104                 (setq xoff (nth 1 nref)
 105                       yoff (nth 2 nref)
 106                       nref (car nref))
 107                 (or (and (>= xoff -100) (<= xoff 100)
 108                          (>= yoff -100) (<= yoff 100))
 109                     (error "Invalid compostion rule: %s" rule))
 110                 (setq xoff (+ xoff 128) yoff (+ yoff 128)))
 111             ;; (GREF . NREF)
 112             (setq xoff 0 yoff 0))
 113           (or (integerp gref)
 114               (setq gref (cdr (assq gref reference-point-alist))))
 115           (or (integerp nref)
 116               (setq nref (cdr (assq nref reference-point-alist))))
 117           (or (and (>= gref 0) (< gref 12) (>= nref 0) (< nref 12))
 118               (error "Invalid composition rule: %S" rule))
 119           (logior (lsh xoff 16) (lsh yoff 8) (+ (* gref 12) nref)))
 120       (error "Invalid composition rule: %S" rule))))
 121
 122 ;; Decode encoded composition rule RULE-CODE.  The value is a cons of
 123 ;; global and new reference point symbols.
 124 ;; This must be compatible with C macro COMPOSITION_DECODE_RULE
 125 ;; defined in composite.h.
 126
 127 (defun decode-composition-rule (rule-code)
 128   (or (and (natnump rule-code) (< rule-code #x1000000))
 129       (error "Invalid encoded composition rule: %S" rule-code))
 130   (let ((xoff (lsh rule-code -16))
 131         (yoff (logand (lsh rule-code -8) #xFF))
 132         gref nref)
 133     (setq rule-code (logand rule-code #xFF)
 134           gref (car (rassq (/ rule-code 12) reference-point-alist))
 135           nref (car (rassq (% rule-code 12) reference-point-alist)))
 136     (or (and gref (symbolp gref) nref (symbolp nref))
 137         (error "Invalid composition rule code: %S" rule-code))
 138     (if (and (= xoff 0) (= yoff 0))
 139         (cons gref nref)
 140       (setq xoff (- xoff 128) yoff (- yoff 128))
 141       (list gref xoff yoff nref))))
 142
 143 ;; Encode composition rules in composition components COMPONENTS.  The
 144 ;; value is a copy of COMPONENTS, where composition rules (cons of
 145 ;; global and new glyph reference point symbols) are replaced with
 146 ;; encoded composition rules.  Optional 2nd argument NOCOPY non-nil
 147 ;; means don't make a copy but modify COMPONENTS directly.
 148
 149 (defun encode-composition-components (components &optional nocopy)
 150   (or nocopy
 151       (setq components (copy-sequence components)))
 152   (if (vectorp components)
 153       (let ((len (length components))
 154             (i 1))
 155         (while (< i len)
 156           (aset components i
 157                 (encode-composition-rule (aref components i)))
 158           (setq i (+ i 2))))
 159     (let ((tail (cdr components)))
 160       (while tail
 161         (setcar tail
 162                 (encode-composition-rule (car tail)))
 163         (setq tail (nthcdr 2 tail)))))
 164   components)
 165
 166 ;; Decode composition rule codes in composition components COMPONENTS.
 167 ;; The value is a copy of COMPONENTS, where composition rule codes are
 168 ;; replaced with composition rules (cons of global and new glyph
 169 ;; reference point symbols).  Optional 2nd argument NOCOPY non-nil
 170 ;; means don't make a copy but modify COMPONENTS directly.
 171 ;; It is assumed that COMPONENTS is a vector and is for rule-base
 172 ;; composition, thus (2N+1)th elements are rule codes.
 173
 174 (defun decode-composition-components (components &optional nocopy)
 175   (or nocopy
 176       (setq components (copy-sequence components)))
 177   (let ((len (length components))
 178         (i 1))
 179     (while (< i len)
 180       (aset components i
 181             (decode-composition-rule (aref components i)))
 182       (setq i (+ i 2))))
 183   components)
 184
 185 (defun compose-region (start end &optional components modification-func)
 186   "Compose characters in the current region.
 187
 188 Characters are composed relatively, i.e. composed by overstricking or
 189 stacking depending on ascent, descent and other properties.
 190
 191 When called from a program, expects these four arguments.
 192
 193 First two arguments START and END are positions (integers or markers)
 194 specifying the region.
 195
 196 Optional 3rd argument COMPONENTS, if non-nil, is a character, a string
 197 or a vector or list of integers and rules.
 198
 199 If it is a character, it is an alternate character to display instead
 200 of the text in the region.
 201
 202 If it is a string, the elements are alternate characters.
 203
 204 If it is a vector or list, it is a sequence of alternate characters and
 205 composition rules, where (2N)th elements are characters and (2N+1)th
 206 elements are composition rules to specify how to compose (2N+2)th
 207 elements with previously composed N glyphs.
 208
 209 A composition rule is a cons of global and new glyph reference point
 210 symbols.  See the documentation of `reference-point-alist' for more
 211 detail.
 212
 213 Optional 4th argument MODIFICATION-FUNC is a function to call to
 214 adjust the composition when it gets invalid because of a change of
 215 text in the composition."
 216   (interactive "r")
 217   (let ((modified-p (buffer-modified-p))
 218         (inhibit-read-only t))
 219     (if (or (vectorp components) (listp components))
 220         (setq components (encode-composition-components components)))
 221     (compose-region-internal start end components modification-func)
 222     (restore-buffer-modified-p modified-p)))
 223
 224 (defun decompose-region (start end)
 225   "Decompose text in the current region.
 226
 227 When called from a program, expects two arguments,
 228 positions (integers or markers) specifying the region."
 229   (interactive "r")
 230   (let ((modified-p (buffer-modified-p))
 231         (inhibit-read-only t))
 232     (remove-text-properties start end '(composition nil))
 233     (restore-buffer-modified-p modified-p)))
 234
 235 (defun compose-string (string &optional start end components modification-func)
 236   "Compose characters in string STRING.
 237
 238 The return value is STRING with the `composition' property put on all
 239 the characters in it.
 240
 241 Optional 2nd and 3rd arguments START and END specify the range of
 242 STRING to be composed.  They default to the beginning and the end of
 243 STRING respectively.
 244
 245 Optional 4th argument COMPONENTS, if non-nil, is a character or a
 246 sequence (vector, list, or string) of integers.  See the function
 247 `compose-region' for more detail.
 248
 249 Optional 5th argument MODIFICATION-FUNC is a function to call to
 250 adjust the composition when it gets invalid because of a change of
 251 text in the composition."
 252   (if (or (vectorp components) (listp components))
 253       (setq components (encode-composition-components components)))
 254   (or start (setq start 0))
 255   (or end (setq end (length string)))
 256   (compose-string-internal string start end components modification-func)
 257   string)
 258
 259 (defun decompose-string (string)
 260   "Return STRING where `composition' property is removed."
 261   (remove-text-properties 0 (length string) '(composition nil) string)
 262   string)
 263
 264 (defun compose-chars (&rest args)
 265   "Return a string from arguments in which all characters are composed.
 266 For relative composition, arguments are characters.
 267 For rule-based composition, Mth \(where M is odd) arguments are
 268 characters, and Nth \(where N is even) arguments are composition rules.
 269 A composition rule is a cons of glyph reference points of the form
 270 \(GLOBAL-REF-POINT . NEW-REF-POINT).  See the documentation of
 271 `reference-point-alist' for more detail."
 272   (let (str components)
 273     (if (consp (car (cdr args)))
 274         ;; Rule-base composition.
 275         (let ((len (length args))
 276               (tail (encode-composition-components args 'nocopy)))
 277
 278           (while tail
 279             (setq str (cons (car tail) str))
 280             (setq tail (nthcdr 2 tail)))
 281           (setq str (concat (nreverse str))
 282                 components args))
 283       ;; Relative composition.
 284       (setq str (concat args)))
 285     (compose-string-internal str 0 (length str) components)))
 286
 287 (defun find-composition (pos &optional limit string detail-p)
 288   "Return information about a composition at or nearest to buffer position POS.
 289
 290 If the character at POS has `composition' property, the value is a list
 291 of FROM, TO, and VALID-P.
 292
 293 FROM and TO specify the range of text that has the same `composition'
 294 property, VALID-P is non-nil if and only if this composition is valid.
 295
 296 If there's no composition at POS, and the optional 2nd argument LIMIT
 297 is non-nil, search for a composition toward LIMIT.
 298
 299 If no composition is found, return nil.
 300
 301 Optional 3rd argument STRING, if non-nil, is a string to look for a
 302 composition in; nil means the current buffer.
 303
 304 If a valid composition is found and the optional 4th argument DETAIL-P
 305 is non-nil, the return value is a list of FROM, TO, COMPONENTS,
 306 RELATIVE-P, MOD-FUNC, and WIDTH.
 307
 308 COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
 309
 310 RELATIVE-P is t if the composition method is relative, else nil.
 311
 312 If RELATIVE-P is t, COMPONENTS is a vector of characters to be
 313 composed.  If RELATIVE-P is nil, COMPONENTS is a vector of characters
 314 and composition rules as described in `compose-region'.
 315
 316 MOD-FUNC is a modification function of the composition.
 317
 318 WIDTH is a number of columns the composition occupies on the screen."
 319   (let ((result (find-composition-internal pos limit string detail-p)))
 320     (if (and detail-p result (nth 2 result) (not (nth 3 result)))
 321         ;; This is a valid rule-base composition.
 322         (decode-composition-components (nth 2 result) 'nocopy))
 323     result))
 324
 325 \f
 326 (defun compose-chars-after (pos &optional limit object)
 327   "Compose characters in current buffer after position POS.
 328
 329 It looks up the char-table `composition-function-table' (which see) by
 330 a character after POS.  If non-nil value is found, the format of the
 331 value should be an alist of PATTERNs vs FUNCs, where PATTERNs are
 332 regular expressions and FUNCs are functions.  If the text after POS
 333 matches one of PATTERNs, call the corresponding FUNC with three
 334 arguments POS, TO, and PATTERN, where TO is the end position of text
 335 matching PATTERN, and return what FUNC returns.  Otherwise, return
 336 nil.
 337
 338 FUNC is responsible for composing the text properly.  The return value
 339 is:
 340   nil -- if no characters were composed.
 341   CHARS (integer) -- if CHARS characters were composed.
 342
 343 Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
 344
 345 Optional 3rd arg OBJECT, if non-nil, is a string that contains the
 346 text to compose.  In that case, POS and LIMIT index into the string.
 347
 348 This function is the default value of `compose-chars-after-function'."
 349   (let ((tail (aref composition-function-table (char-after pos)))
 350         pattern func result)
 351     (when tail
 352       (save-match-data
 353         (save-excursion
 354           (while (and tail (not func))
 355             (setq pattern (car (car tail))
 356                   func (cdr (car tail)))
 357             (goto-char pos)
 358             (if (if limit
 359                     (and (re-search-forward pattern limit t)
 360                          (= (match-beginning 0) pos))
 361                   (looking-at pattern))
 362                 (setq result (funcall func pos (match-end 0) pattern nil))
 363               (setq func nil tail (cdr tail)))))))
 364       result))
 365
 366 (defun compose-last-chars (args)
 367   "Compose last characters.
 368 The argument is a parameterized event of the form
 369         \(compose-last-chars N COMPONENTS),
 370 where N is the number of characters before point to compose,
 371 COMPONENTS, if non-nil, is the same as the argument to `compose-region'
 372 \(which see).  If it is nil, `compose-chars-after' is called,
 373 and that function finds a proper rule to compose the target characters.
 374 This function is intended to be used from input methods.
 375 The global keymap binds special event `compose-last-chars' to this
 376 function.  Input method may generate an event (compose-last-chars N COMPONENTS)
 377 after a sequence of character events."
 378   (interactive "e")
 379   (let ((chars (nth 1 args)))
 380     (if (and (numberp chars)
 381              (>= (- (point) (point-min)) chars))
 382         (if (nth 2 args)
 383             (compose-region (- (point) chars) (point) (nth 2 args))
 384           (compose-chars-after (- (point) chars) (point))))))
 385
 386 (global-set-key [compose-last-chars] 'compose-last-chars)
 387
 388 \f
 389 ;;; Automatic character composition.
 390
 391 (defvar composition-function-table
 392   (make-char-table nil)
 393   "Char table of functions for automatic character composition.
 394 For each character that has to be composed automatically with
 395 preceding and/or following characters, this char table contains
 396 a function to call to compose that character.
 397
 398 An element, if non-nil, is FUNC or an alist of PATTERNs vs FUNCs,
 399 where PATTERNs are regular expressions and FUNCs are functions.
 400 If the element is FUNC, FUNC itself determines the region to
 401 compose.
 402
 403 Each function is called with 4 arguments, FROM, TO, FONT-OBJECT,
 404 and STRING.
 405
 406 If STRING is nil, FROM and TO are positions specifying the region
 407 maching with PATTERN in the current buffer, and the function has
 408 to compose character in that region (possibly with characters
 409 preceding FROM).  The return value of the function is the end
 410 position where characters are composed.
 411
 412 Otherwise, STRING is a string, and FROM and TO are indices into
 413 the string.  In this case, the function has to compose a
 414 character in the string.
 415
 416 FONT-OBJECT may be nil if not available (e.g. for the case of
 417 terminal).
 418
 419 See also the command `toggle-auto-composition'.")
 420
 421 ;; Copied from font-lock.el.
 422 (eval-when-compile
 423   ;; Borrowed from lazy-lock.el.
 424   ;; We use this to preserve or protect things when modifying text properties.
 425   (defmacro save-buffer-state (varlist &rest body)
 426     "Bind variables according to VARLIST and eval BODY restoring buffer state."
 427     `(let* ,(append varlist
 428                     '((modified (buffer-modified-p)) (buffer-undo-list t)
 429                       (inhibit-read-only t) (inhibit-point-motion-hooks t)
 430                       (inhibit-modification-hooks t)
 431                       deactivate-mark buffer-file-name buffer-file-truename))
 432        ,@body
 433        (unless modified
 434          (restore-buffer-modified-p nil))))
 435   ;; Fixme: This makes bootstrapping fail with this error.
 436   ;;   Symbol's function definition is void: eval-defun
 437   ;;(def-edebug-spec save-buffer-state let)
 438   )
 439
 440 (put 'save-buffer-state 'lisp-indent-function 1)
 441
 442 (defun terminal-composition-function (from to font-object string)
 443   "General composition function used on terminal.
 444 Non-spacing characters are composed with the preceding spacing
 445 character.  All non-spacing characters has this function in
 446 `terminal-composition-function-table'."
 447   (let ((pos (1+ from)))
 448     (if string
 449         (progn
 450           (while (and (< pos to)
 451                       (= (aref char-width-table (aref string pos)) 0))
 452             (setq pos (1+ pos)))
 453           (if (> from 0)
 454               (compose-string string (1- from) pos)
 455             (compose-string string from pos
 456                             (concat " " (buffer-substring from pos)))))
 457       (while (and (< pos to)
 458                   (= (aref char-width-table (char-after pos)) 0))
 459         (setq pos (1+ pos)))
 460       (if (> from (point-min))
 461           (compose-region (1- from) pos (buffer-substring from pos))
 462         (compose-region from pos
 463                         (concat " " (buffer-substring from pos)))))
 464     pos))
 465
 466 (defvar terminal-composition-function-table
 467   (let ((table (make-char-table nil)))
 468     (map-char-table
 469      #'(lambda (key val)
 470          (if (= val 0) (set-char-table-range table key
 471                                              'terminal-composition-function)))
 472      char-width-table)
 473     table)
 474   "Char table of functions for automatic character composition on terminal.
 475 This is like `composition-function-table' but used when Emacs is running
 476 on a terminal.")
 477
 478 (defun auto-compose-chars (from to window string)
 479   "Compose characters in the region between FROM and TO.
 480 WINDOW is a window displaying the current buffer.
 481 If STRING is non-nil, it is a string, and FROM and TO are indices
 482 into the string.  In that case, compose characters in the string.
 483
 484 This function is the default value of `auto-composition-function' (which see)."
 485   (save-buffer-state nil
 486     (save-excursion
 487       (save-restriction
 488         (save-match-data
 489           (let ((table (if (display-graphic-p)
 490                            composition-function-table
 491                          terminal-composition-function-table))
 492                 (start from))
 493             (setq to (or (text-property-any (1+ from) to 'auto-composed t
 494                                             string)
 495                          to))
 496             (if string
 497                 (while (< from to)
 498                   (let* ((ch (aref string from))
 499                          (elt (aref table ch))
 500                          font-obj newpos)
 501                     (when elt
 502                       (if window
 503                           (setq font-obj (font-at from window string)))
 504                       (if (functionp elt)
 505                           (setq newpos (funcall elt from to font-obj string))
 506                         (while (and elt
 507                                     (or (not (eq (string-match (caar elt) string
 508                                                                from)
 509                                                  from))
 510                                         (not (setq newpos
 511                                                    (funcall (cdar elt) from
 512                                                             (match-end 0)
 513                                                             font-obj string)))))
 514                           (setq elt (cdr elt)))))
 515                     (if (and newpos (> newpos from))
 516                         (setq from newpos)
 517                       (setq from (1+ from)))))
 518               (narrow-to-region from to)
 519               (while (< from to)
 520                   (let* ((ch (char-after from))
 521                          (elt (aref table ch))
 522                          func pattern font-obj newpos)
 523                     (when elt
 524                       (if window
 525                           (setq font-obj (font-at from window)))
 526                       (if (functionp elt)
 527                           (setq newpos (funcall elt from to font-obj nil))
 528                         (goto-char from)
 529                         (while (and elt
 530                                     (or (not (looking-at (caar elt)))
 531                                         (not (setq newpos
 532                                                    (funcall (cdar elt) from
 533                                                             (match-end 0)
 534                                                             font-obj nil)))))
 535                           (setq elt (cdr elt)))))
 536                     (if (and newpos (> newpos from))
 537                         (setq from newpos)
 538                       (setq from (1+ from))))))
 539             (put-text-property start to 'auto-composed t string)))))))
 540
 541 (make-variable-buffer-local 'auto-composition-function)
 542
 543 ;;;###autoload
 544 (define-minor-mode auto-composition-mode
 545   "Toggle Auto Compostion mode.
 546 With arg, turn Auto Compostion mode off if and only if arg is a non-positive
 547 number; if arg is nil, toggle Auto Compostion mode; anything else turns Auto
 548 Compostion on.
 549
 550 When Auto Composition is enabled, text characters are automatically composed
 551 by functions registered in `composition-function-table' (which see).
 552
 553 You can use Global Auto Composition mode to automagically turn on
 554 Auto Composition mode in all buffers (this is the default)."
 555   nil nil nil
 556   (if noninteractive
 557       (setq auto-composition-mode nil))
 558   (cond (auto-composition-mode
 559          (add-hook 'after-change-functions 'auto-composition-after-change nil t)
 560          (setq auto-composition-function 'auto-compose-chars))
 561         (t
 562          (remove-hook 'after-change-functions 'auto-composition-after-change t)
 563          (setq auto-composition-function nil)))
 564   (save-buffer-state nil
 565     (save-restriction
 566       (widen)
 567       (remove-text-properties (point-min) (point-max) '(auto-composed nil))
 568       (decompose-region (point-min) (point-max)))))
 569
 570 (defun auto-composition-after-change (start end old-len)
 571   (save-buffer-state nil
 572     (if (< start (point-min))
 573         (setq start (point-min)))
 574     (if (> end (point-max))
 575         (setq end (point-max)))
 576     (when (and auto-composition-mode (not memory-full))
 577       (let (func1 func2)
 578         (when (and (> start (point-min))
 579                    (setq func2 (aref composition-function-table
 580                                      (char-after (1- start))))
 581                    (or (= start (point-max))
 582                        (not (setq func1 (aref composition-function-table
 583                                               (char-after start))))
 584                        (eq func1 func2)))
 585           (setq start (1- start)
 586                 func1 func2)
 587           (while (eq func1 func2)
 588             (if (> start (point-min))
 589                 (setq start (1- start)
 590                       func2 (aref composition-function-table
 591                                   (char-after start)))
 592               (setq func2 nil))))
 593         (when (and (< end (point-max))
 594                    (setq func2 (aref composition-function-table
 595                                      (char-after end)))
 596                    (or (= end (point-min))
 597                        (not (setq func1 (aref composition-function-table
 598                                               (char-after (1- end)))))
 599                        (eq func1 func2)))
 600           (setq end (1+ end)
 601                 func1 func2)
 602           (while (eq func1 func2)
 603             (if (< end (point-max))
 604                 (setq func2 (aref composition-function-table
 605                                   (char-after end))
 606                       end (1+ end))
 607               (setq func2 nil))))
 608         (if (< start end)
 609             (remove-text-properties start end '(auto-composed nil)))))))
 610
 611 (defun turn-on-auto-composition-if-enabled ()
 612   (if enable-multibyte-characters
 613       (auto-composition-mode 1)))
 614
 615 ;;;###autoload
 616 (define-global-minor-mode global-auto-composition-mode
 617   auto-composition-mode turn-on-auto-composition-if-enabled
 618   :extra-args (dummy)
 619   :initialize 'custom-initialize-safe-default
 620   :init-value (not noninteractive)
 621   :group 'auto-composition
 622   :version "23.1")
 623
 624 (defun toggle-auto-composition (&optional arg)
 625   "Change whether automatic character composition is enabled in this buffer.
 626 With arg, enable it iff arg is positive."
 627   (interactive "P")
 628   (let ((enable (if (null arg) (not auto-composition-function)
 629                   (> (prefix-numeric-value arg) 0))))
 630     (if enable
 631         (kill-local-variable 'auto-composition-function)
 632       (make-local-variable 'auto-composition-function)
 633       (setq auto-composition-function nil)
 634       (save-buffer-state nil
 635         (save-restriction
 636           (widen)
 637           (decompose-region (point-min) (point-max)))))
 638
 639     (save-buffer-state nil
 640       (save-restriction
 641         (widen)
 642         (remove-text-properties (point-min) (point-max)
 643                                 '(auto-composed nil))))))
 644
 645 (defun auto-compose-region (from to)
 646   "Force automatic character composition on the region FROM and TO."
 647   (save-excursion
 648     (if (get-text-property from 'auto-composed)
 649         (setq from (next-single-property-change from 'auto-composed nil to)))
 650     (goto-char from)
 651     (let ((modified-p (buffer-modified-p))
 652           (inhibit-read-only '(composition auto-composed))
 653           (stop (next-single-property-change (point) 'auto-composed nil to)))
 654       (while (< (point) to)
 655         (if (= (point) stop)
 656             (progn
 657               (goto-char (next-single-property-change (point)
 658                                                       'auto-composed nil to))
 659               (setq stop (next-single-property-change (point)
 660                                                       'auto-composed nil to)))
 661           (let ((func (aref composition-function-table (following-char)))
 662                 (pos (point)))
 663             (if (functionp func)
 664                 (goto-char (funcall func (point) nil)))
 665             (if (<= (point) pos)
 666                 (forward-char 1)))))
 667       (put-text-property from to 'auto-composed t)
 668       (set-buffer-modified-p modified-p))))
 669
 670 \f
 671 ;; The following codes are only for backward compatibility with Emacs
 672 ;; 20.4 and earlier.
 673
 674 (defun decompose-composite-char (char &optional type with-composition-rule)
 675   "Convert CHAR to string.
 676
 677 If optional 2nd arg TYPE is non-nil, it is `string', `list', or
 678 `vector'.  In this case, CHAR is converted to string, list of CHAR, or
 679 vector of CHAR respectively.
 680 Optional 3rd arg WITH-COMPOSITION-RULE is ignored."
 681   (cond ((or (null type) (eq type 'string)) (char-to-string char))
 682         ((eq type 'list) (list char))
 683         (t (vector char))))
 684
 685 (make-obsolete 'decompose-composite-char 'char-to-string "21.1")
 686
 687 \f
 688
 689 ;; arch-tag: ee703d77-1723-45d4-a31f-e9f0f867aa33
 690 ;;; composite.el ends here