Mercurial > hg > xemacs-beta

comparison lisp/mule/mule-composite.el @ 778:2923009caf47

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2002-03-16 10:38:59 by ben] cm.c, file-coding.c: fix warnings. .cvsignore: Those pesky *.tmp files. mule\arabic.el, mule\canna-leim.el, mule\china-util.el, mule\chinese.el, mule\cyril-util.el, mule\cyrillic.el, mule\devan-util.el, mule\devanagari.el, mule\english.el, mule\ethio-util.el, mule\ethiopic.el, mule\european.el, mule\greek.el, mule\hebrew.el, mule\indian.el, mule\japan-util.el, mule\japanese.el, mule\korea-util.el, mule\korean.el, mule\lao-util.el, mule\lao.el, mule\misc-lang.el, mule\mule-charset.el, mule\mule-cmds.el, mule\thai-util.el, mule\thai.el, mule\tibet-util.el, mule\tibetan.el, mule\viet-util.el, mule\vietnamese.el, unicode.el: Fix lots of warnings. Sync up some files to FSF 21.1. Copy over all charset definitions from FSF 21.1, convert them to our format, and stick them in the relevant files. Eventually we will actually be able to dump these files (though they may not quite work). autoload.el: Support defun*, defmacro*. mule/mule-composite.el, mule/mule-composite-stub.el: New file, stubs for nonexistent composition funs/vars. mule/viet-chars.el, dumped-lisp.el: Account for these changes. font.el, mouse.el, msw-font-menu.el, printer.el, startup.el: fix warnings.
author ben
date Sat, 16 Mar 2002 10:39:19 +0000
parents
children 308d34e9f07d
comparison
equal deleted inserted replaced
777:e65d9cf16707 778:2923009caf47
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