lisp/composite.el

   1 ;;; composite.el --- support character composition
   2
   3 ;; Copyright (C) 1999 Electrotechnical Laboratory, JAPAN.
   4 ;; Licensed to the Free Software Foundation.
   5
   6 ;; Keywords: mule, multilingual, character composition
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  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
  78 ;; Encode composition rule RULE into an integer value.  RULE is a cons
  79 ;; of global and new reference point symbols.
  80 ;; This must be compatible with C macro COMPOSITION_ENCODE_RULE
  81 ;; defined in composite.h.
  82
  83 (defun encode-composition-rule (rule)
  84   (if (and (integerp rule) (< rule 144))
  85       ;; Already encoded.
  86       rule
  87     (or (consp rule)
  88         (error "Invalid composition rule: %S" rule))
  89     (let ((gref (car rule))
  90           (nref (cdr rule)))
  91       (or (integerp gref)
  92           (setq gref (cdr (assq gref reference-point-alist))))
  93       (or (integerp nref)
  94           (setq nref (cdr (assq nref reference-point-alist))))
  95       (or (and (>= gref 0) (< gref 12) (>= nref 0) (< nref 12))
  96           (error "Invalid composition rule: %S" rule))
  97       (+ (* gref 12) nref))))
  98
  99 ;; Decode encoded composition rule RULE-CODE.  The value is a cons of
 100 ;; global and new reference point symbols.
 101 ;; This must be compatible with C macro COMPOSITION_DECODE_RULE
 102 ;; defined in composite.h.
 103
 104 (defun decode-composition-rule (rule-code)
 105   (or (and (natnump rule-code) (< rule-code 144))
 106       (error "Invalid encoded composition rule: %S" rule-code))
 107   (let ((gref (car (rassq (/ rule-code 12) reference-point-alist)))
 108         (nref (car (rassq (% rule-code 12) reference-point-alist))))
 109     (or (and gref (symbolp gref) nref (symbolp nref))
 110         (error "Invalid composition rule code: %S" rule-code))
 111     (cons gref nref)))
 112
 113 ;; Encode composition rules in composition components COMPONENTS.  The
 114 ;; value is a copy of COMPONENTS, where composition rules (cons of
 115 ;; global and new glyph reference point symbols) are replaced with
 116 ;; encoded composition rules.  Optional 2nd argument NOCOPY non-nil
 117 ;; means don't make a copy but modify COMPONENTS directly.
 118
 119 (defun encode-composition-components (components &optional nocopy)
 120   (or nocopy
 121       (setq components (copy-sequence components)))
 122   (if (vectorp components)
 123       (let ((len (length components))
 124             (i 1))
 125         (while (< i len)
 126           (aset components i
 127                 (encode-composition-rule (aref components i)))
 128           (setq i (+ i 2))))
 129     (let ((tail (cdr components)))
 130       (while tail
 131         (setcar tail
 132                 (encode-composition-rule (car tail)))
 133         (setq tail (nthcdr 2 tail)))))
 134   components)
 135
 136 ;; Decode composition rule codes in composition components COMPONENTS.
 137 ;; The value is a copy of COMPONENTS, where composition rule codes are
 138 ;; replaced with composition rules (cons of global and new glyph
 139 ;; reference point symbols).  Optional 2nd argument NOCOPY non-nil
 140 ;; means don't make a copy but modify COMPONENTS directly.
 141 ;; It is assumed that COMPONENTS is a vector and is for rule-base
 142 ;; composition, thus (2N+1)th elements are rule codes.
 143
 144 (defun decode-composition-components (components &optional nocopy)
 145   (or nocopy
 146       (setq components (copy-sequence components)))
 147   (let ((len (length components))
 148         (i 1))
 149     (while (< i len)
 150       (aset components i
 151             (decode-composition-rule (aref components i)))
 152       (setq i (+ i 2))))
 153   components)
 154
 155 (defun compose-region (start end &optional components modification-func)
 156   "Compose characters in the current region.
 157
 158 Characters are composed relatively, i.e. composed by overstricking or
 159 stacking depending on ascent, descent and other properties.
 160
 161 When called from a program, expects these four arguments.
 162
 163 First two arguments START and END are positions (integers or markers)
 164 specifying the region.
 165
 166 Optional 3rd argument COMPONENTS, if non-nil, is a character, a string
 167 or a vector or list of integers and rules.
 168
 169 If it is a character, it is an alternate character to display instead
 170 of the text in the region.
 171
 172 If it is a string, the elements are alternate characters.
 173
 174 If it is a vector or list, it is a sequence of alternate characters and
 175 composition rules, where (2N)th elements are characters and (2N+1)th
 176 elements are composition rules to specify how to compose (2N+2)th
 177 elements with previously composed N glyphs.
 178
 179 A composition rule is a cons of global and new glyph reference point
 180 symbols.  See the documentation of `reference-point-alist' for more
 181 detail.
 182
 183 Optional 4th argument MODIFICATION-FUNC is a function to call to
 184 adjust the composition when it gets invalid because of a change of
 185 text in the composition."
 186   (interactive "r")
 187   (let ((modified-p (buffer-modified-p))
 188         (buffer-read-only nil))
 189     (if (or (vectorp components) (listp components))
 190         (setq components (encode-composition-components components)))
 191     (compose-region-internal start end components modification-func)
 192     (set-buffer-modified-p modified-p)))
 193
 194 (defun decompose-region (start end)
 195   "Decompose text in the current region.
 196
 197 When called from a program, expects two arguments,
 198 positions (integers or markers) specifying the region."
 199   (interactive "r")
 200   (let ((modified-p (buffer-modified-p))
 201         (buffer-read-only nil))
 202     (remove-text-properties start end '(composition nil))
 203     (set-buffer-modified-p modified-p)))
 204
 205 (defun compose-string (string &optional start end components modification-func)
 206   "Compose characters in string STRING.
 207
 208 The return value is STRING with the `composition' property put on all
 209 the characters in it.
 210
 211 Optional 2nd and 3rd arguments START and END specify the range of
 212 STRING to be composed.  They default to the beginning and the end of
 213 STRING respectively.
 214
 215 Optional 4th argument COMPONENTS, if non-nil, is a character or a
 216 sequence (vector, list, or string) of integers.  See the function
 217 `compose-region' for more detail.
 218
 219 Optional 5th argument MODIFICATION-FUNC is a function to call to
 220 adjust the composition when it gets invalid because of a change of
 221 text in the composition."
 222   (if (or (vectorp components) (listp components))
 223       (setq components (encode-composition-components components)))
 224   (or start (setq start 0))
 225   (or end (setq end (length string)))
 226   (compose-string-internal string start end components modification-func)
 227   string)
 228
 229 (defun decompose-string (string)
 230   "Return STRING where `composition' property is removed."
 231   (remove-text-properties 0 (length string) '(composition nil) string)
 232   string)
 233
 234 (defun compose-chars (&rest args)
 235   "Return a string from arguments in which all characters are composed.
 236 For relative composition, arguments are characters.
 237 For rule-based composition, Mth \(where M is odd) arguments are
 238 characters, and Nth \(where N is even) arguments are composition rules.
 239 A composition rule is a cons of glyph reference points of the form
 240 \(GLOBAL-REF-POINT . NEW-REF-POINT).  See the documentation of
 241 `reference-point-alist' for more detail."
 242   (let (str components)
 243     (if (consp (car (cdr args)))
 244         ;; Rule-base composition.
 245         (let ((len (length args))
 246               (tail (encode-composition-components args 'nocopy)))
 247
 248           (while tail
 249             (setq str (cons (car tail) str))
 250             (setq tail (nthcdr 2 tail)))
 251           (setq str (concat (nreverse str))
 252                 components args))
 253       ;; Relative composition.
 254       (setq str (concat args)))
 255     (compose-string-internal str 0 (length str) components)))
 256
 257 (defun find-composition (pos &optional limit string detail-p)
 258   "Return information about a composition at or nearest to buffer position POS.
 259
 260 If the character at POS has `composition' property, the value is a list
 261 of FROM, TO, and VALID-P.
 262
 263 FROM and TO specify the range of text that has the same `composition'
 264 property, VALID-P is non-nil if and only if this composition is valid.
 265
 266 If there's no composition at POS, and the optional 2nd argument LIMIT
 267 is non-nil, search for a composition toward LIMIT.
 268
 269 If no composition is found, return nil.
 270
 271 Optional 3rd argument STRING, if non-nil, is a string to look for a
 272 composition in; nil means the current buffer.
 273
 274 If a valid composition is found and the optional 4th argument DETAIL-P
 275 is non-nil, the return value is a list of FROM, TO, COMPONENTS,
 276 RELATIVE-P, MOD-FUNC, and WIDTH.
 277
 278 COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
 279
 280 RELATIVE-P is t if the composition method is relative, else nil.
 281
 282 If RELATIVE-P is t, COMPONENTS is a vector of characters to be
 283 composed.  If RELATIVE-P is nil, COMPONENTS is a vector of characters
 284 and composition rules as described in `compose-region'.
 285
 286 MOD-FUNC is a modification function of the composition.
 287
 288 WIDTH is a number of columns the composition occupies on the screen."
 289   (let ((result (find-composition-internal pos limit string detail-p)))
 290     (if (and detail-p result (nth 2 result) (not (nth 3 result)))
 291         ;; This is a valid rule-base composition.
 292         (decode-composition-components (nth 2 result) 'nocopy))
 293     result))
 294
 295 \f
 296 (defun compose-chars-after (pos &optional limit object)
 297   "Compose characters in current buffer after position POS.
 298
 299 It looks up the char-table `composition-function-table' (which see) by
 300 a character after POS.  If non-nil value is found, the format of the
 301 value should be an alist of PATTERNs vs FUNCs, where PATTERNs are
 302 regular expressions and FUNCs are functions.  If the text after POS
 303 matches one of PATTERNs, call the corresponding FUNC with three
 304 arguments POS, TO, and PATTERN, where TO is the end position of text
 305 matching PATTERN, and return what FUNC returns.  Otherwise, return
 306 nil.
 307
 308 FUNC is responsible for composing the text properly.  The return value
 309 is:
 310   nil -- if no characters were composed.
 311   CHARS (integer) -- if CHARS characters were composed.
 312
 313 Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
 314
 315 Optional 3rd arg OBJECT, if non-nil, is a string that contains the
 316 text to compose.  In that case, POS and LIMIT index into the string.
 317
 318 This function is the default value of `compose-chars-after-function'."
 319   (let ((tail (aref composition-function-table (char-after pos)))
 320         pattern func result)
 321     (when tail
 322       (save-match-data
 323         (save-excursion
 324           (while (and tail (not func))
 325             (setq pattern (car (car tail))
 326                   func (cdr (car tail)))
 327             (goto-char pos)
 328             (if (if limit
 329                     (and (re-search-forward pattern limit t)
 330                          (= (match-beginning 0) pos))
 331                   (looking-at pattern))
 332                 (setq result (funcall func pos (match-end 0) pattern nil))
 333               (setq func nil tail (cdr tail)))))))
 334       result))
 335
 336 (defun compose-last-chars (args)
 337   "Compose last characters.
 338 The argument is a parameterized event of the form
 339         \(compose-last-chars N COMPONENTS),
 340 where N is the number of characters before point to compose,
 341 COMPONENTS, if non-nil, is the same as the argument to `compose-region'
 342 \(which see).  If it is nil, `compose-chars-after' is called,
 343 and that function find a proper rule to compose the target characters.
 344 This function is intended to be used from input methods.
 345 The global keymap binds special event `compose-last-chars' to this
 346 function.  Input method may generate an event (compose-last-chars N COMPONENTS)
 347 after a sequence character events."
 348   (interactive "e")
 349   (let ((chars (nth 1 args)))
 350     (if (and (numberp chars)
 351              (>= (- (point) (point-min)) chars))
 352         (if (nth 2 args)
 353             (compose-region (- (point) chars) (point) (nth 2 args))
 354           (compose-chars-after (- (point) chars) (point))))))
 355
 356 (global-set-key [compose-last-chars] 'compose-last-chars)
 357
 358 \f
 359 ;;; Automatic character composition.
 360
 361 (defvar composition-function-table
 362   (make-char-table nil)
 363   "Char table of functions for automatic character composition.
 364 For each character that has to be composed automatically with
 365 preceding and/or following characters, this char table contains
 366 a function to call to compose that character.
 367
 368 Each function is called with two arguments, POS and STRING.
 369
 370 If STRING is nil, POS is a position in the current buffer, and the
 371 function has to compose a character at POS with surrounding characters
 372 in the current buffer.
 373
 374 Otherwise, STRING is a string, and POS is an index into the string.  In
 375 this case, the function has to compose a character at POS with
 376 surrounding characters in the string.
 377
 378 See also the command `toggle-auto-composition'.")
 379
 380 ;; Copied from font-lock.el.
 381 (eval-when-compile
 382   ;; Borrowed from lazy-lock.el.
 383   ;; We use this to preserve or protect things when modifying text properties.
 384   (defmacro save-buffer-state (varlist &rest body)
 385     "Bind variables according to VARLIST and eval BODY restoring buffer state."
 386     `(let* ,(append varlist
 387                     '((modified (buffer-modified-p)) (buffer-undo-list t)
 388                       (inhibit-read-only t) (inhibit-point-motion-hooks t)
 389                       (inhibit-modification-hooks t)
 390                       deactivate-mark buffer-file-name buffer-file-truename))
 391        ,@body
 392        (unless modified
 393          (restore-buffer-modified-p nil))))
 394   ;; Fixme: This makes bootstrapping fail with this error.
 395   ;;   Symbol's function definition is void: eval-defun
 396   ;;(def-edebug-spec save-buffer-state let)
 397   )
 398
 399 (put 'save-buffer-state 'lisp-indent-function 1)
 400
 401 (defun auto-compose-chars (pos string)
 402   "Compose characters after the buffer position POS.
 403 If STRING is non-nil, it is a string, and POS is an index into the string.
 404 In that case, compose characters in the string.
 405
 406 This function is the default value of `auto-composition-function' (which see)."
 407   (save-buffer-state nil
 408     (save-excursion
 409       (save-match-data
 410         (let ((start pos)
 411               (limit (if string (length string) (point-max)))
 412               ch func newpos)
 413           (setq limit (or (text-property-any pos limit 'auto-composed t string)
 414                           limit))
 415           (catch 'tag
 416             (if string
 417                 (while (< pos limit)
 418                   (setq ch (aref string pos))
 419                   (if (= ch ?\n)
 420                       (throw 'tag nil))
 421                   (setq func (aref composition-function-table ch))
 422                   (if (and (functionp func)
 423                            (setq newpos (funcall func pos string))
 424                            (> newpos pos))
 425                       (setq pos newpos)
 426                     (setq pos (1+ pos))))
 427               (while (< pos limit)
 428                 (setq ch (char-after pos))
 429                 (if (= ch ?\n)
 430                     (throw 'tag nil))
 431                 (setq func (aref composition-function-table ch))
 432                 (if (and (functionp func)
 433                          (setq newpos (funcall func pos string))
 434                          (> newpos pos))
 435                     (setq pos newpos)
 436                   (setq pos (1+ pos))))))
 437           (put-text-property start pos 'auto-composed t string))))))
 438
 439 (setq auto-composition-function 'auto-compose-chars)
 440
 441 (defun toggle-auto-composition (&optional arg)
 442   "Change whether automatic character composition is enabled in this buffer.
 443 With arg, enable it iff arg is positive."
 444   (interactive "P")
 445   (let ((enable (if (null arg) (not auto-composition-function)
 446                   (> (prefix-numeric-value arg) 0))))
 447     (if enable
 448         (kill-local-variable 'auto-composition-function)
 449       (make-local-variable 'auto-composition-function)
 450       (setq auto-composition-function nil)
 451       (save-buffer-state nil
 452         (save-restriction
 453           (widen)
 454           (decompose-region (point-min) (point-max)))))
 455
 456     (save-buffer-state nil
 457       (save-restriction
 458         (widen)
 459         (put-text-property (point-min) (point-max) 'auto-composed nil)))))
 460
 461 (defun auto-compose-region (from to)
 462   "Force automatic character composition on the region FROM and TO."
 463   (save-excursion
 464     (if (get-text-property from 'auto-composed)
 465         (setq from (next-single-property-change from 'auto-composed nil to)))
 466     (goto-char from)
 467     (let ((modified-p (buffer-modified-p))
 468           (inhibit-read-only '(composition auto-composed))
 469           (stop (next-single-property-change (point) 'auto-composed nil to)))
 470       (while (< (point) to)
 471         (if (= (point) stop)
 472             (progn
 473               (goto-char (next-single-property-change (point)
 474                                                       'auto-composed nil to))
 475               (setq stop (next-single-property-change (point)
 476                                                       'auto-composed nil to)))
 477           (let ((func (aref composition-function-table (following-char)))
 478                 (pos (point)))
 479             (if (functionp func)
 480                 (goto-char (funcall func (point) nil)))
 481             (if (<= (point) pos)
 482                 (forward-char 1)))))
 483       (put-text-property from to 'auto-composed t)
 484       (set-buffer-modified-p modified-p))))
 485
 486 \f
 487 ;;; The following codes are only for backward compatibility with Emacs
 488 ;;; 20.4 and earlier.
 489
 490 (defun decompose-composite-char (char &optional type with-composition-rule)
 491   "Convert CHAR to string.
 492
 493 If optional 2nd arg TYPE is non-nil, it is `string', `list', or
 494 `vector'.  In this case, CHAR is converted to string, list of CHAR, or
 495 vector of CHAR respectively.
 496 Optional 3rd arg WITH-COMPOSITION-RULE is ignored."
 497   (cond ((or (null type) (eq type 'string)) (char-to-string char))
 498         ((eq type 'list) (list char))
 499         (t (vector char))))
 500
 501 (make-obsolete 'decompose-composite-char 'char-to-string "21.1")
 502
 503 \f
 504 ;;; composite.el ends here