|
778
|
1 ;;; mule-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 ;;; Synched up with: Emacs 21.1 (lisp/composite.el).
|
|
|
26
|
|
|
27 ;;; Commentary:
|
|
|
28
|
|
|
29 ;;; Code:
|
|
|
30
|
|
|
31 ;;;###autoload
|
|
|
32 (defconst reference-point-alist
|
|
|
33 '((tl . 0) (tc . 1) (tr . 2)
|
|
|
34 (Bl . 3) (Bc . 4) (Br . 5)
|
|
|
35 (bl . 6) (bc . 7) (br . 8)
|
|
|
36 (cl . 9) (cc . 10) (cr . 11)
|
|
|
37 (top-left . 0) (top-center . 1) (top-right . 2)
|
|
|
38 (base-left . 3) (base-center . 4) (base-right . 5)
|
|
|
39 (bottom-left . 6) (bottom-center . 7) (bottom-right . 8)
|
|
|
40 (center-left . 9) (center-center . 10) (center-right . 11)
|
|
|
41 ;; For backward compatibility...
|
|
|
42 (ml . 3) (mc . 10) (mr . 5)
|
|
|
43 (mid-left . 3) (mid-center . 10) (mid-right . 5))
|
|
|
44 "UNIMPLEMENTED.
|
|
|
45 Alist of symbols vs integer codes of glyph reference points.
|
|
|
46 A glyph reference point symbol is to be used to specify a composition
|
|
|
47 rule in COMPONENTS argument to such functions as `compose-region' and
|
|
|
48 `make-composition'.
|
|
|
49
|
|
|
50 Meanings of glyph reference point codes are as follows:
|
|
|
51
|
|
|
52 0----1----2 <---- ascent 0:tl or top-left
|
|
|
53 | | 1:tc or top-center
|
|
|
54 | | 2:tr or top-right
|
|
|
55 | | 3:Bl or base-left 9:cl or center-left
|
|
|
56 9 10 11 <---- center 4:Bc or base-center 10:cc or center-center
|
|
|
57 | | 5:Br or base-right 11:cr or center-right
|
|
|
58 --3----4----5-- <-- baseline 6:bl or bottom-left
|
|
|
59 | | 7:bc or bottom-center
|
|
|
60 6----7----8 <---- descent 8:br or bottom-right
|
|
|
61
|
|
|
62 Glyph reference point symbols are to be used to specify composition
|
|
|
63 rule of the form \(GLOBAL-REF-POINT . NEW-REF-POINT), where
|
|
|
64 GLOBAL-REF-POINT is a reference point in the overall glyphs already
|
|
|
65 composed, and NEW-REF-POINT is a reference point in the new glyph to
|
|
|
66 be added.
|
|
|
67
|
|
|
68 For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and
|
|
|
69 NEW-REF-POINT is `tc' (top-center), the overall glyph is updated as
|
|
|
70 follows (the point `*' corresponds to both reference points):
|
|
|
71
|
|
|
72 +-------+--+ <--- new ascent
|
|
|
73 | | |
|
|
|
74 | global| |
|
|
|
75 | glyph | |
|
|
|
76 -- | | |-- <--- baseline \(doesn't change)
|
|
|
77 +----+--*--+
|
|
|
78 | | new |
|
|
|
79 | |glyph|
|
|
|
80 +----+-----+ <--- new descent
|
|
|
81 ")
|
|
|
82
|
|
|
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 mule-composite.h.
|
|
|
87
|
|
|
88 (defun encode-composition-rule (rule)
|
|
|
89 (if (and (integerp rule) (< rule 144))
|
|
|
90 ;; Already encoded.
|
|
|
91 rule
|
|
|
92 (or (consp rule)
|
|
|
93 (error "Invalid composition rule: %S" rule))
|
|
|
94 (let ((gref (car rule))
|
|
|
95 (nref (cdr rule)))
|
|
|
96 (or (integerp gref)
|
|
|
97 (setq gref (cdr (assq gref reference-point-alist))))
|
|
|
98 (or (integerp nref)
|
|
|
99 (setq nref (cdr (assq nref reference-point-alist))))
|
|
|
100 (or (and (>= gref 0) (< gref 12) (>= nref 0) (< nref 12))
|
|
|
101 (error "Invalid composition rule: %S" rule))
|
|
|
102 (+ (* gref 12) nref))))
|
|
|
103
|
|
|
104 ;; Decode encoded composition rule RULE-CODE. The value is a cons of
|
|
|
105 ;; global and new reference point symbols.
|
|
|
106 ;; This must be compatible with C macro COMPOSITION_DECODE_RULE
|
|
|
107 ;; defined in mule-composite.h.
|
|
|
108
|
|
|
109 (defun decode-composition-rule (rule-code)
|
|
|
110 (or (and (natnump rule-code) (< rule-code 144))
|
|
|
111 (error "Invalid encoded composition rule: %S" rule-code))
|
|
|
112 (let ((gref (car (rassq (/ rule-code 12) reference-point-alist)))
|
|
|
113 (nref (car (rassq (% rule-code 12) reference-point-alist))))
|
|
|
114 (or (and gref (symbolp gref) nref (symbolp nref))
|
|
|
115 (error "Invalid composition rule code: %S" rule-code))
|
|
|
116 (cons gref nref)))
|
|
|
117
|
|
|
118 ;; Encode composition rules in composition components COMPONENTS. The
|
|
|
119 ;; value is a copy of COMPONENTS, where composition rules (cons of
|
|
|
120 ;; global and new glyph reference point symbols) are replaced with
|
|
|
121 ;; encoded composition rules. Optional 2nd argument NOCOPY non-nil
|
|
|
122 ;; means don't make a copy but modify COMPONENTS directly.
|
|
|
123
|
|
|
124 (defun encode-composition-components (components &optional nocopy)
|
|
|
125 (or nocopy
|
|
|
126 (setq components (copy-sequence components)))
|
|
|
127 (if (vectorp components)
|
|
|
128 (let ((len (length components))
|
|
|
129 (i 1))
|
|
|
130 (while (< i len)
|
|
|
131 (aset components i
|
|
|
132 (encode-composition-rule (aref components i)))
|
|
|
133 (setq i (+ i 2))))
|
|
|
134 (let ((tail (cdr components)))
|
|
|
135 (while tail
|
|
|
136 (setcar tail
|
|
|
137 (encode-composition-rule (car tail)))
|
|
|
138 (setq tail (nthcdr 2 tail)))))
|
|
|
139 components)
|
|
|
140
|
|
|
141 ;; Decode composition rule codes in composition components COMPONENTS.
|
|
|
142 ;; The value is a copy of COMPONENTS, where composition rule codes are
|
|
|
143 ;; replaced with composition rules (cons of global and new glyph
|
|
|
144 ;; reference point symbols). Optional 2nd argument NOCOPY non-nil
|
|
|
145 ;; means don't make a copy but modify COMPONENTS directly.
|
|
|
146 ;; It is assumed that COMPONENTS is a vector and is for rule-base
|
|
|
147 ;; composition, thus (2N+1)th elements are rule codes.
|
|
|
148
|
|
|
149 (defun decode-composition-components (components &optional nocopy)
|
|
|
150 (or nocopy
|
|
|
151 (setq components (copy-sequence components)))
|
|
|
152 (let ((len (length components))
|
|
|
153 (i 1))
|
|
|
154 (while (< i len)
|
|
|
155 (aset components i
|
|
|
156 (decode-composition-rule (aref components i)))
|
|
|
157 (setq i (+ i 2))))
|
|
|
158 components)
|
|
|
159
|
|
|
160 ;;;###autoload
|
|
|
161 (defun compose-region (start end &optional components modification-func)
|
|
|
162 "UNIMPLEMENTED.
|
|
|
163 Compose characters in the current region.
|
|
|
164
|
|
|
165 When called from a program, expects these four arguments.
|
|
|
166
|
|
|
167 First two arguments START and END are positions (integers or markers)
|
|
|
168 specifying the region.
|
|
|
169
|
|
|
170 Optional 3rd argument COMPONENTS, if non-nil, is a character or a
|
|
|
171 sequence (vector, list, or string) of integers.
|
|
|
172
|
|
|
173 If it is a character, it is an alternate character to display instead
|
|
|
174 of the text in the region.
|
|
|
175
|
|
|
176 If it is a string, the elements are alternate characters.
|
|
|
177
|
|
|
178 If it is a vector or list, it is a sequence of alternate characters and
|
|
|
179 composition rules, where (2N)th elements are characters and (2N+1)th
|
|
|
180 elements are composition rules to specify how to compose (2N+2)th
|
|
|
181 elements with previously composed N glyphs.
|
|
|
182
|
|
|
183 A composition rule is a cons of global and new glyph reference point
|
|
|
184 symbols. See the documentation of `reference-point-alist' for more
|
|
|
185 detail.
|
|
|
186
|
|
|
187 Optional 4th argument MODIFICATION-FUNC is a function to call to
|
|
|
188 adjust the composition when it gets invalid because of a change of
|
|
|
189 text in the composition."
|
|
|
190 (interactive "r")
|
|
|
191 (let ((modified-p (buffer-modified-p))
|
|
|
192 (buffer-read-only nil))
|
|
|
193 (if (or (vectorp components) (listp components))
|
|
|
194 (setq components (encode-composition-components components)))
|
|
|
195 (compose-region-internal start end components modification-func)
|
|
|
196 (set-buffer-modified-p modified-p)))
|
|
|
197
|
|
|
198 ;;;###autoload
|
|
|
199 (defun decompose-region (start end)
|
|
|
200 "UNIMPLEMENTED.
|
|
|
201 Decompose text in the current region.
|
|
|
202
|
|
|
203 When called from a program, expects two arguments,
|
|
|
204 positions (integers or markers) specifying the region."
|
|
|
205 (interactive "r")
|
|
|
206 (let ((modified-p (buffer-modified-p))
|
|
|
207 (buffer-read-only nil))
|
|
|
208 (remove-text-properties start end '(composition nil))
|
|
|
209 (set-buffer-modified-p modified-p)))
|
|
|
210
|
|
|
211 ;;;###autoload
|
|
|
212 (defun compose-string (string &optional start end components modification-func)
|
|
|
213 "UNIMPLEMENTED.
|
|
|
214 Compose characters in string STRING.
|
|
|
215
|
|
|
216 The return value is STRING where `composition' property is put on all
|
|
|
217 the characters in it.
|
|
|
218
|
|
|
219 Optional 2nd and 3rd arguments START and END specify the range of
|
|
|
220 STRING to be composed. They defaults to the beginning and the end of
|
|
|
221 STRING respectively.
|
|
|
222
|
|
|
223 Optional 4th argument COMPONENTS, if non-nil, is a character or a
|
|
|
224 sequence (vector, list, or string) of integers. See the function
|
|
|
225 `compose-region' for more detail.
|
|
|
226
|
|
|
227 Optional 5th argument MODIFICATION-FUNC is a function to call to
|
|
|
228 adjust the composition when it gets invalid because of a change of
|
|
|
229 text in the composition."
|
|
|
230 (if (or (vectorp components) (listp components))
|
|
|
231 (setq components (encode-composition-components components)))
|
|
|
232 (or start (setq start 0))
|
|
|
233 (or end (setq end (length string)))
|
|
|
234 (compose-string-internal string start end components modification-func)
|
|
|
235 string)
|
|
|
236
|
|
|
237 ;;;###autoload
|
|
|
238 (defun decompose-string (string)
|
|
|
239 "UNIMPLEMENTED.
|
|
|
240 Return STRING where `composition' property is removed."
|
|
|
241 (remove-text-properties 0 (length string) '(composition nil) string)
|
|
|
242 string)
|
|
|
243
|
|
|
244 ;;;###autoload
|
|
|
245 (defun compose-chars (&rest args)
|
|
|
246 "UNIMPLEMENTED.
|
|
|
247 Return a string from arguments in which all characters are composed.
|
|
|
248 For relative composition, arguments are characters.
|
|
|
249 For rule-based composition, Mth \(where M is odd) arguments are
|
|
|
250 characters, and Nth \(where N is even) arguments are composition rules.
|
|
|
251 A composition rule is a cons of glyph reference points of the form
|
|
|
252 \(GLOBAL-REF-POINT . NEW-REF-POINT). See the documentation of
|
|
|
253 `reference-point-alist' for more detail."
|
|
|
254 (let (str components)
|
|
|
255 (if (consp (car (cdr args)))
|
|
|
256 ;; Rule-base composition.
|
|
|
257 (let (;(len (length args))
|
|
|
258 (tail (encode-composition-components args 'nocopy)))
|
|
|
259
|
|
|
260 (while tail
|
|
|
261 (setq str (cons (car tail) str))
|
|
|
262 (setq tail (nthcdr 2 tail)))
|
|
|
263 (setq str (concat (nreverse str))
|
|
|
264 components args))
|
|
|
265 ;; Relative composition.
|
|
|
266 (setq str (concat args)))
|
|
|
267 (compose-string-internal str 0 (length str) components)))
|
|
|
268
|
|
|
269 ;;;###autoload
|
|
|
270 (defun find-composition (pos &optional limit string detail-p)
|
|
|
271 "UNIMPLEMENTED.
|
|
|
272 Return information about a composition at or nearest to buffer position POS.
|
|
|
273
|
|
|
274 If the character at POS has `composition' property, the value is a list
|
|
|
275 of FROM, TO, and VALID-P.
|
|
|
276
|
|
|
277 FROM and TO specify the range of text that has the same `composition'
|
|
|
278 property, VALID-P is non-nil if and only if this composition is valid.
|
|
|
279
|
|
|
280 If there's no composition at POS, and the optional 2nd argument LIMIT
|
|
|
281 is non-nil, search for a composition toward LIMIT.
|
|
|
282
|
|
|
283 If no composition is found, return nil.
|
|
|
284
|
|
|
285 Optional 3rd argument STRING, if non-nil, is a string to look for a
|
|
|
286 composition in; nil means the current buffer.
|
|
|
287
|
|
|
288 If a valid composition is found and the optional 4th argument DETAIL-P
|
|
|
289 is non-nil, the return value is a list of FROM, TO, COMPONENTS,
|
|
|
290 RELATIVE-P, MOD-FUNC, and WIDTH.
|
|
|
291
|
|
|
292 COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
|
|
|
293
|
|
|
294 RELATIVE-P is t if the composition method is relative, else nil.
|
|
|
295
|
|
|
296 If RELATIVE-P is t, COMPONENTS is a vector of characters to be
|
|
|
297 composed. If RELATIVE-P is nil, COMPONENTS is a vector of characters
|
|
|
298 and composition rules as described in `compose-region'.
|
|
|
299
|
|
|
300 MOD-FUNC is a modification function of the composition.
|
|
|
301
|
|
|
302 WIDTH is a number of columns the composition occupies on the screen."
|
|
|
303 (let ((result (find-composition-internal pos limit string detail-p)))
|
|
|
304 (if (and detail-p result (nth 2 result) (not (nth 3 result)))
|
|
|
305 ;; This is a valid rule-base composition.
|
|
|
306 (decode-composition-components (nth 2 result) 'nocopy))
|
|
|
307 result))
|
|
|
308
|
|
|
309
|
|
|
310 ;;;###autoload
|
|
|
311 (defun compose-chars-after (pos &optional limit object)
|
|
|
312 "UNIMPLEMENTED.
|
|
|
313 Compose characters in current buffer after position POS.
|
|
|
314
|
|
|
315 It looks up the char-table `composition-function-table' (which see) by
|
|
|
316 a character after POS. If non-nil value is found, the format of the
|
|
|
317 value should be an alist of PATTERNs vs FUNCs, where PATTERNs are
|
|
|
318 regular expressions and FUNCs are functions. If the text after POS
|
|
|
319 matches one of PATTERNs, call the corresponding FUNC with three
|
|
|
320 arguments POS, TO, and PATTERN, where TO is the end position of text
|
|
|
321 matching PATTERN, and return what FUNC returns. Otherwise, return
|
|
|
322 nil.
|
|
|
323
|
|
|
324 FUNC is responsible for composing the text properly. The return value
|
|
|
325 is:
|
|
|
326 nil -- if no characters were composed.
|
|
|
327 CHARS (integer) -- if CHARS characters were composed.
|
|
|
328
|
|
|
329 Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
|
|
|
330
|
|
|
331 Optional 3rd arg OBJECT, if non-nil, is a string that contains the
|
|
|
332 text to compose. In that case, POS and LIMIT index to the string.
|
|
|
333
|
|
|
334 This function is the default value of `compose-chars-after-function'."
|
|
|
335 (let ((tail (get-char-table (char-after pos) composition-function-table))
|
|
|
336 pattern func result)
|
|
|
337 (when tail
|
|
|
338 (save-match-data
|
|
|
339 (save-excursion
|
|
|
340 (while (and tail (not func))
|
|
|
341 (setq pattern (car (car tail))
|
|
|
342 func (cdr (car tail)))
|
|
|
343 (goto-char pos)
|
|
|
344 (if (if limit
|
|
|
345 (and (re-search-forward pattern limit t)
|
|
|
346 (= (match-beginning 0) pos))
|
|
|
347 (looking-at pattern))
|
|
|
348 (setq result (funcall func pos (match-end 0) pattern nil))
|
|
|
349 (setq func nil tail (cdr tail)))))))
|
|
|
350 result))
|
|
|
351
|
|
|
352 ;;;###autoload
|
|
|
353 (defun compose-last-chars (args)
|
|
|
354 "UNIMPLEMENTED.
|
|
|
355 Compose last characters.
|
|
|
356 The argument is a parameterized event of the form
|
|
|
357 \(compose-last-chars N COMPONENTS),
|
|
|
358 where N is the number of characters before point to compose,
|
|
|
359 COMPONENTS, if non-nil, is the same as the argument to `compose-region'
|
|
|
360 \(which see). If it is nil, `compose-chars-after' is called,
|
|
|
361 and that function find a proper rule to compose the target characters.
|
|
|
362 This function is intended to be used from input methods.
|
|
|
363 The global keymap binds special event `compose-last-chars' to this
|
|
|
364 function. Input method may generate an event (compose-last-chars N COMPONENTS)
|
|
|
365 after a sequence character events."
|
|
|
366 (interactive "e")
|
|
|
367 (let ((chars (nth 1 args)))
|
|
|
368 (if (and (numberp chars)
|
|
|
369 (>= (- (point) (point-min)) chars))
|
|
|
370 (if (nth 2 args)
|
|
|
371 (compose-region (- (point) chars) (point) (nth 2 args))
|
|
|
372 (compose-chars-after (- (point) chars) (point))))))
|
|
|
373
|
|
|
374 ;;;###autoload(global-set-key [compose-last-chars] 'compose-last-chars)
|
|
|
375
|
|
|
376
|
|
|
377 ;;; The following codes are only for backward compatibility with Emacs
|
|
|
378 ;;; 20.4 and the earlier.
|
|
|
379
|
|
|
380 ;;;###autoload
|
|
|
381 (defun decompose-composite-char (char &optional type with-composition-rule)
|
|
|
382 "UNIMPLEMENTED.
|
|
|
383 Convert CHAR to string.
|
|
|
384 This is only for backward compatibility with Emacs 20.4 and the earlier.
|
|
|
385
|
|
|
386 If optional 2nd arg TYPE is non-nil, it is `string', `list', or
|
|
|
387 `vector'. In this case, CHAR is converted string, list of CHAR, or
|
|
|
388 vector of CHAR respectively."
|
|
|
389 (cond ((or (null type) (eq type 'string)) (char-to-string char))
|
|
|
390 ((eq type 'list) (list char))
|
|
|
391 (t (vector char))))
|
|
|
392
|
|
|
393 (make-obsolete 'decompose-composite-char 'char-to-string
|
|
|
394 ;;"21.1"
|
|
|
395 )
|
|
|
396
|
|
|
397
|
|
|
398 ;;; mule-composite.el ends here
|
