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