Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
What's new
10
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Open sidebar
emacs
emacs
Commits
c674f351
Commit
c674f351
authored
Dec 15, 1999
by
Kenichi Handa
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
New file.
parent
b4192550
Changes
1
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
387 additions
and
0 deletions
+387
-0
lisp/composite.el
lisp/composite.el
+387
-0
No files found.
lisp/composite.el
0 → 100644
View file @
c674f351
;;; composite.el --- Support character composition.
;; Copyright (C) 1999 Electrotechnical Laboratory, JAPAN.
;; Licensed to the Free Software Foundation.
;; Keywords: mule, multilingual, character composition
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Code:
;;;###autoload
(
defconst
reference-point-alist
'
((
tl
.
0
)
(
tc
.
1
)
(
tr
.
2
)
(
Bl
.
3
)
(
Bc
.
4
)
(
Br
.
5
)
(
bl
.
6
)
(
bc
.
7
)
(
br
.
8
)
(
cl
.
9
)
(
cc
.
10
)
(
cr
.
11
)
(
top-left
.
0
)
(
top-center
.
1
)
(
top-right
.
2
)
(
base-left
.
3
)
(
base-center
.
4
)
(
base-right
.
5
)
(
bottom-left
.
6
)
(
bottom-center
.
7
)
(
bottom-right
.
8
)
(
center-left
.
9
)
(
center-center
.
10
)
(
center-right
.
11
)
;; For backward compatibility...
(
ml
.
3
)
(
mc
.
10
)
(
mr
.
5
)
(
mid-left
.
3
)
(
mid-center
.
10
)
(
mid-right
.
5
))
"Alist of symbols vs integer codes of glyph reference points.
A glyph reference point symbol is to be used to specify a composition
rule in COMPONENTS argument to such functions as `compose-region' and
`make-composition'.
Meanings of glyph reference point codes are as follows:
0----1----2 <---- ascent 0:tl or top-left
| | 1:tc or top-center
| | 2:tr or top-right
| | 3:Bl or base-left 9:cl or center-left
9 10 11 <---- center 4:Bc or base-center 10:cc or center-center
| | 5:Br or base-right 11:cr or center-right
--3----4----5-- <-- baseline 6:bl or bottom-left
| | 7:bc or bottom-center
6----7----8 <---- descent 8:br or bottom-right
Glyph reference point symbols are to be used to specify composition
rule of the form \(GLOBAL-REF-POINT . NEW-REF-POINT), where
GLOBAL-REF-POINT is a reference point in the overall glyphs already
composed, and NEW-REF-POINT is a reference point in the new glyph to
be added.
For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and
NEW-REF-POINT is `tl' (top-left), the overall glyph is updated as
follows (the point `*' corresponds to both reference points):
+-------+--+ <--- new ascent
| | |
| global| |
| glyph | |
-- | | |-- <--- baseline \(doesn't change)
+----+--*--+
| | new |
| |glyph|
+----+-----+ <--- new descent
"
)
;; Encode composition rule RULE into an integer value. RULE is a cons
;; of global and new reference point symbols.
;; This must be compatible with C macro COMPOSITION_ENCODE_RULE
;; defined in composite.h.
(
defun
encode-composition-rule
(
rule
)
(
if
(
and
(
integerp
rule
)
(
<
rule
144
))
;; Already encoded.
rule
(
or
(
consp
rule
)
(
error
"Invalid composition rule: %S"
rule
))
(
let
((
gref
(
car
rule
))
(
nref
(
cdr
rule
)))
(
or
(
integerp
gref
)
(
setq
gref
(
cdr
(
assq
gref
reference-point-alist
))))
(
or
(
integerp
nref
)
(
setq
nref
(
cdr
(
assq
nref
reference-point-alist
))))
(
or
(
and
(
>=
gref
0
)
(
<
gref
12
)
(
>=
nref
0
)
(
<
nref
12
))
(
error
"Invalid composition rule: %S"
rule
))
(
+
(
*
gref
12
)
nref
))))
;; Decode encoded composition rule RULE-CODE. The value is a cons of
;; global and new reference point symbols.
;; This must be compatible with C macro COMPOSITION_DECODE_RULE
;; defined in composite.h.
(
defun
decode-composition-rule
(
rule-code
)
(
or
(
and
(
natnump
rule-code
)
(
<
rule-code
144
))
(
error
"Invalid encoded composition rule: %S"
rule-code
))
(
let
((
gref
(
car
(
rassq
(
/
rule-code
12
)
reference-point-alist
)))
(
nref
(
car
(
rassq
(
%
rule-code
12
)
reference-point-alist
))))
(
or
(
and
gref
(
symbolp
gref
)
nref
(
symbolp
nref
))
(
error
"Invalid composition rule code: %S"
rule-code
))
(
cons
gref
nref
)))
;; Encode composition rules in composition components COMPONENTS. The
;; value is a copy of COMPONENTS, where composition rules (cons of
;; global and new glyph reference point symbols) are replaced with
;; encoded composition rules. Optional 2nd argument NOCOPY non-nil
;; means don't make a copy but modify COMPONENTS directly.
(
defun
encode-composition-components
(
components
&optional
nocopy
)
(
or
nocopy
(
setq
components
(
copy-sequence
components
)))
(
if
(
vectorp
components
)
(
let
((
len
(
length
components
))
(
i
1
))
(
while
(
<
i
len
)
(
aset
components
i
(
encode-composition-rule
(
aref
components
i
)))
(
setq
i
(
+
i
2
))))
(
let
((
tail
(
cdr
components
)))
(
while
tail
(
setcar
tail
(
encode-composition-rule
(
car
tail
)))
(
setq
tail
(
nthcdr
2
tail
)))))
components
)
;; Decode composition rule codes in composition components COMPONENTS.
;; The value is a copy of COMPONENTS, where composition rule codes are
;; replaced with composition rules (cons of global and new glyph
;; reference point symbols). Optional 2nd argument NOCOPY non-nil
;; means don't make a copy but modify COMPONENTS directly.
;; It is assumed that COMPONENTS is a vector and is for rule-base
;; composition, thus (2N+1)th elements are rule codes.
(
defun
decode-composition-components
(
components
&optional
nocopy
)
(
or
nocopy
(
setq
components
(
copy-sequence
components
)))
(
let
((
len
(
length
components
))
(
i
1
))
(
while
(
<
i
len
)
(
aset
components
i
(
decode-composition-rule
(
aref
components
i
)))
(
setq
i
(
+
i
2
))))
components
)
;;;###autoload
(
defun
compose-region
(
start
end
&optional
components
modification-func
)
"Compose characters in the current region.
When called from a program, expects these four arguments.
First two arguments START and END are positions (integers or markers)
specifying the region.
Optional 3rd argument COMPONENTS, if non-nil, is a character or a
sequence (vector, list, or string) of integers.
If it is a character, it is an alternate character to display instead
of the text in the region.
If it is a string, the elements are alternate characters.
If it is a vector or list, it is a sequence of alternate characters and
composition rules, where (2N)th elements are characters and (2N+1)th
elements are composition rules to specify how to compose (2N+2)th
elements with previously composed N glyphs.
A composition rule is a cons of global and new glyph reference point
symbols. See the documentation of `reference-point-alist' for more
detail.
Optional 4th argument MODIFICATION-FUNC is a function to call to
adjust the composition when it gets invalid because of a change of
text in the composition."
(
interactive
"r"
)
(
let
((
modified-p
(
buffer-modified-p
))
(
buffer-read-only
nil
))
(
if
(
or
(
vectorp
components
)
(
listp
components
))
(
setq
components
(
encode-composition-components
components
)))
(
compose-region-internal
start
end
components
modification-func
)
(
set-buffer-modified-p
modified-p
)))
;;;###autoload
(
defun
decompose-region
(
start
end
)
"Decompose text in the current region.
When called from a program, expects two arguments,
positions (integers or markers) specifying the region."
(
interactive
"r"
)
(
let
((
modified-p
(
buffer-modified-p
))
(
buffer-read-only
nil
))
(
remove-text-properties
start
end
'
(
composition
nil
))
(
set-buffer-modified-p
modified-p
)))
;;;###autoload
(
defun
compose-string
(
string
&optional
start
end
components
modification-func
)
"Compose characters in string STRING.
The return value is STRING where `composition' property is put on all
the characters in it.
Optional 2nd and 3rd arguments START and END specify the range of
STRING to be composed. They defaults to the beginning and the end of
STRING respectively.
Optional 4th argument COMPONENTS, if non-nil, is a character or a
sequence (vector, list, or string) of integers. See the function
`compose-region' for more detail.
Optional 5th argument MODIFICATION-FUNC is a function to call to
adjust the composition when it gets invalid because of a change of
text in the composition."
(
if
(
or
(
vectorp
components
)
(
listp
components
))
(
setq
components
(
encode-composition-components
components
)))
(
or
start
(
setq
start
0
))
(
or
end
(
setq
end
(
length
string
)))
(
compose-string-internal
string
start
end
components
modification-func
)
string
)
;;;###autoload
(
defun
decompose-string
(
string
)
"Return STRING where `composition' property is removed."
(
remove-text-properties
0
(
length
string
)
'
(
composition
nil
)
string
)
string
)
;;;###autoload
(
defun
compose-chars
(
&rest
args
)
"Return a string from arguments in which all characters are composed.
For relative composition, arguments are characters.
For rule-based composition, Mth \(where M is odd) arguments are
characters, and Nth \(where N is even) arguments are composition rules.
A composition rule is a cons of glyph reference points of the form
\(GLOBAL-REF-POINT . NEW-REF-POINT). See the documentation of
`reference-point-alist' for more detail."
(
let
(
str
components
)
(
if
(
consp
(
car
(
cdr
args
)))
;; Rule-base composition.
(
let
((
len
(
length
args
))
(
tail
(
encode-composition-components
args
'nocopy
)))
(
while
tail
(
setq
str
(
cons
(
car
tail
)
str
))
(
setq
tail
(
nthcdr
2
tail
)))
(
setq
str
(
concat
(
nreverse
str
))
components
args
))
;; Relative composition.
(
setq
str
(
concat
args
)))
(
compose-string-internal
str
0
(
length
str
)
components
)))
;;;###autoload
(
defun
find-composition
(
pos
&optional
limit
string
detail-p
)
"Return information about a composition at or nearest to buffer position POS.
If the character at POS has `composition' property, the value is a list
of FROM, TO, and VALID-P.
FROM and TO specify the range of text that has the same `composition'
property, VALID-P is non-nil if and only if this composition is valid.
If there's no composition at POS, and the optional 2nd argument LIMIT
is non-nil, search for a composition toward LIMIT.
If no composition is found, return nil.
Optional 3rd argument STRING, if non-nil, is a string to look for a
composition in; nil means the current buffer.
If a valid composition is found and the optional 4th argument DETAIL-P
is non-nil, the return value is a list of FROM, TO, COMPONENTS,
RELATIVE-P, MOD-FUNC, and WIDTH.
COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
RELATIVE-P is t if the composition method is relative, else nil.
If RELATIVE-P is t, COMPONENTS is a vector of characters to be
composed. If RELATIVE-P is nil, COMPONENTS is a vector of characters
and composition rules as described in `compose-region'.
MOD-FUNC is a modification function of the composition.
WIDTH is a number of columns the composition occupies on the screen."
(
let
((
result
(
find-composition-internal
pos
limit
string
detail-p
)))
(
if
(
and
detail-p
result
(
nth
2
result
)
(
not
(
nth
3
result
)))
;; This is a valid rule-base composition.
(
decode-composition-components
(
nth
2
result
)
'nocopy
))
result
))
;; A char-table of functions to call for compositions.
;;;###autoload(put 'composition-function-table 'char-table-extra-slots 0)
;;;###autoload
(
defvar
composition-function-table
(
make-char-table
'composition-function-table
)
"Char table of patterns and functions to make a composition.
Each element is nil or an alist of PATTERNs vs FUNCs, where PATTERNs
are regular expressions and FUNCs are functions. FUNC is responsible
for composing text matching the corresponding PATTERN. FUNC is called
with three arguments FROM, TO, and PATTERN. See the function
`compose-chars-after' for more detail.
This table is looked up by the first character of a composition when
the composition gets invalid after a change in a buffer."
)
;;;###autoload
(
defun
compose-chars-after
(
pos
&optional
limit
)
"Compose characters in current buffer after position POS.
It looks up the char-table `composition-function-table' (which see) by
a character after POS. If non-nil value is found, the format of the
value should be an alist of PATTERNs vs FUNCs, where PATTERNs are
regular expressions and FUNCs are functions. If the text after POS
matches one of PATTERNs, call the corresponding FUNC with three
arguments POS, TO, and PATTERN, where TO is the end position of text
matching PATTERN, and return what FUNC returns. Otherwise, return
nil.
FUNC is responsible for composing the text properly. The return value
is:
nil -- if no characters were composed.
CHARS (integer) -- if CHARS characters were composed.
Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
This function is the default value of `compose-chars-after-function'."
(
let
((
tail
(
aref
composition-function-table
(
char-after
pos
)))
pattern
func
result
)
(
when
tail
(
save-excursion
(
while
(
and
tail
(
not
func
))
(
setq
pattern
(
car
(
car
tail
))
func
(
cdr
(
car
tail
)))
(
goto-char
pos
)
(
if
(
if
limit
(
and
(
re-search-forward
pattern
limit
t
)
(
=
(
match-beginning
0
)
pos
))
(
looking-at
pattern
))
(
setq
result
(
funcall
func
pos
(
match-end
0
)
pattern
nil
))
(
setq
func
nil
tail
(
cdr
tail
))))))
result
))
;;;###autoload
(
defun
compose-last-chars
(
args
)
"Compose last characters.
The argument is a parameterized event of the form (compose-last-chars N),
where N is the number of characters before point to compose.
This function is intended to be used from input methods.
The global keymap binds special event `compose-last-chars' to this
function. Input method may generate an event (compose-last-chars N)
after a sequence character events."
(
interactive
"e"
)
(
let
((
chars
(
nth
1
args
)))
(
if
(
and
(
numberp
chars
)
(
>=
(
-
(
point
)
(
point-min
))
chars
))
(
compose-chars-after
(
-
(
point
)
chars
)
(
point
)))))
;;;###autoload(global-set-key [compose-last-chars] 'compose-last-chars)
;;; The following codes are only for backward compatibility with Emacs
;;; 20.4 and the earlier.
;;;###autoload
(
defun
decompose-composite-char
(
char
&optional
type
with-composition-rule
)
"Convert CHAR to string.
This is only for backward compatibility with Emacs 20.4 and the earlier.
If optional 2nd arg TYPE is non-nil, it is `string', `list', or
`vector'. In this case, CHAR is converted string, list of CHAR, or
vector of CHAR respectively."
(
cond
((
or
(
null
type
)
(
eq
type
'string
))
(
char-to-string
char
))
((
eq
type
'list
)
(
list
char
))
(
t
(
vector
char
))))
;;; composite.el ends here
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment