1 ;;; composite.el --- support character composition
3 ;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 ;; National Institute of Advanced Industrial Science and Technology (AIST)
6 ;; Registration Number H14PRO021
8 ;; Author: Kenichi HANDA <handa@etl.go.jp>
9 ;; (according to ack.texi)
10 ;; Keywords: mule, multilingual, character composition
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
31 (defconst reference-point-alist
32 '((tl .
0) (tc .
1) (tr .
2)
33 (Bl .
3) (Bc .
4) (Br .
5)
34 (bl .
6) (bc .
7) (br .
8)
35 (cl .
9) (cc .
10) (cr .
11)
36 (top-left .
0) (top-center .
1) (top-right .
2)
37 (base-left .
3) (base-center .
4) (base-right .
5)
38 (bottom-left .
6) (bottom-center .
7) (bottom-right .
8)
39 (center-left .
9) (center-center .
10) (center-right .
11)
40 ;; For backward compatibility...
41 (ml .
3) (mc .
10) (mr .
5)
42 (mid-left .
3) (mid-center .
10) (mid-right .
5))
43 "Alist of symbols vs integer codes of glyph reference points.
44 A glyph reference point symbol is to be used to specify a composition
45 rule in COMPONENTS argument to such functions as `compose-region'.
47 Meanings of glyph reference point codes are as follows:
49 0----1----2 <---- ascent 0:tl or top-left
50 | | 1:tc or top-center
52 | | 3:Bl or base-left 9:cl or center-left
53 9 10 11 <---- center 4:Bc or base-center 10:cc or center-center
54 | | 5:Br or base-right 11:cr or center-right
55 --3----4----5-- <-- baseline 6:bl or bottom-left
56 | | 7:bc or bottom-center
57 6----7----8 <---- descent 8:br or bottom-right
59 Glyph reference point symbols are to be used to specify composition
60 rule of the form \(GLOBAL-REF-POINT . NEW-REF-POINT), where
61 GLOBAL-REF-POINT is a reference point in the overall glyphs already
62 composed, and NEW-REF-POINT is a reference point in the new glyph to
65 For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and
66 NEW-REF-POINT is `tc' (top-center), the overall glyph is updated as
67 follows (the point `*' corresponds to both reference points):
69 +-------+--+ <--- new ascent
73 -- | | |-- <--- baseline \(doesn't change)
77 +----+-----+ <--- new descent
79 A composition rule may have the form \(GLOBAL-REF-POINT
80 NEW-REF-POINT XOFF YOFF), where XOFF and YOFF specifies how much
81 to shift NEW-REF-POINT from GLOBAL-REF-POINT. In this case, XOFF
82 and YOFF are integers in the range -100..100 representing the
83 shifting percentage against the font size.")
87 (defun encode-composition-rule (rule)
88 "Encode composition rule RULE into an integer value.
89 RULE is a cons of global and new reference point symbols
90 \(see `reference-point-alist')."
92 ;; This must be compatible with C macro COMPOSITION_ENCODE_RULE
93 ;; defined in composite.h.
95 (if (and (integerp rule
) (< rule
144))
99 (let ((gref (car rule
))
102 (if (consp nref
) ; (GREF NREF XOFF YOFF)
104 (setq xoff
(nth 1 nref
)
107 (or (and (>= xoff -
100) (<= xoff
100)
108 (>= yoff -
100) (<= yoff
100))
109 (error "Invalid composition rule: %s" rule
))
110 (setq xoff
(+ xoff
128) yoff
(+ yoff
128)))
112 (setq xoff
0 yoff
0))
114 (setq gref
(cdr (assq gref reference-point-alist
))))
116 (setq nref
(cdr (assq nref reference-point-alist
))))
117 (or (and (>= gref
0) (< gref
12) (>= nref
0) (< nref
12))
118 (error "Invalid composition rule: %S" rule
))
119 (logior (lsh xoff
16) (lsh yoff
8) (+ (* gref
12) nref
)))
120 (error "Invalid composition rule: %S" rule
))))
122 ;; Decode encoded composition rule RULE-CODE. The value is a cons of
123 ;; global and new reference point symbols.
124 ;; This must be compatible with C macro COMPOSITION_DECODE_RULE
125 ;; defined in composite.h.
127 (defun decode-composition-rule (rule-code)
128 (or (and (natnump rule-code
) (< rule-code
#x1000000
))
129 (error "Invalid encoded composition rule: %S" rule-code
))
130 (let ((xoff (lsh rule-code -
16))
131 (yoff (logand (lsh rule-code -
8) #xFF
))
133 (setq rule-code
(logand rule-code
#xFF
)
134 gref
(car (rassq (/ rule-code
12) reference-point-alist
))
135 nref
(car (rassq (% rule-code
12) reference-point-alist
)))
136 (or (and gref
(symbolp gref
) nref
(symbolp nref
))
137 (error "Invalid composition rule code: %S" rule-code
))
138 (if (and (= xoff
0) (= yoff
0))
140 (setq xoff
(- xoff
128) yoff
(- yoff
128))
141 (list gref xoff yoff nref
))))
143 ;; Encode composition rules in composition components COMPONENTS. The
144 ;; value is a copy of COMPONENTS, where composition rules (cons of
145 ;; global and new glyph reference point symbols) are replaced with
146 ;; encoded composition rules. Optional 2nd argument NOCOPY non-nil
147 ;; means don't make a copy but modify COMPONENTS directly.
149 (defun encode-composition-components (components &optional nocopy
)
151 (setq components
(copy-sequence components
)))
152 (if (vectorp components
)
153 (let ((len (length components
))
157 (encode-composition-rule (aref components i
)))
159 (let ((tail (cdr components
)))
162 (encode-composition-rule (car tail
)))
163 (setq tail
(nthcdr 2 tail
)))))
166 ;; Decode composition rule codes in composition components COMPONENTS.
167 ;; The value is a copy of COMPONENTS, where composition rule codes are
168 ;; replaced with composition rules (cons of global and new glyph
169 ;; reference point symbols). Optional 2nd argument NOCOPY non-nil
170 ;; means don't make a copy but modify COMPONENTS directly.
171 ;; It is assumed that COMPONENTS is a vector and is for rule-base
172 ;; composition, thus (2N+1)th elements are rule codes.
174 (defun decode-composition-components (components &optional nocopy
)
176 (setq components
(copy-sequence components
)))
177 (let ((len (length components
))
181 (decode-composition-rule (aref components i
)))
185 (defun compose-region (start end
&optional components modification-func
)
186 "Compose characters in the current region.
188 Characters are composed relatively, i.e. composed by overstricking or
189 stacking depending on ascent, descent and other properties.
191 When called from a program, expects these four arguments.
193 First two arguments START and END are positions (integers or markers)
194 specifying the region.
196 Optional 3rd argument COMPONENTS, if non-nil, is a character, a string
197 or a vector or list of integers and rules.
199 If it is a character, it is an alternate character to display instead
200 of the text in the region.
202 If it is a string, the elements are alternate characters. In
203 this case, TAB element has a special meaning. If the first
204 characer is TAB, the glyphs are displayed with left padding space
205 so that no pixel overlaps with the previous column. If the last
206 character is TAB, the glyphs are displayed with rigth padding
207 space so that no pixel overlaps with the following column.
209 If it is a vector or list, it is a sequence of alternate characters and
210 composition rules, where (2N)th elements are characters and (2N+1)th
211 elements are composition rules to specify how to compose (2N+2)th
212 elements with previously composed N glyphs.
214 A composition rule is a cons of global and new glyph reference point
215 symbols. See the documentation of `reference-point-alist' for more
218 Optional 4th argument MODIFICATION-FUNC is a function to call to
219 adjust the composition when it gets invalid because of a change of
220 text in the composition."
222 (let ((modified-p (buffer-modified-p))
223 (inhibit-read-only t
))
224 (if (or (vectorp components
) (listp components
))
225 (setq components
(encode-composition-components components
)))
226 (compose-region-internal start end components modification-func
)
227 (restore-buffer-modified-p modified-p
)))
229 (defun decompose-region (start end
)
230 "Decompose text in the current region.
232 When called from a program, expects two arguments,
233 positions (integers or markers) specifying the region."
235 (let ((modified-p (buffer-modified-p))
236 (inhibit-read-only t
))
237 (remove-text-properties start end
'(composition nil
))
238 (restore-buffer-modified-p modified-p
)))
240 (defun compose-string (string &optional start end components modification-func
)
241 "Compose characters in string STRING.
243 The return value is STRING with the `composition' property put on all
244 the characters in it.
246 Optional 2nd and 3rd arguments START and END specify the range of
247 STRING to be composed. They default to the beginning and the end of
250 Optional 4th argument COMPONENTS, if non-nil, is a character or a
251 sequence (vector, list, or string) of integers. See the function
252 `compose-region' for more detail.
254 Optional 5th argument MODIFICATION-FUNC is a function to call to
255 adjust the composition when it gets invalid because of a change of
256 text in the composition."
257 (if (or (vectorp components
) (listp components
))
258 (setq components
(encode-composition-components components
)))
259 (or start
(setq start
0))
260 (or end
(setq end
(length string
)))
261 (compose-string-internal string start end components modification-func
)
264 (defun decompose-string (string)
265 "Return STRING where `composition' property is removed."
266 (remove-text-properties 0 (length string
) '(composition nil
) string
)
269 (defun compose-chars (&rest args
)
270 "Return a string from arguments in which all characters are composed.
271 For relative composition, arguments are characters.
272 For rule-based composition, Mth \(where M is odd) arguments are
273 characters, and Nth \(where N is even) arguments are composition rules.
274 A composition rule is a cons of glyph reference points of the form
275 \(GLOBAL-REF-POINT . NEW-REF-POINT). See the documentation of
276 `reference-point-alist' for more detail."
277 (let (str components
)
278 (if (consp (car (cdr args
)))
279 ;; Rule-base composition.
280 (let ((len (length args
))
281 (tail (encode-composition-components args
'nocopy
)))
284 (setq str
(cons (car tail
) str
))
285 (setq tail
(nthcdr 2 tail
)))
286 (setq str
(concat (nreverse str
))
288 ;; Relative composition.
289 (setq str
(concat args
)))
290 (compose-string-internal str
0 (length str
) components
)))
292 (defun find-composition (pos &optional limit string detail-p
)
293 "Return information about a composition at or nearest to buffer position POS.
295 If the character at POS has `composition' property, the value is a list
296 of FROM, TO, and VALID-P.
298 FROM and TO specify the range of text that has the same `composition'
299 property, VALID-P is t if this composition is valid, and nil if not.
301 If there's no composition at POS, and the optional 2nd argument LIMIT
302 is non-nil, search for a composition toward LIMIT.
304 If no composition is found, return nil.
306 Optional 3rd argument STRING, if non-nil, is a string to look for a
307 composition in; nil means the current buffer.
309 If a valid composition is found and the optional 4th argument DETAIL-P
310 is non-nil, the return value is a list of FROM, TO, COMPONENTS,
311 RELATIVE-P, MOD-FUNC, and WIDTH.
313 COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
315 RELATIVE-P is t if the composition method is relative, else nil.
317 If RELATIVE-P is t, COMPONENTS is a vector of characters to be
318 composed. If RELATIVE-P is nil, COMPONENTS is a vector of characters
319 and composition rules as described in `compose-region'.
321 MOD-FUNC is a modification function of the composition.
323 WIDTH is a number of columns the composition occupies on the screen.
325 When Automatic Compostion mode is on, this function also finds a
326 chunk of text that is automatically composed. If such a chunk is
327 found closer to POS than the position that has `composition'
328 property, the value is a list of FROM, TO, and a glyph gstring
329 the specify how the chunk is composed. See the function
330 `composition-get-gstring' for the format of the glyph string."
331 (let ((result (find-composition-internal pos limit string detail-p
)))
332 (if (and detail-p
(> (length result
) 3) (nth 2 result
) (not (nth 3 result
)))
333 ;; This is a valid rule-base composition.
334 (decode-composition-components (nth 2 result
) 'nocopy
))
338 (defun compose-chars-after (pos &optional limit object
)
339 "Compose characters in current buffer after position POS.
341 It looks up the char-table `composition-function-table' (which
342 see) by a character at POS, and compose characters after POS
343 according to the contents of `composition-function-table'.
345 Optional 2nd arg LIMIT, if non-nil, limits characters to compose.
347 Optional 3rd arg OBJECT, if non-nil, is a string that contains the
348 text to compose. In that case, POS and LIMIT index into the string.
350 This function is the default value of `compose-chars-after-function'."
351 (let ((tail (aref composition-function-table
(char-after pos
)))
352 (font-obj (and (display-multi-font-p)
353 (and (not (stringp object
))
354 (font-at pos
(selected-window)))))
357 (setq limit
(if (stringp object
) (length object
) (point-max))))
358 (when (and font-obj tail
)
362 (if (functionp (car tail
))
363 (setq pattern nil func
(car tail
))
364 (setq pattern
(car (car tail
))
365 func
(cdr (car tail
))))
368 (if (and (if (stringp object
)
369 (eq (string-match pattern object
) 0)
370 (looking-at pattern
))
371 (<= (match-end 0) limit
))
373 (funcall func pos
(match-end 0) font-obj object
)))
374 (setq result
(funcall func pos limit font-obj object
)))
375 (if result
(setq tail nil
))))))
378 (defun compose-last-chars (args)
379 "Compose last characters.
380 The argument is a parameterized event of the form
381 \(compose-last-chars N COMPONENTS),
382 where N is the number of characters before point to compose,
383 COMPONENTS, if non-nil, is the same as the argument to `compose-region'
384 \(which see). If it is nil, `compose-chars-after' is called,
385 and that function finds a proper rule to compose the target characters.
386 This function is intended to be used from input methods.
387 The global keymap binds special event `compose-last-chars' to this
388 function. Input method may generate an event (compose-last-chars N COMPONENTS)
389 after a sequence of character events."
391 (let ((chars (nth 1 args
)))
392 (if (and (numberp chars
)
393 (>= (- (point) (point-min)) chars
))
395 (compose-region (- (point) chars
) (point) (nth 2 args
))
396 (compose-chars-after (- (point) chars
) (point))))))
398 (global-set-key [compose-last-chars
] 'compose-last-chars
)
401 ;;; Automatic character composition.
403 ;; Copied from font-lock.el.
405 ;; Borrowed from lazy-lock.el.
406 ;; We use this to preserve or protect things when modifying text properties.
407 (defmacro save-buffer-state
(varlist &rest body
)
408 "Bind variables according to VARLIST and eval BODY restoring buffer state."
409 `(let* ,(append varlist
410 '((modified (buffer-modified-p)) (buffer-undo-list t
)
411 (inhibit-read-only t
) (inhibit-point-motion-hooks t
)
412 (inhibit-modification-hooks t
)
413 deactivate-mark buffer-file-name buffer-file-truename
))
416 (restore-buffer-modified-p nil
))))
417 ;; Fixme: This makes bootstrapping fail with this error.
418 ;; Symbol's function definition is void: eval-defun
419 ;;(def-edebug-spec save-buffer-state let)
422 (put 'save-buffer-state
'lisp-indent-function
1)
424 ;; These macros must match with C macros LGSTRING_XXX and LGLYPH_XXX in font.h
425 (defsubst lgstring-header
(gstring) (aref gstring
0))
426 (defsubst lgstring-set-header
(gstring header
) (aset gstring
0 header
))
427 (defsubst lgstring-font
(gstring) (aref (lgstring-header gstring
) 0))
428 (defsubst lgstring-char
(gstring i
) (aref (lgstring-header gstring
) (1+ i
)))
429 (defsubst lgstring-char-len
(gstring) (1- (length (lgstring-header gstring
))))
430 (defsubst lgstring-shaped-p
(gstring) (aref gstring
1))
431 (defsubst lgstring-set-id
(gstring id
) (aset gstring
1 id
))
432 (defsubst lgstring-glyph
(gstring i
) (aref gstring
(+ i
2)))
433 (defsubst lgstring-glyph-len
(gstring) (- (length gstring
) 2))
434 (defsubst lgstring-set-glyph
(gstring i glyph
) (aset gstring
(+ i
2) glyph
))
436 (defsubst lglyph-from
(glyph) (aref glyph
0))
437 (defsubst lglyph-to
(glyph) (aref glyph
1))
438 (defsubst lglyph-char
(glyph) (aref glyph
2))
439 (defsubst lglyph-code
(glyph) (aref glyph
3))
440 (defsubst lglyph-width
(glyph) (aref glyph
4))
441 (defsubst lglyph-lbearing
(glyph) (aref glyph
5))
442 (defsubst lglyph-rbearing
(glyph) (aref glyph
6))
443 (defsubst lglyph-ascent
(glyph) (aref glyph
7))
444 (defsubst lglyph-descent
(glyph) (aref glyph
8))
445 (defsubst lglyph-adjustment
(glyph) (aref glyph
9))
447 (defsubst lglyph-set-from-to
(glyph from to
)
448 (progn (aset glyph
0 from
) (aset glyph
1 to
)))
449 (defsubst lglyph-set-char
(glyph char
) (aset glyph
2 char
))
450 (defsubst lglyph-set-code
(glyph code
) (aset glyph
3 code
))
451 (defsubst lglyph-set-width
(glyph width
) (aset glyph
4 width
))
452 (defsubst lglyph-set-adjustment
(glyph &optional xoff yoff wadjust
)
453 (aset glyph
9 (vector (or xoff
0) (or yoff
0) (or wadjust
0))))
455 (defsubst lglyph-copy
(glyph) (copy-sequence glyph
))
457 (defun lgstring-insert-glyph (gstring idx glyph
)
458 (let ((nglyphs (lgstring-glyph-len gstring
))
460 (while (and (< i nglyphs
) (setq g
(lgstring-glyph gstring i
)))
463 (setq gstring
(vconcat gstring
(vector glyph
)))
464 (if (< (1+ i
) nglyphs
)
465 (lgstring-set-glyph gstring
(1+ i
) nil
)))
467 (lgstring-set-glyph gstring i
(lgstring-glyph gstring
(1- i
)))
469 (lgstring-set-glyph gstring i glyph
)
472 (defun compose-glyph-string (gstring from to
)
473 (let ((glyph (lgstring-glyph gstring from
))
475 ascent descent lbearing rbearing
)
476 (setq from-pos
(lglyph-from glyph
)
477 to-pos
(lglyph-to (lgstring-glyph gstring
(1- to
))))
478 (lglyph-set-from-to glyph from-pos to-pos
)
479 (setq from
(1+ from
))
480 (while (and (< from to
)
481 (setq glyph
(lgstring-glyph gstring from
)))
482 (lglyph-set-from-to glyph from-pos to-pos
)
483 (let ((xoff (if (<= (lglyph-rbearing glyph
) 0) 0
484 (- (lglyph-width glyph
)))))
485 (lglyph-set-adjustment glyph xoff
0 0))
486 (setq from
(1+ from
)))
489 (defun compose-glyph-string-relative (gstring from to
&optional gap
)
490 (let ((font-object (lgstring-font gstring
))
491 (glyph (lgstring-glyph gstring from
))
493 ascent descent lbearing rbearing
)
495 (setq gap
(floor (* (font-get font-object
:size
) gap
)))
497 (setq from-pos
(lglyph-from glyph
)
498 to-pos
(lglyph-to (lgstring-glyph gstring
(1- to
)))
499 ascent
(lglyph-ascent glyph
)
500 descent
(lglyph-descent glyph
))
501 (lglyph-set-from-to glyph from-pos to-pos
)
502 (setq from
(1+ from
))
504 (setq glyph
(lgstring-glyph gstring from
))
505 (lglyph-set-from-to glyph from-pos to-pos
)
506 (let ((this-ascent (lglyph-ascent glyph
))
507 (this-descent (lglyph-descent glyph
))
509 (setq xoff
(if (<= (lglyph-rbearing glyph
) 0) 0
510 (- (lglyph-width glyph
))))
511 (if (> this-ascent
0)
512 (if (< this-descent
0)
513 (setq yoff
(- 0 ascent gap this-descent
)
514 ascent
(+ ascent gap this-ascent this-descent
))
516 (setq yoff
(+ descent gap this-ascent
)
517 descent
(+ descent gap this-ascent this-descent
)))
518 (if (or (/= xoff
0) (/= yoff
0))
519 (lglyph-set-adjustment glyph xoff yoff
0)))
520 (setq from
(1+ from
)))
523 (defun compose-gstring-for-graphic (gstring)
524 "Compose glyph-string GSTRING for graphic display.
525 Non-spacing characters are composed with the preceding base
526 character. If the preceding character is not a base character,
527 each non-spacing character is composed as a spacing character by
528 a padding space before and/or after the character.
530 All non-spacing characters has this function in
531 `composition-function-table' unless overwritten."
532 (let* ((header (lgstring-header gstring
))
533 (nchars (lgstring-char-len gstring
))
534 (nglyphs (lgstring-glyph-len gstring
))
535 (glyph (lgstring-glyph gstring
0)))
537 ;; A non-spacing character not following a proper base character.
539 (let ((lbearing (lglyph-lbearing glyph
))
540 (rbearing (lglyph-rbearing glyph
))
541 (width (lglyph-width glyph
))
544 (setq xoff
(- lbearing
))
545 (setq xoff
0 lbearing
0))
546 (if (< rbearing width
)
547 (setq rbearing width
))
548 (lglyph-set-adjustment glyph xoff
0 (- rbearing lbearing
))
551 ;; This sequence doesn't start with a proper base character.
552 ((memq (get-char-code-property (lgstring-char gstring
0)
554 '(Mn Mc Me Zs Zl Zp Cc Cf Cs
))
557 ;; A base character and the following non-spacing characters.
559 (let ((gstr (font-shape-gstring gstring
)))
561 (> (lglyph-to (lgstring-glyph gstr
0)) 0))
563 ;; The shaper of the font couldn't shape the gstring.
564 ;; Shape them according to canonical-combining-class.
565 (lgstring-set-id gstring nil
)
566 (let* ((width (lglyph-width glyph
))
567 (ascent (lglyph-ascent glyph
))
568 (descent (lglyph-descent glyph
))
569 (rbearing (lglyph-rbearing glyph
))
570 (lbearing (lglyph-lbearing glyph
))
571 (center (/ (+ lbearing rbearing
) 2))
572 (gap (round (* (font-get (lgstring-font gstring
) :size
) 0.1)))
575 (setq glyph
(lgstring-glyph gstring i
))
577 (let* ((class (get-char-code-property
578 (lglyph-char glyph
) 'canonical-combining-class
))
579 (lb (lglyph-lbearing glyph
))
580 (rb (lglyph-rbearing glyph
))
581 (as (lglyph-ascent glyph
))
582 (de (lglyph-descent glyph
))
585 (when (and class
(>= class
200) (<= class
240))
589 (setq xoff
(- lbearing ce
)
590 yoff
(if (> as
0) 0 (+ descent as
))))
592 (if (> as
0) (setq as
0))
593 (setq xoff
(- center ce
)
594 yoff
(if (> as
0) 0 (+ descent as
))))
596 (if (> as
0) (setq as
0))
597 (setq xoff
(- rbearing ce
)
598 yoff
(if (> as
0) 0 (+ descent as
))))
600 (setq xoff
(- lbearing rb
)))
602 (setq xoff
(- rbearing lb
)))
604 (setq xoff
(- lbearing ce
)
605 yoff
(if (>= de
0) 0 (- (- ascent
) de
))))
607 (setq xoff
(- center ce
)
608 yoff
(if (>= de
0) 0 (- (- ascent
) de
))))
610 (setq xoff
(- rbearing ce
)
611 yoff
(if (>= de
0) 0 (- (- ascent
) de
))))
613 (setq xoff
(- lbearing ce
)
614 yoff
(if (> as
0) 0 (+ descent as gap
))))
616 (setq xoff
(- center ce
)
617 yoff
(if (> as
0) 0 (+ descent as gap
))))
619 (setq xoff
(- rbearing ce
)
620 yoff
(if (> as
0) 0 (+ descent as gap
))))
622 (setq xoff
(- lbearing rb
)))
624 (setq xoff
(- rbearing lb
)))
626 (setq xoff
(- lbearing ce
)
627 yoff
(if (>= de
0) 0 (- (- ascent
) de gap
))))
629 (setq xoff
(- center ce
)
630 yoff
(if (>= de
0) 0 (- (- ascent
) de gap
))))
632 (setq xoff
(- rbearing ce
)
633 yoff
(if (>= de
0) 0 (- (+ ascent de
) gap
)))))
634 (lglyph-set-adjustment glyph
(- xoff width
) yoff
)
642 (setq descent de
))))))
644 (while (and (< i nglyphs
) (setq glyph
(lgstring-glyph gstring i
)))
645 (lglyph-set-from-to glyph
0 (1- nchars
))
649 (let ((elt '(["[[:alpha:]]\\c^+" 1 compose-gstring-for-graphic
]
650 [nil
0 compose-gstring-for-graphic
])))
654 (set-char-table-range composition-function-table key elt
)))
657 (defun compose-gstring-for-terminal (gstring)
658 "Compose glyph string GSTRING for terminal display.
659 Non-spacing characters are composed with the preceding base
660 character. If the preceding character is not a base character,
661 each non-spacing character is composed as a spacing character by
662 a prepending a space before it."
663 (let* ((header (lgstring-header gstring
))
664 (nchars (lgstring-char-len gstring
))
665 (nglyphs (lgstring-glyph-len gstring
))
668 (while (and (< i nglyphs
)
669 (setq glyph
(lgstring-glyph gstring i
)))
670 (if (= (lglyph-width glyph
) 0)
672 ;; Compose by prepending a space.
673 (setq gstring
(lgstring-insert-glyph gstring i
(lglyph-copy glyph
))
674 nglyphs
(lgstring-glyph-len gstring
))
675 (lglyph-set-char (lgstring-glyph gstring i
) 32)
677 (let ((from (lglyph-from glyph
))
678 (to (lglyph-to glyph
))
680 (while (and (< j nglyphs
)
681 (setq glyph
(lgstring-glyph gstring j
))
682 (= (lglyph-width glyph
) 0))
683 (setq to
(lglyph-to glyph
)
686 (setq glyph
(lgstring-glyph gstring i
))
687 (lglyph-set-from-to glyph from to
)
692 (defun auto-compose-chars (func from to font-object string
)
693 "Compose the characters at FROM by FUNC.
694 FUNC is called with one argument GSTRING which is built for characters
695 in the region FROM (inclusive) and TO (exclusive).
697 If the character are composed on a graphic display, FONT-OBJECT
700 Otherwise, FONT-OBJECT is nil, and the fucntion
701 `compose-gstring-for-terminal' is used instead of FUNC.
703 If STRING is non-nil, it is a string, and FROM and TO are indices
704 into the string. In that case, compose characters in the string.
706 The value is a gstring containing information for shaping the characters.
708 This function is the default value of `auto-composition-function' (which see)."
709 (let ((gstring (composition-get-gstring from to font-object string
)))
710 (if (lgstring-shaped-p gstring
)
713 (setq func
'compose-gstring-for-terminal
))
714 (funcall func gstring
))))
716 (make-variable-buffer-local 'auto-composition-function
)
719 (define-minor-mode auto-composition-mode
720 "Toggle Auto Composition mode.
721 With ARG, turn Auto Composition mode off if and only if ARG is a non-positive
722 number; if ARG is nil, toggle Auto Composition mode; anything else turns Auto
725 When Auto Composition is enabled, text characters are automatically composed
726 by functions registered in `composition-function-table' (which see).
728 You can use `global-auto-composition-mode' to turn on
729 Auto Composition mode in all buffers (this is the default)."
732 (setq auto-composition-mode nil
))
733 (cond (auto-composition-mode
734 (add-hook 'after-change-functions
'auto-composition-after-change nil t
)
735 (setq auto-composition-function
'auto-compose-chars
))
737 (remove-hook 'after-change-functions
'auto-composition-after-change t
)
738 (setq auto-composition-function nil
)))
739 (save-buffer-state nil
742 (remove-text-properties (point-min) (point-max) '(auto-composed nil
))
743 (decompose-region (point-min) (point-max)))))
745 (defun auto-composition-after-change (start end old-len
)
746 (save-buffer-state nil
747 (if (< start
(point-min))
748 (setq start
(point-min)))
749 (if (> end
(point-max))
750 (setq end
(point-max)))
751 (when (and auto-composition-mode
(not memory-full
))
753 (when (and (> start
(point-min))
754 (setq func2
(aref composition-function-table
755 (char-after (1- start
))))
756 (or (= start
(point-max))
757 (not (setq func1
(aref composition-function-table
758 (char-after start
))))
760 (setq start
(1- start
)
762 (while (eq func1 func2
)
763 (if (> start
(point-min))
764 (setq start
(1- start
)
765 func2
(aref composition-function-table
768 (when (and (< end
(point-max))
769 (setq func2
(aref composition-function-table
771 (or (= end
(point-min))
772 (not (setq func1
(aref composition-function-table
773 (char-after (1- end
)))))
777 (while (eq func1 func2
)
778 (if (< end
(point-max))
779 (setq func2
(aref composition-function-table
784 (remove-text-properties start end
'(auto-composed nil
)))))))
786 (defun turn-on-auto-composition-if-enabled ()
787 (if enable-multibyte-characters
788 (auto-composition-mode 1)))
791 (define-global-minor-mode global-auto-composition-mode
792 auto-composition-mode turn-on-auto-composition-if-enabled
794 :initialize
'custom-initialize-safe-default
795 :init-value
(not noninteractive
)
796 :group
'auto-composition
799 (defun toggle-auto-composition (&optional arg
)
800 "Change whether automatic character composition is enabled in this buffer.
801 With arg, enable it if and only if arg is positive."
803 (let ((enable (if (null arg
) (not auto-composition-function
)
804 (> (prefix-numeric-value arg
) 0))))
806 (kill-local-variable 'auto-composition-function
)
807 (make-local-variable 'auto-composition-function
)
808 (setq auto-composition-function nil
)
809 (save-buffer-state nil
812 (decompose-region (point-min) (point-max)))))
814 (save-buffer-state nil
817 (remove-text-properties (point-min) (point-max)
818 '(auto-composed nil
))))))
820 (defun auto-compose-region (from to
)
821 "Force automatic character composition on the region FROM and TO."
823 (if (get-text-property from
'auto-composed
)
824 (setq from
(next-single-property-change from
'auto-composed nil to
)))
826 (let ((modified-p (buffer-modified-p))
827 (inhibit-read-only '(composition auto-composed
))
828 (stop (next-single-property-change (point) 'auto-composed nil to
)))
829 (while (< (point) to
)
832 (goto-char (next-single-property-change (point)
833 'auto-composed nil to
))
834 (setq stop
(next-single-property-change (point)
835 'auto-composed nil to
)))
836 (let ((func (aref composition-function-table
(following-char)))
837 (font-obj (and (display-multi-font-p)
838 (font-at (point) (selected-window))))
840 (if (and (functionp func
) font-obj
)
841 (goto-char (funcall func
(point) to font-obj nil
)))
844 (put-text-property from to
'auto-composed t
)
845 (set-buffer-modified-p modified-p
))))
848 ;; The following codes are only for backward compatibility with Emacs
851 (defun decompose-composite-char (char &optional type with-composition-rule
)
852 "Convert CHAR to string.
854 If optional 2nd arg TYPE is non-nil, it is `string', `list', or
855 `vector'. In this case, CHAR is converted to string, list of CHAR, or
856 vector of CHAR respectively.
857 Optional 3rd arg WITH-COMPOSITION-RULE is ignored."
858 (cond ((or (null type
) (eq type
'string
)) (char-to-string char
))
859 ((eq type
'list
) (list char
))
862 (make-obsolete 'decompose-composite-char
'char-to-string
"21.1")
866 ;; arch-tag: ee703d77-1723-45d4-a31f-e9f0f867aa33
867 ;;; composite.el ends here