lisp/composite.el

   1 ;;; composite.el --- support character composition
   2
   3 ;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   4 ;;   2008, 2009
   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.  In
 201 this case, TAB element has a special meaning.  If the first
 202 characer is TAB, the glyphs are displayed with left padding space
 203 so that no pixel overlaps with the previous column.  If the last
 204 character is TAB, the glyphs are displayed with rigth padding
 205 space so that no pixel overlaps with the following column.
 206
 207 If it is a vector or list, it is a sequence of alternate characters and
 208 composition rules, where (2N)th elements are characters and (2N+1)th
 209 elements are composition rules to specify how to compose (2N+2)th
 210 elements with previously composed N glyphs.
 211
 212 A composition rule is a cons of global and new glyph reference point
 213 symbols.  See the documentation of `reference-point-alist' for more
 214 detail.
 215
 216 Optional 4th argument MODIFICATION-FUNC is a function to call to
 217 adjust the composition when it gets invalid because of a change of
 218 text in the composition."
 219   (interactive "r")
 220   (let ((modified-p (buffer-modified-p))
 221         (inhibit-read-only t))
 222     (if (or (vectorp components) (listp components))
 223         (setq components (encode-composition-components components)))
 224     (compose-region-internal start end components modification-func)
 225     (restore-buffer-modified-p modified-p)))
 226
 227 (defun decompose-region (start end)
 228   "Decompose text in the current region.
 229
 230 When called from a program, expects two arguments,
 231 positions (integers or markers) specifying the region."
 232   (interactive "r")
 233   (let ((modified-p (buffer-modified-p))
 234         (inhibit-read-only t))
 235     (remove-text-properties start end '(composition nil))
 236     (restore-buffer-modified-p modified-p)))
 237
 238 (defun compose-string (string &optional start end components modification-func)
 239   "Compose characters in string STRING.
 240
 241 The return value is STRING with the `composition' property put on all
 242 the characters in it.
 243
 244 Optional 2nd and 3rd arguments START and END specify the range of
 245 STRING to be composed.  They default to the beginning and the end of
 246 STRING respectively.
 247
 248 Optional 4th argument COMPONENTS, if non-nil, is a character or a
 249 sequence (vector, list, or string) of integers.  See the function
 250 `compose-region' for more detail.
 251
 252 Optional 5th argument MODIFICATION-FUNC is a function to call to
 253 adjust the composition when it gets invalid because of a change of
 254 text in the composition."
 255   (if (or (vectorp components) (listp components))
 256       (setq components (encode-composition-components components)))
 257   (or start (setq start 0))
 258   (or end (setq end (length string)))
 259   (compose-string-internal string start end components modification-func)
 260   string)
 261
 262 (defun decompose-string (string)
 263   "Return STRING where `composition' property is removed."
 264   (remove-text-properties 0 (length string) '(composition nil) string)
 265   string)
 266
 267 (defun compose-chars (&rest args)
 268   "Return a string from arguments in which all characters are composed.
 269 For relative composition, arguments are characters.
 270 For rule-based composition, Mth \(where M is odd) arguments are
 271 characters, and Nth \(where N is even) arguments are composition rules.
 272 A composition rule is a cons of glyph reference points of the form
 273 \(GLOBAL-REF-POINT . NEW-REF-POINT).  See the documentation of
 274 `reference-point-alist' for more detail."
 275   (let (str components)
 276     (if (consp (car (cdr args)))
 277         ;; Rule-base composition.
 278         (let ((len (length args))
 279               (tail (encode-composition-components args 'nocopy)))
 280
 281           (while tail
 282             (setq str (cons (car tail) str))
 283             (setq tail (nthcdr 2 tail)))
 284           (setq str (concat (nreverse str))
 285                 components args))
 286       ;; Relative composition.
 287       (setq str (concat args)))
 288     (compose-string-internal str 0 (length str) components)))
 289
 290 (defun find-composition (pos &optional limit string detail-p)
 291   "Return information about a composition at or nearest to buffer position POS.
 292
 293 If the character at POS has `composition' property, the value is a list
 294 of FROM, TO, and VALID-P.
 295
 296 FROM and TO specify the range of text that has the same `composition'
 297 property, VALID-P is t if this composition is valid, and nil if not.
 298
 299 If there's no composition at POS, and the optional 2nd argument LIMIT
 300 is non-nil, search for a composition toward LIMIT.
 301
 302 If no composition is found, return nil.
 303
 304 Optional 3rd argument STRING, if non-nil, is a string to look for a
 305 composition in; nil means the current buffer.
 306
 307 If a valid composition is found and the optional 4th argument DETAIL-P
 308 is non-nil, the return value is a list of FROM, TO, COMPONENTS,
 309 RELATIVE-P, MOD-FUNC, and WIDTH.
 310
 311 COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
 312
 313 RELATIVE-P is t if the composition method is relative, else nil.
 314
 315 If RELATIVE-P is t, COMPONENTS is a vector of characters to be
 316 composed.  If RELATIVE-P is nil, COMPONENTS is a vector of characters
 317 and composition rules as described in `compose-region'.
 318
 319 MOD-FUNC is a modification function of the composition.
 320
 321 WIDTH is a number of columns the composition occupies on the screen.
 322
 323 When Automatic Compostion mode is on, this function also finds a
 324 chunk of text that is automatically composed.  If such a chunk is
 325 found closer to POS than the position that has `composition'
 326 property, the value is a list of FROM, TO, and a glyph gstring
 327 the specify how the chunk is composed.  See the function
 328 `composition-get-gstring' for the format of the glyph string."
 329   (let ((result (find-composition-internal pos limit string detail-p)))
 330     (if (and detail-p (> (length result) 3) (nth 2 result) (not (nth 3 result)))
 331         ;; This is a valid rule-base composition.
 332         (decode-composition-components (nth 2 result) 'nocopy))
 333     result))
 334
 335 \f
 336 (defun compose-chars-after (pos &optional limit object)
 337   "Compose characters in current buffer after position POS.
 338
 339 It looks up the char-table `composition-function-table' (which
 340 see) by a character at POS, and compose characters after POS
 341 according to the contents of `composition-function-table'.
 342
 343 Optional 2nd arg LIMIT, if non-nil, limits characters to compose.
 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         (font-obj (and (display-multi-font-p)
 351                        (and (not (stringp object))
 352                             (font-at pos (selected-window)))))
 353         pattern func result)
 354     (or limit
 355         (setq limit (if (stringp object) (length object) (point-max))))
 356     (when (and font-obj tail)
 357       (save-match-data
 358         (save-excursion
 359           (while tail
 360             (if (functionp (car tail))
 361                 (setq pattern nil func (car tail))
 362               (setq pattern (car (car tail))
 363                     func (cdr (car tail))))
 364             (goto-char pos)
 365             (if pattern
 366                 (if (and (if (stringp object)
 367                              (eq (string-match pattern object) 0)
 368                            (looking-at pattern))
 369                          (<= (match-end 0) limit))
 370                     (setq result
 371                           (funcall func pos (match-end 0) font-obj object)))
 372               (setq result (funcall func pos limit font-obj  object)))
 373             (if result (setq tail nil))))))
 374     result))
 375
 376 (defun compose-last-chars (args)
 377   "Compose last characters.
 378 The argument is a parameterized event of the form
 379         \(compose-last-chars N COMPONENTS),
 380 where N is the number of characters before point to compose,
 381 COMPONENTS, if non-nil, is the same as the argument to `compose-region'
 382 \(which see).  If it is nil, `compose-chars-after' is called,
 383 and that function finds a proper rule to compose the target characters.
 384 This function is intended to be used from input methods.
 385 The global keymap binds special event `compose-last-chars' to this
 386 function.  Input method may generate an event (compose-last-chars N COMPONENTS)
 387 after a sequence of character events."
 388   (interactive "e")
 389   (let ((chars (nth 1 args)))
 390     (if (and (numberp chars)
 391              (>= (- (point) (point-min)) chars))
 392         (if (nth 2 args)
 393             (compose-region (- (point) chars) (point) (nth 2 args))
 394           (compose-chars-after (- (point) chars) (point))))))
 395
 396 (global-set-key [compose-last-chars] 'compose-last-chars)
 397
 398 \f
 399 ;;; Automatic character composition.
 400
 401 ;; Copied from font-lock.el.
 402 (eval-when-compile
 403   ;; Borrowed from lazy-lock.el.
 404   ;; We use this to preserve or protect things when modifying text properties.
 405   (defmacro save-buffer-state (varlist &rest body)
 406     "Bind variables according to VARLIST and eval BODY restoring buffer state."
 407     `(let* ,(append varlist
 408                     '((modified (buffer-modified-p)) (buffer-undo-list t)
 409                       (inhibit-read-only t) (inhibit-point-motion-hooks t)
 410                       (inhibit-modification-hooks t)
 411                       deactivate-mark buffer-file-name buffer-file-truename))
 412        ,@body
 413        (unless modified
 414          (restore-buffer-modified-p nil))))
 415   ;; Fixme: This makes bootstrapping fail with this error.
 416   ;;   Symbol's function definition is void: eval-defun
 417   ;;(def-edebug-spec save-buffer-state let)
 418   )
 419
 420 (put 'save-buffer-state 'lisp-indent-function 1)
 421
 422 ;; These macros must match with C macros LGSTRING_XXX and LGLYPH_XXX in font.h
 423 (defsubst lgstring-header (gstring) (aref gstring 0))
 424 (defsubst lgstring-set-header (gstring header) (aset gstring 0 header))
 425 (defsubst lgstring-font (gstring) (aref (lgstring-header gstring) 0))
 426 (defsubst lgstring-char (gstring i) (aref (lgstring-header gstring) (1+ i)))
 427 (defsubst lgstring-char-len (gstring) (1- (length (lgstring-header gstring))))
 428 (defsubst lgstring-shaped-p (gstring) (aref gstring 1))
 429 (defsubst lgstring-set-id (gstring id) (aset gstring 1 id))
 430 (defsubst lgstring-glyph (gstring i) (aref gstring (+ i 2)))
 431 (defsubst lgstring-glyph-len (gstring) (- (length gstring) 2))
 432 (defsubst lgstring-set-glyph (gstring i glyph) (aset gstring (+ i 2) glyph))
 433
 434 (defsubst lglyph-from (glyph) (aref glyph 0))
 435 (defsubst lglyph-to (glyph) (aref glyph 1))
 436 (defsubst lglyph-char (glyph) (aref glyph 2))
 437 (defsubst lglyph-code (glyph) (aref glyph 3))
 438 (defsubst lglyph-width (glyph) (aref glyph 4))
 439 (defsubst lglyph-lbearing (glyph) (aref glyph 5))
 440 (defsubst lglyph-rbearing (glyph) (aref glyph 6))
 441 (defsubst lglyph-ascent (glyph) (aref glyph 7))
 442 (defsubst lglyph-descent (glyph) (aref glyph 8))
 443 (defsubst lglyph-adjustment (glyph) (aref glyph 9))
 444
 445 (defsubst lglyph-set-from-to (glyph from to)
 446   (progn (aset glyph 0 from) (aset glyph 1 to)))
 447 (defsubst lglyph-set-char (glyph char) (aset glyph 2 char))
 448 (defsubst lglyph-set-code (glyph code) (aset glyph 3 code))
 449 (defsubst lglyph-set-width (glyph width) (aset glyph 4 width))
 450 (defsubst lglyph-set-adjustment (glyph &optional xoff yoff wadjust)
 451   (aset glyph 9 (vector (or xoff 0) (or yoff 0) (or wadjust 0))))
 452
 453 (defsubst lglyph-copy (glyph) (copy-sequence glyph))
 454
 455 (defun lgstring-insert-glyph (gstring idx glyph)
 456   (let ((nglyphs (lgstring-glyph-len gstring))
 457         (i idx) g)
 458     (while (and (< i nglyphs) (setq g (lgstring-glyph gstring i)))
 459       (setq i (1+ i)))
 460     (if (= i nglyphs)
 461         (setq gstring (vconcat gstring (vector glyph)))
 462       (if (< (1+ i) nglyphs)
 463           (lgstring-set-glyph gstring (1+ i) nil)))
 464     (while (> i idx)
 465       (lgstring-set-glyph gstring i (lgstring-glyph gstring (1- i)))
 466       (setq i (1- i)))
 467     (lgstring-set-glyph gstring i glyph)
 468     gstring))
 469
 470 (defun compose-glyph-string (gstring from to)
 471   (let ((glyph (lgstring-glyph gstring from))
 472         from-pos to-pos
 473         ascent descent lbearing rbearing)
 474     (setq from-pos (lglyph-from glyph)
 475           to-pos (lglyph-to (lgstring-glyph gstring (1- to))))
 476     (lglyph-set-from-to glyph from-pos to-pos)
 477     (setq from (1+ from))
 478     (while (and (< from to)
 479                 (setq glyph (lgstring-glyph gstring from)))
 480       (lglyph-set-from-to glyph from-pos to-pos)
 481       (let ((xoff (if (<= (lglyph-rbearing glyph) 0) 0
 482                     (- (lglyph-width glyph)))))
 483         (lglyph-set-adjustment glyph xoff 0 0))
 484       (setq from (1+ from)))
 485     gstring))
 486
 487 (defun compose-glyph-string-relative (gstring from to &optional gap)
 488   (let ((font-object (lgstring-font gstring))
 489         (glyph (lgstring-glyph gstring from))
 490         from-pos to-pos
 491         ascent descent lbearing rbearing)
 492     (if gap
 493         (setq gap (floor (* (font-get font-object :size) gap)))
 494       (setq gap 0))
 495     (setq from-pos (lglyph-from glyph)
 496           to-pos (lglyph-to (lgstring-glyph gstring (1- to)))
 497           ascent (lglyph-ascent glyph)
 498           descent (lglyph-descent glyph))
 499     (lglyph-set-from-to glyph from-pos to-pos)
 500     (setq from (1+ from))
 501     (while (< from to)
 502       (setq glyph (lgstring-glyph gstring from))
 503       (lglyph-set-from-to glyph from-pos to-pos)
 504       (let ((this-ascent (lglyph-ascent glyph))
 505             (this-descent (lglyph-descent glyph))
 506             xoff yoff wadjust)
 507         (setq xoff (if (<= (lglyph-rbearing glyph) 0) 0
 508                      (- (lglyph-width glyph))))
 509         (if (> this-ascent 0)
 510             (if (< this-descent 0)
 511                 (setq yoff (- 0 ascent gap this-descent)
 512                       ascent (+ ascent gap this-ascent this-descent))
 513               (setq yoff 0))
 514           (setq yoff (+ descent gap this-ascent)
 515                 descent (+ descent gap this-ascent this-descent)))
 516         (if (or (/= xoff 0) (/= yoff 0))
 517             (lglyph-set-adjustment glyph xoff yoff 0)))
 518       (setq from (1+ from)))
 519     gstring))
 520
 521 (defun compose-gstring-for-graphic (gstring)
 522   "Compose glyph-string GSTRING for graphic display.
 523 Non-spacing characters are composed with the preceding base
 524 character.  If the preceding character is not a base character,
 525 each non-spacing character is composed as a spacing character by
 526 a padding space before and/or after the character.
 527
 528 All non-spacing characters has this function in
 529 `composition-function-table' unless overwritten."
 530   (let* ((header (lgstring-header gstring))
 531          (nchars (lgstring-char-len gstring))
 532          (nglyphs (lgstring-glyph-len gstring))
 533          (glyph (lgstring-glyph gstring 0)))
 534     (cond
 535      ;; A non-spacing character not following a proper base character.
 536      ((= nchars 1)
 537       (let ((lbearing (lglyph-lbearing glyph))
 538             (rbearing (lglyph-rbearing glyph))
 539             (width (lglyph-width glyph))
 540             xoff wadjust)
 541         (if (< lbearing 0)
 542             (setq xoff (- lbearing))
 543           (setq xoff 0 lbearing 0))
 544         (if (< rbearing width)
 545             (setq rbearing width))
 546         (lglyph-set-adjustment glyph xoff 0 (- rbearing lbearing))
 547         gstring))
 548
 549      ;; This sequence doesn't start with a proper base character.
 550      ((memq (get-char-code-property (lgstring-char gstring 0)
 551                                     'general-category)
 552             '(Mn Mc Me Zs Zl Zp Cc Cf Cs))
 553       nil)
 554
 555      ;; A base character and the following non-spacing characters.
 556      (t
 557       (let ((gstr (font-shape-gstring gstring)))
 558         (if (and gstr
 559                  (> (lglyph-to (lgstring-glyph gstr 0)) 0))
 560             gstr
 561           ;; The shaper of the font couldn't shape the gstring.
 562           ;; Shape them according to canonical-combining-class.
 563           (lgstring-set-id gstring nil)
 564           (let* ((width (lglyph-width glyph))
 565                  (ascent (lglyph-ascent glyph))
 566                  (descent (lglyph-descent glyph))
 567                  (rbearing (lglyph-rbearing glyph))
 568                  (lbearing (lglyph-lbearing glyph))
 569                  (center (/ (+ lbearing rbearing) 2))
 570                  (gap (round (* (font-get (lgstring-font gstring) :size) 0.1)))
 571                  xoff yoff)
 572             (dotimes (i nchars)
 573               (setq glyph (lgstring-glyph gstring i))
 574               (when (> i 0)
 575                 (let* ((class (get-char-code-property
 576                                (lglyph-char glyph) 'canonical-combining-class))
 577                        (lb (lglyph-lbearing glyph))
 578                        (rb (lglyph-rbearing glyph))
 579                        (as (lglyph-ascent glyph))
 580                        (de (lglyph-descent glyph))
 581                        (ce (/ (+ lb rb) 2))
 582                        xoff yoff)
 583                   (when (and class (>= class 200) (<= class 240))
 584                     (setq xoff 0 yoff 0)
 585                     (cond
 586                      ((= class 200)
 587                       (setq xoff (- lbearing ce)
 588                             yoff (if (> as 0) 0 (+ descent as))))
 589                      ((= class 202)
 590                       (if (> as 0) (setq as 0))
 591                       (setq xoff (- center ce)
 592                             yoff (if (> as 0) 0 (+ descent as))))
 593                      ((= class 204)
 594                       (if (> as 0) (setq as 0))
 595                       (setq xoff (- rbearing ce)
 596                             yoff (if (> as 0) 0 (+ descent as))))
 597                      ((= class 208)
 598                       (setq xoff (- lbearing rb)))
 599                      ((= class 210)
 600                       (setq xoff (- rbearing lb)))
 601                      ((= class 212)
 602                       (setq xoff (- lbearing ce)
 603                             yoff (if (>= de 0) 0 (- (- ascent) de))))
 604                      ((= class 214)
 605                       (setq xoff (- center ce)
 606                             yoff (if (>= de 0) 0 (- (- ascent) de))))
 607                      ((= class 216)
 608                       (setq xoff (- rbearing ce)
 609                             yoff (if (>= de 0) 0 (- (- ascent) de))))
 610                      ((= class 218)
 611                       (setq xoff (- lbearing ce)
 612                             yoff (if (> as 0) 0 (+ descent as gap))))
 613                      ((= class 220)
 614                       (setq xoff (- center ce)
 615                             yoff (if (> as 0) 0 (+ descent as gap))))
 616                      ((= class 222)
 617                       (setq xoff (- rbearing ce)
 618                             yoff (if (> as 0) 0 (+ descent as gap))))
 619                      ((= class 224)
 620                       (setq xoff (- lbearing rb)))
 621                      ((= class 226)
 622                       (setq xoff (- rbearing lb)))
 623                      ((= class 228)
 624                       (setq xoff (- lbearing ce)
 625                             yoff (if (>= de 0) 0 (- (- ascent) de gap))))
 626                      ((= class 230)
 627                       (setq xoff (- center ce)
 628                             yoff (if (>= de 0) 0 (- (- ascent) de gap))))
 629                      ((= class 232)
 630                       (setq xoff (- rbearing ce)
 631                             yoff (if (>= de 0) 0 (- (+ ascent de) gap)))))
 632                     (lglyph-set-adjustment glyph (- xoff width) yoff)
 633                     (setq lb (+ lb xoff)
 634                           rb (+ lb xoff)
 635                           as (- as yoff)
 636                           de (+ de yoff)))
 637                   (if (< ascent as)
 638                       (setq ascent as))
 639                   (if (< descent de)
 640                       (setq descent de))))))
 641           (let ((i 0))
 642             (while (and (< i nglyphs) (setq glyph (lgstring-glyph gstring i)))
 643               (lglyph-set-from-to glyph 0 (1- nchars))
 644               (setq i (1+ i))))
 645           gstring))))))
 646
 647 (let ((elt '(["[[:alpha:]]\\c^+" 1 compose-gstring-for-graphic]
 648              [nil 0 compose-gstring-for-graphic])))
 649   (map-char-table
 650    #'(lambda (key val)
 651        (if (= val 0)
 652            (set-char-table-range composition-function-table key elt)))
 653    char-width-table))
 654
 655 (defun compose-gstring-for-terminal (gstring)
 656   "Compose glyph string GSTRING for terminal display.
 657 Non-spacing characters are composed with the preceding base
 658 character.  If the preceding character is not a base character,
 659 each non-spacing character is composed as a spacing character by
 660 a prepending a space before it."
 661   (let* ((header (lgstring-header gstring))
 662          (nchars (lgstring-char-len gstring))
 663          (nglyphs (lgstring-glyph-len gstring))
 664          (i 0)
 665          glyph)
 666     (while (and (< i nglyphs)
 667                 (setq glyph (lgstring-glyph gstring i)))
 668       (if (= (lglyph-width glyph) 0)
 669           (progn
 670             ;; Compose by prepending a space.
 671             (setq gstring (lgstring-insert-glyph gstring i (lglyph-copy glyph))
 672                   nglyphs (lgstring-glyph-len gstring))
 673             (lglyph-set-char (lgstring-glyph gstring i) 32)
 674             (setq i (+ 2)))
 675         (let ((from (lglyph-from glyph))
 676               (to (lglyph-to glyph))
 677               (j (1+ i)))
 678           (while (and (< j nglyphs)
 679                       (setq glyph (lgstring-glyph gstring j))
 680                       (= (lglyph-width glyph) 0))
 681             (setq to (lglyph-to glyph)
 682                   j (1+ j)))
 683           (while (< i j)
 684             (setq glyph (lgstring-glyph gstring i))
 685             (lglyph-set-from-to glyph from to)
 686             (setq i (1+ i))))))
 687     gstring))
 688
 689
 690 (defun auto-compose-chars (func from to font-object string)
 691   "Compose the characters at FROM by FUNC.
 692 FUNC is called with one argument GSTRING which is built for characters
 693 in the region FROM (inclusive) and TO (exclusive).
 694
 695 If the character are composed on a graphic display, FONT-OBJECT
 696 is a font to use.
 697
 698 Otherwise, FONT-OBJECT is nil, and the fucntion
 699 `compose-gstring-for-terminal' is used instead of FUNC.
 700
 701 If STRING is non-nil, it is a string, and FROM and TO are indices
 702 into the string.  In that case, compose characters in the string.
 703
 704 The value is a gstring containing information for shaping the characters.
 705
 706 This function is the default value of `auto-composition-function' (which see)."
 707   (let ((gstring (composition-get-gstring from to font-object string)))
 708     (if (lgstring-shaped-p gstring)
 709         gstring
 710       (or font-object
 711           (setq func 'compose-gstring-for-terminal))
 712       (funcall func gstring))))
 713
 714 (make-variable-buffer-local 'auto-composition-function)
 715
 716 ;;;###autoload
 717 (define-minor-mode auto-composition-mode
 718   "Toggle Auto Composition mode.
 719 With ARG, turn Auto Composition mode off if and only if ARG is a non-positive
 720 number; if ARG is nil, toggle Auto Composition mode; anything else turns Auto
 721 Composition on.
 722
 723 When Auto Composition is enabled, text characters are automatically composed
 724 by functions registered in `composition-function-table' (which see).
 725
 726 You can use `global-auto-composition-mode' to turn on
 727 Auto Composition mode in all buffers (this is the default)."
 728   nil nil nil
 729   (if noninteractive
 730       (setq auto-composition-mode nil))
 731   (cond (auto-composition-mode
 732          (add-hook 'after-change-functions 'auto-composition-after-change nil t)
 733          (setq auto-composition-function 'auto-compose-chars))
 734         (t
 735          (remove-hook 'after-change-functions 'auto-composition-after-change t)
 736          (setq auto-composition-function nil)))
 737   (save-buffer-state nil
 738     (save-restriction
 739       (widen)
 740       (remove-text-properties (point-min) (point-max) '(auto-composed nil))
 741       (decompose-region (point-min) (point-max)))))
 742
 743 (defun auto-composition-after-change (start end old-len)
 744   (save-buffer-state nil
 745     (if (< start (point-min))
 746         (setq start (point-min)))
 747     (if (> end (point-max))
 748         (setq end (point-max)))
 749     (when (and auto-composition-mode (not memory-full))
 750       (let (func1 func2)
 751         (when (and (> start (point-min))
 752                    (setq func2 (aref composition-function-table
 753                                      (char-after (1- start))))
 754                    (or (= start (point-max))
 755                        (not (setq func1 (aref composition-function-table
 756                                               (char-after start))))
 757                        (eq func1 func2)))
 758           (setq start (1- start)
 759                 func1 func2)
 760           (while (eq func1 func2)
 761             (if (> start (point-min))
 762                 (setq start (1- start)
 763                       func2 (aref composition-function-table
 764                                   (char-after start)))
 765               (setq func2 nil))))
 766         (when (and (< end (point-max))
 767                    (setq func2 (aref composition-function-table
 768                                      (char-after end)))
 769                    (or (= end (point-min))
 770                        (not (setq func1 (aref composition-function-table
 771                                               (char-after (1- end)))))
 772                        (eq func1 func2)))
 773           (setq end (1+ end)
 774                 func1 func2)
 775           (while (eq func1 func2)
 776             (if (< end (point-max))
 777                 (setq func2 (aref composition-function-table
 778                                   (char-after end))
 779                       end (1+ end))
 780               (setq func2 nil))))
 781         (if (< start end)
 782             (remove-text-properties start end '(auto-composed nil)))))))
 783
 784 (defun turn-on-auto-composition-if-enabled ()
 785   (if enable-multibyte-characters
 786       (auto-composition-mode 1)))
 787
 788 ;;;###autoload
 789 (define-global-minor-mode global-auto-composition-mode
 790   auto-composition-mode turn-on-auto-composition-if-enabled
 791   :extra-args (dummy)
 792   :initialize 'custom-initialize-safe-default
 793   :init-value (not noninteractive)
 794   :group 'auto-composition
 795   :version "23.1")
 796
 797 (defun toggle-auto-composition (&optional arg)
 798   "Change whether automatic character composition is enabled in this buffer.
 799 With arg, enable it if and only if arg is positive."
 800   (interactive "P")
 801   (let ((enable (if (null arg) (not auto-composition-function)
 802                   (> (prefix-numeric-value arg) 0))))
 803     (if enable
 804         (kill-local-variable 'auto-composition-function)
 805       (make-local-variable 'auto-composition-function)
 806       (setq auto-composition-function nil)
 807       (save-buffer-state nil
 808         (save-restriction
 809           (widen)
 810           (decompose-region (point-min) (point-max)))))
 811
 812     (save-buffer-state nil
 813       (save-restriction
 814         (widen)
 815         (remove-text-properties (point-min) (point-max)
 816                                 '(auto-composed nil))))))
 817
 818 (defun auto-compose-region (from to)
 819   "Force automatic character composition on the region FROM and TO."
 820   (save-excursion
 821     (if (get-text-property from 'auto-composed)
 822         (setq from (next-single-property-change from 'auto-composed nil to)))
 823     (goto-char from)
 824     (let ((modified-p (buffer-modified-p))
 825           (inhibit-read-only '(composition auto-composed))
 826           (stop (next-single-property-change (point) 'auto-composed nil to)))
 827       (while (< (point) to)
 828         (if (= (point) stop)
 829             (progn
 830               (goto-char (next-single-property-change (point)
 831                                                       'auto-composed nil to))
 832               (setq stop (next-single-property-change (point)
 833                                                       'auto-composed nil to)))
 834           (let ((func (aref composition-function-table (following-char)))
 835                 (font-obj (and (display-multi-font-p)
 836                                (font-at (point) (selected-window))))
 837                 (pos (point)))
 838             (if (and (functionp func) font-obj)
 839                 (goto-char (funcall func (point) to font-obj nil)))
 840             (if (<= (point) pos)
 841                 (forward-char 1)))))
 842       (put-text-property from to 'auto-composed t)
 843       (set-buffer-modified-p modified-p))))
 844
 845 \f
 846 ;; The following codes are only for backward compatibility with Emacs
 847 ;; 20.4 and earlier.
 848
 849 (defun decompose-composite-char (char &optional type with-composition-rule)
 850   "Convert CHAR to string.
 851
 852 If optional 2nd arg TYPE is non-nil, it is `string', `list', or
 853 `vector'.  In this case, CHAR is converted to string, list of CHAR, or
 854 vector of CHAR respectively.
 855 Optional 3rd arg WITH-COMPOSITION-RULE is ignored."
 856   (cond ((or (null type) (eq type 'string)) (char-to-string char))
 857         ((eq type 'list) (list char))
 858         (t (vector char))))
 859
 860 (make-obsolete 'decompose-composite-char 'char-to-string "21.1")
 861
 862 \f
 863
 864 ;; arch-tag: ee703d77-1723-45d4-a31f-e9f0f867aa33
 865 ;;; composite.el ends here