1 ;;; composite.el --- support character composition
3 ;; Copyright (C) 1999 Electrotechnical Laboratory, JAPAN.
4 ;; Licensed to the Free Software Foundation.
6 ;; Keywords: mule, multilingual, character composition
8 ;; This file is part of GNU Emacs.
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)
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.
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.
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'.
45 Meanings of glyph reference point codes are as follows:
47 0----1----2 <---- ascent 0:tl or top-left
48 | | 1:tc or top-center
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
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
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):
67 +-------+--+ <--- new ascent
71 -- | | |-- <--- baseline \(doesn't change)
75 +----+-----+ <--- new descent
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.")
83 ;; Encode composition rule RULE into an integer value. RULE is a cons
84 ;; of global and new reference point symbols.
85 ;; This must be compatible with C macro COMPOSITION_ENCODE_RULE
86 ;; defined in composite.h.
88 (defun encode-composition-rule (rule)
89 (if (and (integerp rule) (< rule 144))
93 (let ((gref (car rule))
96 (if (consp nref) ; (GREF NREF XOFF YOFF)
98 (setq xoff (nth 1 nref)
101 (or (and (>= xoff -100) (<= xoff 100)
102 (>= yoff -100) (<= yoff 100))
103 (error "Invalid compostion rule: %s" rule))
104 (setq xoff (+ xoff 128) yoff (+ yoff 128)))
106 (setq xoff 0 yoff 0))
108 (setq gref (cdr (assq gref reference-point-alist))))
110 (setq nref (cdr (assq nref reference-point-alist))))
111 (or (and (>= gref 0) (< gref 12) (>= nref 0) (< nref 12))
112 (error "Invalid composition rule: %S" rule))
113 (logior (lsh xoff 16) (lsh yoff 8) (+ (* gref 12) nref)))
114 (error "Invalid composition rule: %S" rule))))
116 ;; Decode encoded composition rule RULE-CODE. The value is a cons of
117 ;; global and new reference point symbols.
118 ;; This must be compatible with C macro COMPOSITION_DECODE_RULE
119 ;; defined in composite.h.
121 (defun decode-composition-rule (rule-code)
122 (or (and (natnump rule-code) (< rule-code #x1000000))
123 (error "Invalid encoded composition rule: %S" rule-code))
124 (let ((xoff (lsh rule-code -16))
125 (yoff (logand (lsh rule-code -8) #xFF))
127 (setq rule-code (logand rule-code #xFF)
128 gref (car (rassq (/ rule-code 12) reference-point-alist))
129 nref (car (rassq (% rule-code 12) reference-point-alist)))
130 (or (and gref (symbolp gref) nref (symbolp nref))
131 (error "Invalid composition rule code: %S" rule-code))
132 (if (and (= xoff 0) (= yoff 0))
134 (setq xoff (- xoff 128) yoff (- yoff 128))
135 (list gref xoff yoff nref))))
137 ;; Encode composition rules in composition components COMPONENTS. The
138 ;; value is a copy of COMPONENTS, where composition rules (cons of
139 ;; global and new glyph reference point symbols) are replaced with
140 ;; encoded composition rules. Optional 2nd argument NOCOPY non-nil
141 ;; means don't make a copy but modify COMPONENTS directly.
143 (defun encode-composition-components (components &optional nocopy)
145 (setq components (copy-sequence components)))
146 (if (vectorp components)
147 (let ((len (length components))
151 (encode-composition-rule (aref components i)))
153 (let ((tail (cdr components)))
156 (encode-composition-rule (car tail)))
157 (setq tail (nthcdr 2 tail)))))
160 ;; Decode composition rule codes in composition components COMPONENTS.
161 ;; The value is a copy of COMPONENTS, where composition rule codes are
162 ;; replaced with composition rules (cons of global and new glyph
163 ;; reference point symbols). Optional 2nd argument NOCOPY non-nil
164 ;; means don't make a copy but modify COMPONENTS directly.
165 ;; It is assumed that COMPONENTS is a vector and is for rule-base
166 ;; composition, thus (2N+1)th elements are rule codes.
168 (defun decode-composition-components (components &optional nocopy)
170 (setq components (copy-sequence components)))
171 (let ((len (length components))
175 (decode-composition-rule (aref components i)))
179 (defun compose-region (start end &optional components modification-func)
180 "Compose characters in the current region.
182 Characters are composed relatively, i.e. composed by overstricking or
183 stacking depending on ascent, descent and other properties.
185 When called from a program, expects these four arguments.
187 First two arguments START and END are positions (integers or markers)
188 specifying the region.
190 Optional 3rd argument COMPONENTS, if non-nil, is a character, a string
191 or a vector or list of integers and rules.
193 If it is a character, it is an alternate character to display instead
194 of the text in the region.
196 If it is a string, the elements are alternate characters.
198 If it is a vector or list, it is a sequence of alternate characters and
199 composition rules, where (2N)th elements are characters and (2N+1)th
200 elements are composition rules to specify how to compose (2N+2)th
201 elements with previously composed N glyphs.
203 A composition rule is a cons of global and new glyph reference point
204 symbols. See the documentation of `reference-point-alist' for more
207 Optional 4th argument MODIFICATION-FUNC is a function to call to
208 adjust the composition when it gets invalid because of a change of
209 text in the composition."
211 (let ((modified-p (buffer-modified-p))
212 (buffer-read-only nil))
213 (if (or (vectorp components) (listp components))
214 (setq components (encode-composition-components components)))
215 (compose-region-internal start end components modification-func)
216 (restore-buffer-modified-p modified-p)))
218 (defun decompose-region (start end)
219 "Decompose text in the current region.
221 When called from a program, expects two arguments,
222 positions (integers or markers) specifying the region."
224 (let ((modified-p (buffer-modified-p))
225 (buffer-read-only nil))
226 (remove-text-properties start end '(composition nil))
227 (set-buffer-modified-p modified-p)))
229 (defun compose-string (string &optional start end components modification-func)
230 "Compose characters in string STRING.
232 The return value is STRING with the `composition' property put on all
233 the characters in it.
235 Optional 2nd and 3rd arguments START and END specify the range of
236 STRING to be composed. They default to the beginning and the end of
239 Optional 4th argument COMPONENTS, if non-nil, is a character or a
240 sequence (vector, list, or string) of integers. See the function
241 `compose-region' for more detail.
243 Optional 5th argument MODIFICATION-FUNC is a function to call to
244 adjust the composition when it gets invalid because of a change of
245 text in the composition."
246 (if (or (vectorp components) (listp components))
247 (setq components (encode-composition-components components)))
248 (or start (setq start 0))
249 (or end (setq end (length string)))
250 (compose-string-internal string start end components modification-func)
253 (defun decompose-string (string)
254 "Return STRING where `composition' property is removed."
255 (remove-text-properties 0 (length string) '(composition nil) string)
258 (defun compose-chars (&rest args)
259 "Return a string from arguments in which all characters are composed.
260 For relative composition, arguments are characters.
261 For rule-based composition, Mth \(where M is odd) arguments are
262 characters, and Nth \(where N is even) arguments are composition rules.
263 A composition rule is a cons of glyph reference points of the form
264 \(GLOBAL-REF-POINT . NEW-REF-POINT). See the documentation of
265 `reference-point-alist' for more detail."
266 (let (str components)
267 (if (consp (car (cdr args)))
268 ;; Rule-base composition.
269 (let ((len (length args))
270 (tail (encode-composition-components args 'nocopy)))
273 (setq str (cons (car tail) str))
274 (setq tail (nthcdr 2 tail)))
275 (setq str (concat (nreverse str))
277 ;; Relative composition.
278 (setq str (concat args)))
279 (compose-string-internal str 0 (length str) components)))
281 (defun find-composition (pos &optional limit string detail-p)
282 "Return information about a composition at or nearest to buffer position POS.
284 If the character at POS has `composition' property, the value is a list
285 of FROM, TO, and VALID-P.
287 FROM and TO specify the range of text that has the same `composition'
288 property, VALID-P is non-nil if and only if this composition is valid.
290 If there's no composition at POS, and the optional 2nd argument LIMIT
291 is non-nil, search for a composition toward LIMIT.
293 If no composition is found, return nil.
295 Optional 3rd argument STRING, if non-nil, is a string to look for a
296 composition in; nil means the current buffer.
298 If a valid composition is found and the optional 4th argument DETAIL-P
299 is non-nil, the return value is a list of FROM, TO, COMPONENTS,
300 RELATIVE-P, MOD-FUNC, and WIDTH.
302 COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
304 RELATIVE-P is t if the composition method is relative, else nil.
306 If RELATIVE-P is t, COMPONENTS is a vector of characters to be
307 composed. If RELATIVE-P is nil, COMPONENTS is a vector of characters
308 and composition rules as described in `compose-region'.
310 MOD-FUNC is a modification function of the composition.
312 WIDTH is a number of columns the composition occupies on the screen."
313 (let ((result (find-composition-internal pos limit string detail-p)))
314 (if (and detail-p result (nth 2 result) (not (nth 3 result)))
315 ;; This is a valid rule-base composition.
316 (decode-composition-components (nth 2 result) 'nocopy))
320 (defun compose-chars-after (pos &optional limit object)
321 "Compose characters in current buffer after position POS.
323 It looks up the char-table `composition-function-table' (which see) by
324 a character after POS. If non-nil value is found, the format of the
325 value should be an alist of PATTERNs vs FUNCs, where PATTERNs are
326 regular expressions and FUNCs are functions. If the text after POS
327 matches one of PATTERNs, call the corresponding FUNC with three
328 arguments POS, TO, and PATTERN, where TO is the end position of text
329 matching PATTERN, and return what FUNC returns. Otherwise, return
332 FUNC is responsible for composing the text properly. The return value
334 nil -- if no characters were composed.
335 CHARS (integer) -- if CHARS characters were composed.
337 Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
339 Optional 3rd arg OBJECT, if non-nil, is a string that contains the
340 text to compose. In that case, POS and LIMIT index into the string.
342 This function is the default value of `compose-chars-after-function'."
343 (let ((tail (aref composition-function-table (char-after pos)))
348 (while (and tail (not func))
349 (setq pattern (car (car tail))
350 func (cdr (car tail)))
353 (and (re-search-forward pattern limit t)
354 (= (match-beginning 0) pos))
355 (looking-at pattern))
356 (setq result (funcall func pos (match-end 0) pattern nil))
357 (setq func nil tail (cdr tail)))))))
360 (defun compose-last-chars (args)
361 "Compose last characters.
362 The argument is a parameterized event of the form
363 \(compose-last-chars N COMPONENTS),
364 where N is the number of characters before point to compose,
365 COMPONENTS, if non-nil, is the same as the argument to `compose-region'
366 \(which see). If it is nil, `compose-chars-after' is called,
367 and that function find a proper rule to compose the target characters.
368 This function is intended to be used from input methods.
369 The global keymap binds special event `compose-last-chars' to this
370 function. Input method may generate an event (compose-last-chars N COMPONENTS)
371 after a sequence character events."
373 (let ((chars (nth 1 args)))
374 (if (and (numberp chars)
375 (>= (- (point) (point-min)) chars))
377 (compose-region (- (point) chars) (point) (nth 2 args))
378 (compose-chars-after (- (point) chars) (point))))))
380 (global-set-key [compose-last-chars] 'compose-last-chars)
383 ;;; Automatic character composition.
385 (defvar composition-function-table
386 (make-char-table nil)
387 "Char table of functions for automatic character composition.
388 For each character that has to be composed automatically with
389 preceding and/or following characters, this char table contains
390 a function to call to compose that character.
392 Each function is called with two arguments, POS and STRING.
394 If STRING is nil, POS is a position in the current buffer, and the
395 function has to compose a character at POS with surrounding characters
396 in the current buffer.
398 Otherwise, STRING is a string, and POS is an index into the string. In
399 this case, the function has to compose a character at POS with
400 surrounding characters in the string.
402 See also the command `toggle-auto-composition'.")
404 ;; Copied from font-lock.el.
406 ;; Borrowed from lazy-lock.el.
407 ;; We use this to preserve or protect things when modifying text properties.
408 (defmacro save-buffer-state (varlist &rest body)
409 "Bind variables according to VARLIST and eval BODY restoring buffer state."
410 `(let* ,(append varlist
411 '((modified (buffer-modified-p)) (buffer-undo-list t)
412 (inhibit-read-only t) (inhibit-point-motion-hooks t)
413 (inhibit-modification-hooks t)
414 deactivate-mark buffer-file-name buffer-file-truename))
417 (restore-buffer-modified-p nil))))
418 ;; Fixme: This makes bootstrapping fail with this error.
419 ;; Symbol's function definition is void: eval-defun
420 ;;(def-edebug-spec save-buffer-state let)
423 (put 'save-buffer-state 'lisp-indent-function 1)
425 (defun auto-compose-chars (pos string)
426 "Compose characters after the buffer position POS.
427 If STRING is non-nil, it is a string, and POS is an index into the string.
428 In that case, compose characters in the string.
430 This function is the default value of `auto-composition-function' (which see)."
431 (save-buffer-state nil
436 (limit (if string (length string) (point-max)))
439 (or (text-property-any pos limit 'auto-composed t string)
445 (setq ch (aref string pos))
447 (throw 'tag (1+ pos)))
448 (setq func (aref composition-function-table ch))
449 (if (and (functionp func)
450 (setq newpos (funcall func pos string))
453 (setq pos (1+ pos))))
455 (setq ch (char-after pos))
457 (throw 'tag (1+ pos)))
458 (setq func (aref composition-function-table ch))
459 (if (and (functionp func)
460 (setq newpos (funcall func pos string))
463 (setq pos (1+ pos)))))
465 (put-text-property start pos 'auto-composed t string))
468 (setq auto-composition-function 'auto-compose-chars)
470 (defun toggle-auto-composition (&optional arg)
471 "Change whether automatic character composition is enabled in this buffer.
472 With arg, enable it iff arg is positive."
474 (let ((enable (if (null arg) (not auto-composition-function)
475 (> (prefix-numeric-value arg) 0))))
477 (kill-local-variable 'auto-composition-function)
478 (make-local-variable 'auto-composition-function)
479 (setq auto-composition-function nil)
480 (save-buffer-state nil
483 (decompose-region (point-min) (point-max)))))
485 (save-buffer-state nil
488 (put-text-property (point-min) (point-max) 'auto-composed nil)))))
490 (defun auto-compose-region (from to)
491 "Force automatic character composition on the region FROM and TO."
493 (if (get-text-property from 'auto-composed)
494 (setq from (next-single-property-change from 'auto-composed nil to)))
496 (let ((modified-p (buffer-modified-p))
497 (inhibit-read-only '(composition auto-composed))
498 (stop (next-single-property-change (point) 'auto-composed nil to)))
499 (while (< (point) to)
502 (goto-char (next-single-property-change (point)
503 'auto-composed nil to))
504 (setq stop (next-single-property-change (point)
505 'auto-composed nil to)))
506 (let ((func (aref composition-function-table (following-char)))
509 (goto-char (funcall func (point) nil)))
512 (put-text-property from to 'auto-composed t)
513 (set-buffer-modified-p modified-p))))
516 ;;; The following codes are only for backward compatibility with Emacs
517 ;;; 20.4 and earlier.
519 (defun decompose-composite-char (char &optional type with-composition-rule)
520 "Convert CHAR to string.
522 If optional 2nd arg TYPE is non-nil, it is `string', `list', or
523 `vector'. In this case, CHAR is converted to string, list of CHAR, or
524 vector of CHAR respectively.
525 Optional 3rd arg WITH-COMPOSITION-RULE is ignored."
526 (cond ((or (null type) (eq type 'string)) (char-to-string char))
527 ((eq type 'list) (list char))
530 (make-obsolete 'decompose-composite-char 'char-to-string "21.1")
534 ;;; arch-tag: ee703d77-1723-45d4-a31f-e9f0f867aa33
535 ;;; composite.el ends here