|
0
|
1 ;; Compose-key processing in emacs.
|
|
48
|
2 ;; Copyright (C) 1992, 1993, 1997 Free Software Foundation, Inc.
|
|
0
|
3
|
|
|
4 ;; This file is part of XEmacs.
|
|
|
5
|
|
|
6 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 ;; under the terms of the GNU General Public License as published by
|
|
|
8 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
9 ;; any later version.
|
|
|
10
|
|
|
11 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
12 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
14 ;; General Public License for more details.
|
|
|
15
|
|
|
16 ;; You should have received a copy of the GNU General Public License
|
|
|
17 ;; along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
18 ;; Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
19
|
|
|
20 ;;; created by jwz, 14-jun-92.
|
|
48
|
21 ;;; changed by Heiko Muenkel, 11-jun-97: Fixed the degree bug.
|
|
|
22 ;;; changed by Jan Vroonhof, July 1997: Use function-key-map instead
|
|
|
23 ;;; of global map.
|
|
|
24 ;;; Preliminary support for
|
|
|
25 ;;; XFree86 deadkeys
|
|
|
26 ;;; , August 1997 allow : for diaresis like xlib
|
|
0
|
27
|
|
|
28 ;;; This file implements DEC-, OpenWindows-, and HP-compatible "Compose"
|
|
|
29 ;;; processing for XEmacs.
|
|
|
30 ;;;
|
|
|
31 ;;; If you are running a version of X which already does compose processing,
|
|
|
32 ;;; then you don't need this file. But the MIT R4 and R5 distributions don't
|
|
|
33 ;;; do compose processing, so you may want to fake it by using this code.
|
|
|
34 ;;;
|
|
|
35 ;;; The basic idea is that there are several ways to generate keysyms which
|
|
|
36 ;;; do not have keys devoted to them on your keyboard.
|
|
|
37 ;;;
|
|
|
38 ;;; The first method is by using "dead" keys. A dead key is a key which,
|
|
|
39 ;;; when typed, does not insert a character. Instead it modifies the
|
|
|
40 ;;; following character typed. So if you typed "dead-tilde" followed by "A",
|
|
|
41 ;;; then "A-tilde" would be inserted. Of course, this requires you to modify
|
|
|
42 ;;; your keyboard to include a "dead-tilde" key on it somewhere.
|
|
|
43 ;;;
|
|
|
44 ;;; The second method is by using a "Compose" key. With a Compose key, you
|
|
|
45 ;;; would type "Compose" then "tilde" then "A" to insert "A-tilde".
|
|
|
46 ;;;
|
|
|
47 ;;; There are a small number of dead keys: acute, grave, cedilla, diaeresis,
|
|
|
48 ;;; circumflex, tilde, and ring. There are a larger number of accented and
|
|
|
49 ;;; other characters accessible via the Compose key, so both are useful.
|
|
|
50 ;;;
|
|
|
51 ;;; To use this code, you will need to have a Compose key on your keyboard.
|
|
|
52 ;;; The default configuration of most X keyboards doesn't contain one. You
|
|
|
53 ;;; can, for example, turn the right "Meta" key into a "Compose" key with
|
|
|
54 ;;; this command:
|
|
|
55 ;;;
|
|
|
56 ;;; xmodmap -e "remove mod1 = Meta_R" -e "keysym Meta_R = Multi_key"
|
|
|
57 ;;;
|
|
14
|
58 ;;; Multi-key is the name that X (and emacs) know the "Compose" key by.
|
|
0
|
59 ;;; The "remove..." command is necessary because the "Compose" key must not
|
|
|
60 ;;; have any modifier bits associated with it. This exact command may not
|
|
|
61 ;;; work, depending on what system and keyboard you are using. If it
|
|
|
62 ;;; doesn't, you'll have to read the man page for xmodmap. You might want
|
|
|
63 ;;; to get the "xkeycaps" program from the host export.lcs.mit.edu in the
|
|
|
64 ;;; file contrib/xkeycaps.tar.Z, which is a graphical front end to xmodmap
|
|
|
65 ;;; that hides xmodmap's arcane syntax from you.
|
|
|
66 ;;;
|
|
|
67 ;;; If for some reason you don't want to have a dedicated compose key on your
|
|
|
68 ;;; keyboard, you can use some other key as the prefix. For example, to make
|
|
|
69 ;;; "Meta-Shift-C" act as a compose key (so that "M-C , c" would insert the
|
|
|
70 ;;; character "ccedilla") you could do
|
|
|
71 ;;;
|
|
|
72 ;;; (global-set-key "\M-C" compose-map)
|
|
|
73 ;;;
|
|
|
74 ;;; I believe the bindings encoded in this file are the same as those used
|
|
|
75 ;;; by OpenWindows versions 2 and 3, and DEC VT320 terminals. Please let me
|
|
|
76 ;;; know if you think otherwise.
|
|
|
77 ;;;
|
|
|
78 ;;; Much thanks to Justin Bur <justin@crim.ca> for helping me understand how
|
|
|
79 ;;; this stuff is supposed to work.
|
|
|
80 ;;;
|
|
|
81 ;;; You also might want to consider getting Justin's patch for the MIT Xlib
|
|
|
82 ;;; that implements compose processing in the library. This will enable
|
|
|
83 ;;; compose processing in applications other than emacs as well. You can
|
|
|
84 ;;; get it from export.lcs.mit.edu in contrib/compose.tar.Z.
|
|
|
85
|
|
|
86 ;;; This code has one feature that a more "builtin" Compose mechanism could
|
|
|
87 ;;; not have: at any point you can type C-h to get a list of the possible
|
|
|
88 ;;; completions of what you have typed so far.
|
|
|
89
|
|
|
90 (require 'x-iso8859-1)
|
|
|
91
|
|
|
92 (defvar compose-map (make-keymap))
|
|
|
93 (defvar compose-acute-map (make-sparse-keymap))
|
|
|
94 (defvar compose-grave-map (make-sparse-keymap))
|
|
|
95 (defvar compose-cedilla-map (make-sparse-keymap))
|
|
|
96 (defvar compose-diaeresis-map (make-sparse-keymap))
|
|
|
97 (defvar compose-circumflex-map (make-sparse-keymap))
|
|
|
98 (defvar compose-tilde-map (make-sparse-keymap))
|
|
|
99 (defvar compose-ring-map (make-sparse-keymap))
|
|
|
100
|
|
|
101 ;;; The command `compose-key' exists so that this file may be autoloaded.
|
|
|
102 ;;;this doesn't work yet###autoload
|
|
48
|
103 ;; (define-function 'compose-key compose-map)
|
|
0
|
104
|
|
|
105 ;; The "Compose" key:
|
|
|
106 ;; (keysym is lower case because we downcase everything in the Symbol font...)
|
|
|
107 ;;
|
|
|
108 ;;;this doesn't work yet###autoload
|
|
48
|
109 ;; Ditched JV, (define-key function-key-map [multi-key] 'compose-key)
|
|
|
110 (define-key function-key-map [multi-key] compose-map)
|
|
|
111
|
|
|
112 ;; The following is necessary, because one can't rebind [degree]
|
|
|
113 ;; and use it to insert the degree sign!
|
|
|
114 (defun compose-insert-degree ()
|
|
|
115 "Inserts a degree sign."
|
|
|
116 (interactive)
|
|
|
117 (insert ?\260))
|
|
0
|
118
|
|
|
119 ;; The "Dead" keys:
|
|
|
120 ;;
|
|
48
|
121 (define-key function-key-map [acute] compose-acute-map)
|
|
|
122 (define-key function-key-map [cedilla] compose-cedilla-map)
|
|
|
123 (define-key function-key-map [diaeresis] compose-diaeresis-map)
|
|
|
124 (define-key function-key-map [degree] compose-ring-map)
|
|
0
|
125
|
|
|
126 ;; The dead keys as seen by the "Compose" map:
|
|
|
127 ;;
|
|
|
128 (define-key compose-map [acute] compose-acute-map)
|
|
|
129 (define-key compose-map [cedilla] compose-cedilla-map)
|
|
|
130 (define-key compose-map [diaeresis] compose-diaeresis-map)
|
|
|
131 (define-key compose-map [degree] compose-ring-map)
|
|
|
132
|
|
|
133 (define-key compose-map "'" compose-acute-map)
|
|
|
134 (define-key compose-map "`" compose-grave-map)
|
|
|
135 (define-key compose-map "," compose-cedilla-map)
|
|
|
136 (define-key compose-map "\"" compose-diaeresis-map)
|
|
48
|
137 (define-key compose-map ":" compose-diaeresis-map)
|
|
0
|
138 (define-key compose-map "^" compose-circumflex-map)
|
|
|
139 (define-key compose-map "~" compose-tilde-map)
|
|
|
140 (define-key compose-map "*" compose-ring-map)
|
|
|
141
|
|
|
142
|
|
|
143 ;;; The dead keys might really be called just about anything, depending
|
|
|
144 ;;; on the vendor. MIT thinks that the prefixes are "SunFA_", "D", and
|
|
|
145 ;;; "hpmute_" for Sun, DEC, and HP respectively. However, OpenWindows 3
|
|
|
146 ;;; thinks that the prefixes are "SunXK_FA_", "DXK_", and "hpXK_mute_".
|
|
|
147 ;;; And HP (who don't mention Sun and DEC at all) use "XK_mute_".
|
|
|
148 ;;; Go figure.
|
|
|
149
|
|
|
150 ;;; Presumably if someone is running OpenWindows, they won't be using
|
|
|
151 ;;; the DEC or HP keysyms, but if they are defined then that is possible,
|
|
|
152 ;;; so in that case we accept them all.
|
|
|
153
|
|
|
154 ;;; If things seem not to be working, you might want to check your
|
|
|
155 ;;; /usr/lib/X11/XKeysymDB file to see if your vendor has an equally
|
|
|
156 ;;; mixed up view of what these keys should be called.
|
|
|
157
|
|
|
158 ;; Sun according to MIT:
|
|
|
159 ;;
|
|
|
160 (cond ((x-valid-keysym-name-p "SunFA_Acute")
|
|
48
|
161 (define-key function-key-map [SunFA_Acute]
|
|
|
162 compose-acute-map)
|
|
0
|
163 (define-key compose-map [SunFA_Acute] compose-acute-map)
|
|
48
|
164 (define-key function-key-map [SunFA_Grave]
|
|
|
165 compose-grave-map)
|
|
0
|
166 (define-key compose-map [SunFA_Grave] compose-grave-map)
|
|
48
|
167 (define-key function-key-map [SunFA_Cedilla]
|
|
|
168 compose-cedilla-map)
|
|
0
|
169 (define-key compose-map [SunFA_Cedilla] compose-cedilla-map)
|
|
48
|
170 (define-key function-key-map [SunFA_Diaeresis] compose-diaeresis-map)
|
|
0
|
171 (define-key compose-map [SunFA_Diaeresis] compose-diaeresis-map)
|
|
48
|
172 (define-key function-key-map [SunFA_Circum]
|
|
|
173 compose-circumflex-map)
|
|
0
|
174 (define-key compose-map [SunFA_Circum] compose-circumflex-map)
|
|
48
|
175 (define-key function-key-map [SunFA_Tilde]
|
|
|
176 compose-tilde-map)
|
|
0
|
177 (define-key compose-map [SunFA_Tilde] compose-tilde-map)
|
|
|
178 ))
|
|
|
179
|
|
|
180 ;; Sun according to OpenWindows 2:
|
|
|
181 ;;
|
|
|
182 (cond ((x-valid-keysym-name-p "Dead_Grave")
|
|
48
|
183 (define-key function-key-map [Dead_Grave]
|
|
|
184 compose-grave-map)
|
|
0
|
185 (define-key compose-map [Dead_Grave] compose-grave-map)
|
|
48
|
186 (define-key function-key-map [Dead_Circum]
|
|
|
187 compose-circumflex-map)
|
|
0
|
188 (define-key compose-map [Dead_Circum] compose-circumflex-map)
|
|
48
|
189 (define-key function-key-map [Dead_Tilde]
|
|
|
190 compose-tilde-map)
|
|
0
|
191 (define-key compose-map [Dead_Tilde] compose-tilde-map)
|
|
|
192 ))
|
|
|
193
|
|
|
194 ;; Sun according to OpenWindows 3:
|
|
|
195 ;;
|
|
|
196 (cond ((x-valid-keysym-name-p "SunXK_FA_Acute")
|
|
48
|
197 (define-key function-key-map [SunXK_FA_Acute]
|
|
|
198 compose-acute-map)
|
|
0
|
199 (define-key compose-map [SunXK_FA_Acute] compose-acute-map)
|
|
48
|
200 (define-key function-key-map [SunXK_FA_Grave]
|
|
|
201 compose-grave-map)
|
|
0
|
202 (define-key compose-map [SunXK_FA_Grave] compose-grave-map)
|
|
48
|
203 (define-key function-key-map [SunXK_FA_Cedilla] compose-cedilla-map)
|
|
0
|
204 (define-key compose-map [SunXK_FA_Cedilla] compose-cedilla-map)
|
|
48
|
205 (define-key function-key-map [SunXK_FA_Diaeresis]
|
|
|
206 compose-diaeresis-map)
|
|
0
|
207 (define-key compose-map [SunXK_FA_Diaeresis] compose-diaeresis-map)
|
|
48
|
208 (define-key function-key-map [SunXK_FA_Circum] compose-circumflex-map)
|
|
0
|
209 (define-key compose-map [SunXK_FA_Circum] compose-circumflex-map)
|
|
48
|
210 (define-key function-key-map [SunXK_FA_Tilde]
|
|
|
211 compose-tilde-map)
|
|
0
|
212 (define-key compose-map [SunXK_FA_Tilde] compose-tilde-map)
|
|
|
213 ))
|
|
|
214
|
|
|
215 ;; DEC according to MIT:
|
|
|
216 ;;
|
|
|
217 (cond ((x-valid-keysym-name-p "Dacute_accent")
|
|
48
|
218 (define-key function-key-map [Dacute_accent]
|
|
|
219 compose-acute-map)
|
|
0
|
220 (define-key compose-map [Dacute_accent] compose-acute-map)
|
|
48
|
221 (define-key function-key-map [Dgrave_accent]
|
|
|
222 compose-grave-map)
|
|
0
|
223 (define-key compose-map [Dgrave_accent] compose-grave-map)
|
|
48
|
224 (define-key function-key-map [Dcedilla_accent] compose-cedilla-map)
|
|
0
|
225 (define-key compose-map [Dcedilla_accent] compose-cedilla-map)
|
|
48
|
226 (define-key function-key-map [Dcircumflex_accent]
|
|
|
227 compose-circumflex-map)
|
|
0
|
228 (define-key compose-map [Dcircumflex_accent] compose-circumflex-map)
|
|
48
|
229 (define-key function-key-map [Dtilde]
|
|
|
230 compose-tilde-map)
|
|
0
|
231 (define-key compose-map [Dtilde] compose-tilde-map)
|
|
48
|
232 (define-key function-key-map [Dring_accent]
|
|
|
233 compose-ring-map)
|
|
0
|
234 (define-key compose-map [Dring_accent] compose-ring-map)
|
|
|
235 ))
|
|
|
236
|
|
|
237 ;; DEC according to OpenWindows 3:
|
|
|
238 ;;
|
|
|
239 (cond ((x-valid-keysym-name-p "DXK_acute_accent")
|
|
48
|
240 (define-key function-key-map [DXK_acute_accent] compose-acute-map)
|
|
0
|
241 (define-key compose-map [DXK_acute_accent] compose-acute-map)
|
|
48
|
242 (define-key function-key-map [DXK_grave_accent] compose-grave-map)
|
|
0
|
243 (define-key compose-map [DXK_grave_accent] compose-grave-map)
|
|
48
|
244 (define-key function-key-map [DXK_cedilla_accent]
|
|
|
245 compose-cedilla-map)
|
|
0
|
246 (define-key compose-map [DXK_cedilla_accent] compose-cedilla-map)
|
|
48
|
247 (define-key function-key-map [DXK_circumflex_accent]
|
|
|
248 compose-circumflex-map)
|
|
0
|
249 (define-key compose-map [DXK_circumflex_accent] compose-circumflex-map)
|
|
48
|
250 (define-key function-key-map [DXK_tilde]
|
|
|
251 compose-tilde-map)
|
|
0
|
252 (define-key compose-map [DXK_tilde] compose-tilde-map)
|
|
48
|
253 (define-key function-key-map [DXK_ring_accent] compose-ring-map)
|
|
0
|
254 (define-key compose-map [DXK_ring_accent] compose-ring-map)
|
|
|
255 ))
|
|
|
256
|
|
|
257 ;; HP according to MIT:
|
|
|
258 ;;
|
|
|
259 (cond ((x-valid-keysym-name-p "hpmute_acute")
|
|
48
|
260 (define-key function-key-map [hpmute_acute]
|
|
|
261 compose-acute-map)
|
|
0
|
262 (define-key compose-map [hpmute_acute] compose-acute-map)
|
|
48
|
263 (define-key function-key-map [hpmute_grave]
|
|
|
264 compose-grave-map)
|
|
0
|
265 (define-key compose-map [hpmute_grave] compose-grave-map)
|
|
48
|
266 (define-key function-key-map [hpmute_diaeresis] compose-diaeresis-map)
|
|
0
|
267 (define-key compose-map [hpmute_diaeresis] compose-diaeresis-map)
|
|
48
|
268 (define-key function-key-map [hpmute_asciicircum]
|
|
|
269 compose-circumflex-map)
|
|
0
|
270 (define-key compose-map [hpmute_asciicircum] compose-circumflex-map)
|
|
48
|
271 (define-key function-key-map [hpmute_asciitilde]
|
|
|
272 compose-tilde-map)
|
|
0
|
273 (define-key compose-map [hpmute_asciitilde] compose-tilde-map)
|
|
|
274 ))
|
|
|
275
|
|
|
276 ;; HP according to OpenWindows 3:
|
|
|
277 ;;
|
|
|
278 (cond ((x-valid-keysym-name-p "hpXK_mute_acute")
|
|
48
|
279 (define-key function-key-map [hpXK_mute_acute] compose-acute-map)
|
|
0
|
280 (define-key compose-map [hpXK_mute_acute] compose-acute-map)
|
|
48
|
281 (define-key function-key-map [hpXK_mute_grave] compose-grave-map)
|
|
0
|
282 (define-key compose-map [hpXK_mute_grave] compose-grave-map)
|
|
48
|
283 (define-key function-key-map [hpXK_mute_diaeresis]
|
|
|
284 compose-diaeresis-map)
|
|
0
|
285 (define-key compose-map [hpXK_mute_diaeresis] compose-diaeresis-map)
|
|
48
|
286 (define-key function-key-map [hpXK_mute_asciicircum]
|
|
|
287 compose-circumflex-map)
|
|
0
|
288 (define-key compose-map [hpXK_mute_asciicircum] compose-circumflex-map)
|
|
48
|
289 (define-key function-key-map [hpXK_mute_asciitilde]
|
|
|
290 compose-tilde-map)
|
|
0
|
291 (define-key compose-map [hpXK_mute_asciitilde] compose-tilde-map)
|
|
|
292 ))
|
|
|
293
|
|
|
294 ;; HP according to HP-UX 8.0:
|
|
|
295 ;;
|
|
|
296 (cond ((x-valid-keysym-name-p "XK_mute_acute")
|
|
48
|
297 (define-key function-key-map [XK_mute_acute]
|
|
|
298 compose-acute-map)
|
|
0
|
299 (define-key compose-map [XK_mute_acute] compose-acute-map)
|
|
48
|
300 (define-key function-key-map [XK_mute_grave]
|
|
|
301 compose-grave-map)
|
|
0
|
302 (define-key compose-map [XK_mute_grave] compose-grave-map)
|
|
48
|
303 (define-key function-key-map [XK_mute_diaeresis]
|
|
|
304 compose-diaeresis-map)
|
|
0
|
305 (define-key compose-map [XK_mute_diaeresis] compose-diaeresis-map)
|
|
48
|
306 (define-key function-key-map [XK_mute_asciicircum]
|
|
|
307 compose-circumflex-map)
|
|
0
|
308 (define-key compose-map [XK_mute_asciicircum] compose-circumflex-map)
|
|
48
|
309 (define-key function-key-map
|
|
|
310 [XK_mute_asciitilde] compose-tilde-map)
|
|
0
|
311 (define-key compose-map [XK_mute_asciitilde] compose-tilde-map)
|
|
|
312 ))
|
|
48
|
313 ;; Xfree seems to use lower case and a hyphen
|
|
|
314 (cond ((x-valid-keysym-name-p "dead-tilde")
|
|
|
315 (define-key function-key-map [dead-acute]
|
|
|
316 compose-acute-map)
|
|
|
317 (define-key compose-map [dead-acute] compose-acute-map)
|
|
|
318 (define-key function-key-map [dead-grave]
|
|
|
319 compose-grave-map)
|
|
|
320 (define-key compose-map [dead-grave] compose-grave-map)
|
|
|
321 (define-key function-key-map [dead-cedilla] compose-cedilla-map)
|
|
|
322 (define-key compose-map [dead-cedilla] compose-cedilla-map)
|
|
|
323 (define-key function-key-map [dead_diaeresis] compose-diaeresis-map)
|
|
|
324 (define-key compose-map [dead-diaeresis] compose-diaeresis-map)
|
|
|
325 (define-key function-key-map [dead-circum] compose-circumflex-map)
|
|
|
326 (define-key compose-map [dead-circum] compose-circumflex-map)
|
|
|
327 (define-key function-key-map [dead-circumflex] compose-circumflex-map)
|
|
|
328 (define-key compose-map [dead-circumflex] compose-circumflex-map)
|
|
|
329 (define-key function-key-map [dead-tilde]
|
|
|
330 compose-tilde-map)
|
|
|
331 (define-key compose-map [dead-tilde] compose-tilde-map)
|
|
|
332 ))
|
|
|
333 ;; and AIX uses underscore, sigh....
|
|
|
334 (cond ((x-valid-keysym-name-p "dead_tilde")
|
|
|
335 (define-key function-key-map [dead_acute]
|
|
|
336 compose-acute-map)
|
|
|
337 (define-key compose-map [dead_acute] compose-acute-map)
|
|
|
338 (define-key function-key-map [dead_grave]
|
|
|
339 compose-grave-map)
|
|
|
340 (define-key compose-map [dead_grave] compose-grave-map)
|
|
|
341 (define-key function-key-map [dead_cedilla] compose-cedilla-map)
|
|
|
342 (define-key compose-map [dead_cedilla] compose-cedilla-map)
|
|
|
343 (define-key function-key-map [dead_diaeresis] compose-diaeresis-map)
|
|
|
344 (define-key compose-map [dead_diaeresis] compose-diaeresis-map)
|
|
|
345 ; There seems to be several spellings for circumflex....
|
|
|
346 (define-key function-key-map [dead_circum] compose-circumflex-map)
|
|
|
347 (define-key compose-map [dead_circum] compose-circumflex-map)
|
|
|
348 (define-key function-key-map [dead_circumflex] compose-circumflex-map)
|
|
|
349 (define-key compose-map [dead_circumflex] compose-circumflex-map)
|
|
|
350 (define-key function-key-map [dead_tilde]
|
|
|
351 compose-tilde-map)
|
|
|
352 (define-key compose-map [dead_tilde] compose-tilde-map)
|
|
|
353 ))
|
|
|
354
|
|
|
355
|
|
0
|
356
|
|
|
357 ;;; The contents of the "dead key" maps. These are shared by the
|
|
|
358 ;;; compose-map.
|
|
|
359
|
|
|
360 (set-keymap-name compose-acute-map 'compose-acute-map)
|
|
|
361 (define-key compose-acute-map " " "'")
|
|
|
362 (define-key compose-acute-map "'" [acute])
|
|
|
363 (define-key compose-acute-map "A" [Aacute])
|
|
|
364 (define-key compose-acute-map "E" [Eacute])
|
|
|
365 (define-key compose-acute-map "I" [Iacute])
|
|
|
366 (define-key compose-acute-map "O" [Oacute])
|
|
|
367 (define-key compose-acute-map "U" [Uacute])
|
|
|
368 (define-key compose-acute-map "Y" [Yacute])
|
|
|
369 (define-key compose-acute-map "a" [aacute])
|
|
|
370 (define-key compose-acute-map "e" [eacute])
|
|
|
371 (define-key compose-acute-map "i" [iacute])
|
|
|
372 (define-key compose-acute-map "o" [oacute])
|
|
|
373 (define-key compose-acute-map "u" [uacute])
|
|
|
374 (define-key compose-acute-map "y" [yacute])
|
|
|
375
|
|
|
376 (set-keymap-name compose-grave-map 'compose-grave-map)
|
|
48
|
377 (define-key compose-grave-map " " "`")
|
|
|
378 (define-key compose-grave-map "`" [grave])
|
|
0
|
379 (define-key compose-grave-map "A" [Agrave])
|
|
|
380 (define-key compose-grave-map "E" [Egrave])
|
|
|
381 (define-key compose-grave-map "I" [Igrave])
|
|
|
382 (define-key compose-grave-map "O" [Ograve])
|
|
|
383 (define-key compose-grave-map "U" [Ugrave])
|
|
|
384 (define-key compose-grave-map "a" [agrave])
|
|
|
385 (define-key compose-grave-map "e" [egrave])
|
|
|
386 (define-key compose-grave-map "i" [igrave])
|
|
|
387 (define-key compose-grave-map "o" [ograve])
|
|
|
388 (define-key compose-grave-map "u" [ugrave])
|
|
|
389
|
|
|
390 (set-keymap-name compose-cedilla-map 'compose-cedilla-map)
|
|
48
|
391 (define-key compose-cedilla-map " " ",")
|
|
0
|
392 (define-key compose-cedilla-map "," [cedilla])
|
|
|
393 (define-key compose-cedilla-map "C" [Ccedilla])
|
|
|
394 (define-key compose-cedilla-map "c" [ccedilla])
|
|
|
395
|
|
|
396 (set-keymap-name compose-diaeresis-map 'compose-diaeresis-map)
|
|
|
397 (define-key compose-diaeresis-map " " [diaeresis])
|
|
|
398 (define-key compose-diaeresis-map "\"" [diaeresis])
|
|
48
|
399 (define-key compose-diaeresis-map ":" [diaeresis])
|
|
0
|
400 (define-key compose-diaeresis-map "A" [Adiaeresis])
|
|
|
401 (define-key compose-diaeresis-map "E" [Ediaeresis])
|
|
|
402 (define-key compose-diaeresis-map "I" [Idiaeresis])
|
|
|
403 (define-key compose-diaeresis-map "O" [Odiaeresis])
|
|
|
404 (define-key compose-diaeresis-map "U" [Udiaeresis])
|
|
|
405 (define-key compose-diaeresis-map "a" [adiaeresis])
|
|
|
406 (define-key compose-diaeresis-map "e" [ediaeresis])
|
|
|
407 (define-key compose-diaeresis-map "i" [idiaeresis])
|
|
|
408 (define-key compose-diaeresis-map "o" [odiaeresis])
|
|
|
409 (define-key compose-diaeresis-map "u" [udiaeresis])
|
|
|
410 (define-key compose-diaeresis-map "y" [ydiaeresis])
|
|
|
411
|
|
|
412 (set-keymap-name compose-circumflex-map 'compose-circumflex-map)
|
|
|
413 (define-key compose-circumflex-map " " "^")
|
|
|
414 (define-key compose-circumflex-map "/" "|")
|
|
|
415 (define-key compose-circumflex-map "!" [brokenbar])
|
|
|
416 (define-key compose-circumflex-map "-" [macron])
|
|
|
417 (define-key compose-circumflex-map "_" [macron])
|
|
48
|
418 (define-key compose-circumflex-map "0" 'compose-insert-degree)
|
|
0
|
419 (define-key compose-circumflex-map "1" [onesuperior])
|
|
|
420 (define-key compose-circumflex-map "2" [twosuperior])
|
|
|
421 (define-key compose-circumflex-map "3" [threesuperior])
|
|
|
422 (define-key compose-circumflex-map "." [periodcentered])
|
|
|
423 (define-key compose-circumflex-map "A" [Acircumflex])
|
|
|
424 (define-key compose-circumflex-map "E" [Ecircumflex])
|
|
|
425 (define-key compose-circumflex-map "I" [Icircumflex])
|
|
|
426 (define-key compose-circumflex-map "O" [Ocircumflex])
|
|
|
427 (define-key compose-circumflex-map "U" [Ucircumflex])
|
|
|
428 (define-key compose-circumflex-map "a" [acircumflex])
|
|
|
429 (define-key compose-circumflex-map "e" [ecircumflex])
|
|
|
430 (define-key compose-circumflex-map "i" [icircumflex])
|
|
|
431 (define-key compose-circumflex-map "o" [ocircumflex])
|
|
|
432 (define-key compose-circumflex-map "u" [ucircumflex])
|
|
|
433
|
|
|
434 (set-keymap-name compose-tilde-map 'compose-tilde-map)
|
|
|
435 (define-key compose-tilde-map " " "~")
|
|
|
436 (define-key compose-tilde-map "A" [Atilde])
|
|
|
437 (define-key compose-tilde-map "N" [Ntilde])
|
|
|
438 (define-key compose-tilde-map "O" [Otilde])
|
|
|
439 (define-key compose-tilde-map "a" [atilde])
|
|
|
440 (define-key compose-tilde-map "n" [ntilde])
|
|
|
441 (define-key compose-tilde-map "o" [otilde])
|
|
|
442
|
|
|
443 (set-keymap-name compose-ring-map 'compose-ring-map)
|
|
48
|
444 (define-key compose-ring-map " " 'compose-insert-degree)
|
|
0
|
445 (define-key compose-ring-map "A" [Aring])
|
|
|
446 (define-key compose-ring-map "a" [aring])
|
|
|
447
|
|
|
448
|
|
|
449 ;;; The rest of the compose-map. These are the composed characters
|
|
|
450 ;;; that are not accessible via "dead" keys.
|
|
|
451
|
|
|
452 (set-keymap-name compose-map 'compose-map)
|
|
|
453 (define-key compose-map " '" "'")
|
|
|
454 (define-key compose-map " ^" "^")
|
|
|
455 (define-key compose-map " `" "`")
|
|
|
456 (define-key compose-map " ~" "~")
|
|
|
457 (define-key compose-map " " [nobreakspace])
|
|
|
458 (define-key compose-map " \"" [diaeresis])
|
|
48
|
459 (define-key compose-map " :" [diaeresis])
|
|
|
460 (define-key compose-map " *" 'compose-insert-degree)
|
|
0
|
461
|
|
|
462 (define-key compose-map "!!" [exclamdown])
|
|
|
463 (define-key compose-map "!^" [brokenbar])
|
|
|
464 (define-key compose-map "!S" [section])
|
|
|
465 (define-key compose-map "!s" [section])
|
|
|
466 (define-key compose-map "!P" [paragraph])
|
|
|
467 (define-key compose-map "!p" [paragraph])
|
|
|
468
|
|
|
469 (define-key compose-map "((" "[")
|
|
|
470 (define-key compose-map "(-" "{")
|
|
|
471
|
|
|
472 (define-key compose-map "))" "]")
|
|
|
473 (define-key compose-map ")-" "}")
|
|
|
474
|
|
|
475 (define-key compose-map "++" "#")
|
|
|
476 (define-key compose-map "+-" [plusminus])
|
|
|
477
|
|
|
478 (define-key compose-map "-(" "{")
|
|
|
479 (define-key compose-map "-)" "}")
|
|
|
480 (define-key compose-map "--" "-")
|
|
|
481 (define-key compose-map "-L" [sterling])
|
|
|
482 (define-key compose-map "-l" [sterling])
|
|
|
483 (define-key compose-map "-Y" [yen])
|
|
|
484 (define-key compose-map "-y" [yen])
|
|
|
485 (define-key compose-map "-," [notsign])
|
|
|
486 (define-key compose-map "-|" [notsign])
|
|
|
487 (define-key compose-map "-^" [macron])
|
|
|
488 (define-key compose-map "-+" [plusminus])
|
|
|
489 (define-key compose-map "-:" [division])
|
|
|
490 (define-key compose-map "-D" [ETH])
|
|
|
491 (define-key compose-map "-d" [eth])
|
|
|
492 (define-key compose-map "-a" [ordfeminine])
|
|
|
493
|
|
|
494 (define-key compose-map ".^" [periodcentered])
|
|
|
495
|
|
|
496 (define-key compose-map "//" "\\")
|
|
|
497 (define-key compose-map "/<" "\\")
|
|
|
498 (define-key compose-map "/^" "|")
|
|
|
499 (define-key compose-map "/C" [cent])
|
|
|
500 (define-key compose-map "/c" [cent])
|
|
|
501 (define-key compose-map "/U" [mu])
|
|
|
502 (define-key compose-map "/u" [mu])
|
|
|
503 (define-key compose-map "/O" [Ooblique])
|
|
|
504 (define-key compose-map "/o" [oslash])
|
|
|
505
|
|
|
506 (define-key compose-map "0X" [currency])
|
|
|
507 (define-key compose-map "0x" [currency])
|
|
|
508 (define-key compose-map "0S" [section])
|
|
|
509 (define-key compose-map "0s" [section])
|
|
|
510 (define-key compose-map "0C" [copyright])
|
|
|
511 (define-key compose-map "0c" [copyright])
|
|
|
512 (define-key compose-map "0R" [registered])
|
|
|
513 (define-key compose-map "0r" [registered])
|
|
48
|
514 (define-key compose-map "0^" 'compose-insert-degree)
|
|
0
|
515
|
|
|
516 (define-key compose-map "1^" [onesuperior])
|
|
|
517 (define-key compose-map "14" [onequarter])
|
|
|
518 (define-key compose-map "12" [onehalf])
|
|
|
519
|
|
|
520 (define-key compose-map "2^" [twosuperior])
|
|
|
521
|
|
|
522 (define-key compose-map "3^" [threesuperior])
|
|
|
523 (define-key compose-map "34" [threequarters])
|
|
|
524
|
|
|
525 (define-key compose-map ":-" [division])
|
|
|
526
|
|
|
527 (define-key compose-map "</" "\\")
|
|
|
528 (define-key compose-map "<<" [guillemotleft])
|
|
|
529
|
|
|
530 (define-key compose-map "=L" [sterling])
|
|
|
531 (define-key compose-map "=l" [sterling])
|
|
|
532 (define-key compose-map "=Y" [yen])
|
|
|
533 (define-key compose-map "=y" [yen])
|
|
|
534
|
|
|
535 (define-key compose-map ">>" [guillemotright])
|
|
|
536
|
|
|
537 (define-key compose-map "??" [questiondown])
|
|
|
538
|
|
|
539 (define-key compose-map "AA" "@")
|
|
|
540 (define-key compose-map "Aa" "@")
|
|
|
541 (define-key compose-map "A_" [ordfeminine])
|
|
|
542 (define-key compose-map "A`" [Agrave])
|
|
|
543 (define-key compose-map "A'" [Aacute])
|
|
|
544 (define-key compose-map "A^" [Acircumflex])
|
|
|
545 (define-key compose-map "A~" [Atilde])
|
|
|
546 (define-key compose-map "A\"" [Adiaeresis])
|
|
48
|
547 (define-key compose-map "A:" [Adiaeresis])
|
|
0
|
548 (define-key compose-map "A*" [Aring])
|
|
|
549 (define-key compose-map "AE" [AE])
|
|
|
550
|
|
|
551 (define-key compose-map "C/" [cent])
|
|
|
552 (define-key compose-map "C|" [cent])
|
|
|
553 (define-key compose-map "C0" [copyright])
|
|
|
554 (define-key compose-map "CO" [copyright])
|
|
|
555 (define-key compose-map "Co" [copyright])
|
|
|
556 (define-key compose-map "C," [Ccedilla])
|
|
|
557
|
|
|
558 (define-key compose-map "D-" [ETH])
|
|
|
559
|
|
|
560 (define-key compose-map "E`" [Egrave])
|
|
|
561 (define-key compose-map "E'" [Eacute])
|
|
|
562 (define-key compose-map "E^" [Ecircumflex])
|
|
|
563 (define-key compose-map "E\"" [Ediaeresis])
|
|
48
|
564 (define-key compose-map "E:" [Ediaeresis])
|
|
0
|
565
|
|
|
566 (define-key compose-map "I`" [Igrave])
|
|
|
567 (define-key compose-map "I'" [Iacute])
|
|
|
568 (define-key compose-map "I^" [Icircumflex])
|
|
|
569 (define-key compose-map "I\"" [Idiaeresis])
|
|
48
|
570 (define-key compose-map "I:" [Idiaeresis])
|
|
0
|
571
|
|
|
572 (define-key compose-map "L-" [sterling])
|
|
|
573 (define-key compose-map "L=" [sterling])
|
|
|
574
|
|
|
575 (define-key compose-map "N~" [Ntilde])
|
|
|
576
|
|
|
577 (define-key compose-map "OX" [currency])
|
|
|
578 (define-key compose-map "Ox" [currency])
|
|
|
579 (define-key compose-map "OS" [section])
|
|
|
580 (define-key compose-map "Os" [section])
|
|
|
581 (define-key compose-map "OC" [copyright])
|
|
|
582 (define-key compose-map "Oc" [copyright])
|
|
|
583 (define-key compose-map "OR" [registered])
|
|
|
584 (define-key compose-map "Or" [registered])
|
|
|
585 (define-key compose-map "O_" [masculine])
|
|
|
586 (define-key compose-map "O`" [Ograve])
|
|
|
587 (define-key compose-map "O'" [Oacute])
|
|
|
588 (define-key compose-map "O^" [Ocircumflex])
|
|
|
589 (define-key compose-map "O~" [Otilde])
|
|
|
590 (define-key compose-map "O\"" [Odiaeresis])
|
|
48
|
591 (define-key compose-map "O:" [Odiaeresis])
|
|
0
|
592 (define-key compose-map "O/" [Ooblique])
|
|
|
593
|
|
|
594 (define-key compose-map "P!" [paragraph])
|
|
|
595
|
|
|
596 (define-key compose-map "R0" [registered])
|
|
|
597 (define-key compose-map "RO" [registered])
|
|
|
598 (define-key compose-map "Ro" [registered])
|
|
|
599
|
|
|
600 (define-key compose-map "S!" [section])
|
|
|
601 (define-key compose-map "S0" [section])
|
|
|
602 (define-key compose-map "SO" [section])
|
|
|
603 (define-key compose-map "So" [section])
|
|
|
604 (define-key compose-map "SS" [ssharp])
|
|
|
605
|
|
|
606 (define-key compose-map "TH" [THORN])
|
|
|
607
|
|
|
608 (define-key compose-map "U`" [Ugrave])
|
|
|
609 (define-key compose-map "U'" [Uacute])
|
|
|
610 (define-key compose-map "U^" [Ucircumflex])
|
|
|
611 (define-key compose-map "U\"" [Udiaeresis])
|
|
48
|
612 (define-key compose-map "U:" [Udiaeresis])
|
|
0
|
613
|
|
|
614 (define-key compose-map "X0" [currency])
|
|
|
615 (define-key compose-map "XO" [currency])
|
|
|
616 (define-key compose-map "Xo" [currency])
|
|
|
617
|
|
|
618 (define-key compose-map "Y-" [yen])
|
|
|
619 (define-key compose-map "Y=" [yen])
|
|
|
620 (define-key compose-map "Y'" [Yacute])
|
|
|
621
|
|
|
622 (define-key compose-map "_A" [ordfeminine])
|
|
|
623 (define-key compose-map "_a" [ordfeminine])
|
|
|
624 (define-key compose-map "_^" [macron])
|
|
|
625 (define-key compose-map "_O" [masculine])
|
|
|
626 (define-key compose-map "_o" [masculine])
|
|
|
627
|
|
|
628 (define-key compose-map "aA" "@")
|
|
|
629 (define-key compose-map "aa" "@")
|
|
|
630 (define-key compose-map "a_" [ordfeminine])
|
|
|
631 (define-key compose-map "a-" [ordfeminine])
|
|
|
632 (define-key compose-map "a`" [agrave])
|
|
|
633 (define-key compose-map "a'" [aacute])
|
|
|
634 (define-key compose-map "a^" [acircumflex])
|
|
|
635 (define-key compose-map "a~" [atilde])
|
|
|
636 (define-key compose-map "a\"" [adiaeresis])
|
|
48
|
637 (define-key compose-map "a:" [adiaeresis])
|
|
0
|
638 (define-key compose-map "a*" [aring])
|
|
|
639 (define-key compose-map "ae" [ae])
|
|
|
640
|
|
|
641 (define-key compose-map "c/" [cent])
|
|
|
642 (define-key compose-map "c|" [cent])
|
|
|
643 (define-key compose-map "c0" [copyright])
|
|
|
644 (define-key compose-map "cO" [copyright])
|
|
|
645 (define-key compose-map "co" [copyright])
|
|
|
646 (define-key compose-map "c," [ccedilla])
|
|
|
647
|
|
|
648 (define-key compose-map "d-" [eth])
|
|
|
649
|
|
|
650 (define-key compose-map "e`" [egrave])
|
|
|
651 (define-key compose-map "e'" [eacute])
|
|
|
652 (define-key compose-map "e^" [ecircumflex])
|
|
|
653 (define-key compose-map "e\"" [ediaeresis])
|
|
48
|
654 (define-key compose-map "e:" [ediaeresis])
|
|
0
|
655
|
|
|
656 (define-key compose-map "i`" [igrave])
|
|
|
657 (define-key compose-map "i'" [iacute])
|
|
|
658 (define-key compose-map "i^" [icircumflex])
|
|
|
659 (define-key compose-map "i\"" [idiaeresis])
|
|
48
|
660 (define-key compose-map "i:" [idiaeresis])
|
|
0
|
661
|
|
|
662 (define-key compose-map "l-" [sterling])
|
|
|
663 (define-key compose-map "l=" [sterling])
|
|
|
664
|
|
|
665 (define-key compose-map "n~" [ntilde])
|
|
|
666
|
|
|
667 (define-key compose-map "oX" [currency])
|
|
|
668 (define-key compose-map "ox" [currency])
|
|
|
669 (define-key compose-map "oC" [copyright])
|
|
|
670 (define-key compose-map "oc" [copyright])
|
|
|
671 (define-key compose-map "oR" [registered])
|
|
|
672 (define-key compose-map "or" [registered])
|
|
|
673 (define-key compose-map "oS" [section])
|
|
|
674 (define-key compose-map "os" [section])
|
|
|
675 (define-key compose-map "o_" [masculine])
|
|
|
676 (define-key compose-map "o`" [ograve])
|
|
|
677 (define-key compose-map "o'" [oacute])
|
|
|
678 (define-key compose-map "o^" [ocircumflex])
|
|
|
679 (define-key compose-map "o~" [otilde])
|
|
|
680 (define-key compose-map "o\"" [odiaeresis])
|
|
48
|
681 (define-key compose-map "o:" [odiaeresis])
|
|
0
|
682 (define-key compose-map "o/" [oslash])
|
|
|
683
|
|
|
684 (define-key compose-map "p!" [paragraph])
|
|
|
685
|
|
|
686 (define-key compose-map "r0" [registered])
|
|
|
687 (define-key compose-map "rO" [registered])
|
|
|
688 (define-key compose-map "ro" [registered])
|
|
|
689
|
|
|
690 (define-key compose-map "s!" [section])
|
|
|
691 (define-key compose-map "s0" [section])
|
|
|
692 (define-key compose-map "sO" [section])
|
|
|
693 (define-key compose-map "so" [section])
|
|
|
694 (define-key compose-map "ss" [ssharp])
|
|
|
695
|
|
|
696 (define-key compose-map "th" [thorn])
|
|
|
697
|
|
|
698 (define-key compose-map "u`" [ugrave])
|
|
|
699 (define-key compose-map "u'" [uacute])
|
|
|
700 (define-key compose-map "u^" [ucircumflex])
|
|
|
701 (define-key compose-map "u\"" [udiaeresis])
|
|
48
|
702 (define-key compose-map "u:" [udiaeresis])
|
|
0
|
703 (define-key compose-map "u/" [mu])
|
|
|
704
|
|
|
705 (define-key compose-map "x0" [currency])
|
|
|
706 (define-key compose-map "xO" [currency])
|
|
|
707 (define-key compose-map "xo" [currency])
|
|
|
708 (define-key compose-map "xx" [multiply])
|
|
|
709
|
|
|
710 (define-key compose-map "y-" [yen])
|
|
|
711 (define-key compose-map "y=" [yen])
|
|
|
712 (define-key compose-map "y'" [yacute])
|
|
|
713 (define-key compose-map "y\"" [ydiaeresis])
|
|
48
|
714 (define-key compose-map "y:" [ydiaeresis])
|
|
0
|
715
|
|
|
716 (define-key compose-map "|C" [cent])
|
|
|
717 (define-key compose-map "|c" [cent])
|
|
|
718 (define-key compose-map "||" [brokenbar])
|
|
|
719
|
|
|
720
|
|
|
721 ;;; Electric dead keys: making a' mean a-acute.
|
|
|
722
|
|
|
723 (defun electric-diacritic (&optional count)
|
|
|
724 "Modify the previous character with an accent.
|
|
|
725 For example, if `:' is bound to this command, then typing `a:'
|
|
|
726 will first insert `a' and then turn it into `\344' (adiaeresis).
|
|
|
727 The keys to which this command may be bound (and the accents
|
|
|
728 which it understands) are:
|
|
|
729
|
|
|
730 ' (acute) \301\311\315\323\332\335 \341\351\355\363\372\375
|
|
|
731 ` (grave) \300\310\314\322\331 \340\350\354\362\371
|
|
|
732 : (diaeresis) \304\313\317\326\334 \344\353\357\366\374\377
|
|
|
733 ^ (circumflex) \302\312\316\324\333 \342\352\356\364\373
|
|
|
734 , (cedilla) \307\347
|
|
|
735 . (ring) \305\345"
|
|
|
736 (interactive "p")
|
|
|
737 (or count (setq count 1))
|
|
|
738
|
|
|
739 (if (not (eq last-command 'self-insert-command))
|
|
|
740 ;; Only do the magic if the two chars were typed in succession.
|
|
|
741 (self-insert-command count)
|
|
|
742
|
|
|
743 ;; This is so that ``a : C-x u'' will transform `adiaeresis' back into `a:'
|
|
|
744 (self-insert-command count)
|
|
|
745 (undo-boundary)
|
|
|
746 (delete-char (- count))
|
|
|
747
|
|
|
748 (let* ((c last-command-char)
|
|
|
749 (map (cond ((eq c ?') compose-acute-map)
|
|
|
750 ((eq c ?`) compose-grave-map)
|
|
|
751 ((eq c ?,) compose-cedilla-map)
|
|
|
752 ((eq c ?:) compose-diaeresis-map)
|
|
48
|
753 ((eq c ?\") compose-diaeresis-map)
|
|
0
|
754 ((eq c ?^) compose-circumflex-map)
|
|
|
755 ((eq c ?~) compose-tilde-map)
|
|
|
756 ((eq c ?.) compose-ring-map)
|
|
|
757 (t (error "unknown diacritic: %s (%c)" c c))))
|
|
|
758 (base-char (preceding-char))
|
|
|
759 (mod-char (and (>= (downcase base-char) ?a) ; only do alphabetics?
|
|
|
760 (<= (downcase base-char) ?z)
|
|
|
761 (lookup-key map (make-string 1 base-char)))))
|
|
|
762 (if (and (vectorp mod-char) (= (length mod-char) 1))
|
|
|
763 (setq mod-char (aref mod-char 0)))
|
|
|
764 (if (and mod-char (symbolp mod-char))
|
|
|
765 (setq mod-char (or (get mod-char character-set-property) mod-char)))
|
|
|
766 (if (and mod-char (> count 0))
|
|
|
767 (delete-char -1)
|
|
|
768 (setq mod-char c))
|
|
|
769 (while (> count 0)
|
|
|
770 (insert mod-char)
|
|
|
771 (setq count (1- count))))))
|
|
|
772
|
|
14
|
773 ;; should "::" mean ",A((B" and ": " mean ":"?
|
|
0
|
774 ;; should we also do
|
|
|
775 ;; (?~
|
|
|
776 ;; (?A "\303")
|
|
|
777 ;; (?C "\307")
|
|
|
778 ;; (?D "\320")
|
|
|
779 ;; (?N "\321")
|
|
|
780 ;; (?O "\325")
|
|
|
781 ;; (?a "\343")
|
|
|
782 ;; (?c "\347")
|
|
|
783 ;; (?d "\360")
|
|
|
784 ;; (?n "\361")
|
|
|
785 ;; (?o "\365")
|
|
|
786 ;; (?> "\273")
|
|
|
787 ;; (?< "\253")
|
|
|
788 ;; (? "~")) ; no special code
|
|
|
789 ;; (?\/
|
|
|
790 ;; (?A "\305") ;; A-with-ring (Norwegian and Danish)
|
|
|
791 ;; (?E "\306") ;; AE-ligature (Norwegian and Danish)
|
|
|
792 ;; (?O "\330")
|
|
|
793 ;; (?a "\345") ;; a-with-ring (Norwegian and Danish)
|
|
|
794 ;; (?e "\346") ;; ae-ligature (Norwegian and Danish)
|
|
|
795 ;; (?o "\370")
|
|
|
796 ;; (? "/")) ; no special code
|
|
|
797
|
|
|
798
|
|
|
799 ;;; Providing help in the middle of a compose sequence. (Way cool.)
|
|
|
800
|
|
|
801 (defun compose-help ()
|
|
|
802 (interactive)
|
|
|
803 (let* ((keys (apply 'vector
|
|
|
804 (nreverse
|
|
|
805 (cdr (nreverse (append (this-command-keys) nil))))))
|
|
|
806 (map (or (key-binding keys)
|
|
|
807 (error (format "can't find map? %s" (this-command-keys))))))
|
|
|
808 (with-output-to-temp-buffer "*Help*"
|
|
|
809 (set-buffer "*Help*")
|
|
|
810 (erase-buffer)
|
|
|
811 (message "Working...")
|
|
|
812 (setq ctl-arrow 'compose) ; non-t-non-nil
|
|
|
813 (insert "You are typing a compose sequence. So far you have typed: ")
|
|
|
814 (insert (key-description keys))
|
|
|
815 (insert "\nCompletions from here are:\n\n")
|
|
|
816 (map-keymap 'compose-help-mapper map t)
|
|
|
817 (message "? "))
|
|
|
818 (let (event)
|
|
|
819 (while (progn
|
|
|
820 (setq event (next-command-event))
|
|
|
821 (setq map (lookup-key map (vector event)))
|
|
|
822 (keymapp map))
|
|
|
823 )
|
|
|
824 (if map
|
|
|
825 (command-execute map)
|
|
|
826 (setq unread-command-event event)))))
|
|
|
827
|
|
|
828 (put 'compose-help 'isearch-command t) ; so that it doesn't terminate isearch
|
|
|
829
|
|
|
830 (defun compose-help-mapper (key binding)
|
|
|
831 (if (and (symbolp key)
|
|
|
832 (get key character-set-property))
|
|
|
833 (setq key (get key character-set-property)))
|
|
|
834 (if (eq binding 'compose-help) ; suppress that...
|
|
|
835 nil
|
|
|
836 (if (keymapp binding)
|
|
|
837 (let ((p (point)))
|
|
|
838 (map-keymap 'compose-help-mapper binding t)
|
|
|
839 (goto-char p)
|
|
|
840 (while (not (eobp))
|
|
|
841 (if (numberp key)
|
|
|
842 (insert (make-string 1 key))
|
|
|
843 (insert (single-key-description key)))
|
|
|
844 (insert " ")
|
|
|
845 (forward-line 1)))
|
|
|
846 (if (numberp key)
|
|
|
847 (insert (make-string 1 key))
|
|
|
848 (insert (single-key-description key)))
|
|
|
849 (indent-to 16)
|
|
|
850 (let ((code (and (vectorp binding)
|
|
|
851 (= 1 (length binding))
|
|
|
852 (get (aref binding 0) character-set-property))))
|
|
|
853 (if code
|
|
|
854 (insert (make-string 1 code))
|
|
|
855 (if (stringp binding)
|
|
|
856 (insert binding)
|
|
|
857 (insert (prin1-to-string binding)))))
|
|
|
858 (if (and (vectorp binding) (= 1 (length binding)))
|
|
|
859 (progn
|
|
|
860 (indent-to 32)
|
|
|
861 (insert (symbol-name (aref binding 0))))))
|
|
|
862 (insert "\n")))
|
|
|
863
|
|
|
864 ;; define it at top-level in the compose map...
|
|
|
865 (define-key compose-map '(control h) 'compose-help)
|
|
|
866 (define-key compose-map 'help 'compose-help)
|
|
|
867 ;; and then define it in each sub-map of the compose map.
|
|
|
868 (map-keymap
|
|
|
869 (function (lambda (key binding)
|
|
|
870 (if (keymapp binding)
|
|
|
871 (progn
|
|
|
872 (define-key binding '(control h) 'compose-help)
|
|
|
873 (define-key binding 'help 'compose-help)))))
|
|
|
874 compose-map nil)
|
|
|
875
|
|
2
|
876 ;; Make redisplay display the accented letters
|
|
0
|
877 (if (memq (default-value 'ctl-arrow) '(t nil))
|
|
|
878 (setq-default ctl-arrow 'iso-8859/1))
|
|
|
879
|
|
|
880
|
|
|
881 (provide 'x-compose)
|
