]>
Commit | Line | Data |
---|---|---|
c6e3fd22 WH |
1 | /* speakup.c |
2 | review functions for the speakup screen review package. | |
3 | originally written by: Kirk Reiser and Andy Berdan. | |
4 | ||
5 | extensively modified by David Borowski. | |
6 | ||
7 | Copyright (C) 1998 Kirk Reiser. | |
8 | Copyright (C) 2003 David Borowski. | |
9 | ||
10 | This program 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 of the License, or | |
13 | (at your option) any later version. | |
14 | ||
15 | This program 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 this program; if not, write to the Free Software | |
22 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
23 | */ | |
24 | ||
25 | #include <linux/kernel.h> | |
26 | #include <linux/version.h> | |
27 | #include <linux/vt.h> | |
28 | #include <linux/tty.h> | |
29 | #include <linux/mm.h> /* __get_free_page() and friends */ | |
30 | #include <linux/vt_kern.h> | |
31 | #include <linux/ctype.h> | |
32 | #include <linux/selection.h> | |
33 | #include <linux/unistd.h> | |
34 | #include <linux/jiffies.h> | |
35 | #include <linux/kthread.h> | |
36 | #include <linux/keyboard.h> /* for KT_SHIFT */ | |
37 | #include <linux/kbd_kern.h> /* for vc_kbd_* and friends */ | |
38 | #include <linux/input.h> | |
39 | #include <linux/kmod.h> | |
40 | ||
41 | #include <linux/bootmem.h> /* for alloc_bootmem */ | |
42 | ||
43 | /* speakup_*_selection */ | |
44 | #include <linux/module.h> | |
45 | #include <linux/sched.h> | |
46 | #include <linux/slab.h> | |
47 | #include <linux/types.h> | |
48 | #include <linux/consolemap.h> | |
49 | ||
50 | #include <linux/spinlock.h> | |
51 | #include <linux/notifier.h> | |
52 | ||
53 | #include <linux/uaccess.h> /* copy_from|to|user() and others */ | |
54 | ||
55 | #include "spk_priv.h" | |
56 | #include "speakup.h" | |
57 | ||
58 | #define MAX_DELAY msecs_to_jiffies(500) | |
59 | #define MINECHOCHAR SPACE | |
60 | ||
61 | MODULE_AUTHOR("Kirk Reiser <kirk@braille.uwo.ca>"); | |
62 | MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>"); | |
63 | MODULE_DESCRIPTION("Speakup console speech"); | |
64 | MODULE_LICENSE("GPL"); | |
65 | MODULE_VERSION(SPEAKUP_VERSION); | |
66 | ||
67 | char *synth_name; | |
68 | module_param_named(synth, synth_name, charp, S_IRUGO); | |
69 | module_param_named(quiet, quiet_boot, bool, S_IRUGO); | |
70 | ||
71 | MODULE_PARM_DESC(synth, "Synth to start if speakup is built in."); | |
72 | MODULE_PARM_DESC(quiet, "Do not announce when the synthesizer is found."); | |
73 | ||
74 | special_func special_handler; | |
75 | ||
76 | short pitch_shift, synth_flags; | |
77 | static char buf[256]; | |
78 | int attrib_bleep, bleeps, bleep_time = 10; | |
79 | int no_intr, spell_delay; | |
80 | int key_echo, say_word_ctl; | |
81 | int say_ctrl, bell_pos; | |
82 | short punc_mask; | |
83 | int punc_level, reading_punc; | |
84 | char str_caps_start[MAXVARLEN+1] = "\0", str_caps_stop[MAXVARLEN+1] = "\0"; | |
85 | const struct st_bits_data punc_info[] = { | |
86 | { "none", "", 0 }, | |
87 | { "some", "/$%&@", SOME }, | |
88 | { "most", "$%&#()=+*/@^<>|\\", MOST }, | |
89 | { "all", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", PUNC }, | |
90 | { "delimiters", "", B_WDLM }, | |
91 | { "repeats", "()", CH_RPT }, | |
92 | { "extended numeric", "", B_EXNUM }, | |
93 | { "symbols", "", B_SYM }, | |
94 | { 0, 0 } | |
95 | }; | |
96 | static char mark_cut_flag; | |
97 | #define MAX_KEY 160 | |
98 | u_char *our_keys[MAX_KEY], *shift_table; | |
99 | u_char key_buf[600]; | |
100 | const u_char key_defaults[] = { | |
101 | #include "speakupmap.h" | |
102 | }; | |
103 | ||
104 | /* Speakup Cursor Track Variables */ | |
105 | static int cursor_track = 1, prev_cursor_track = 1; | |
106 | ||
107 | /* cursor track modes, must be ordered same as cursor_msgs */ | |
108 | enum { | |
109 | CT_Off = 0, | |
110 | CT_On, | |
111 | CT_Highlight, | |
112 | CT_Window, | |
113 | CT_Max | |
114 | }; | |
115 | #define read_all_mode CT_Max | |
116 | ||
117 | static struct tty_struct *tty; | |
118 | ||
119 | static void spkup_write(const char *in_buf, int count); | |
120 | ||
121 | ||
122 | static char *phonetic[] = { | |
123 | "alfa", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel", | |
124 | "india", "juliett", "keelo", "leema", "mike", "november", "oscar", "papa", | |
125 | "keh beck", "romeo", "sierra", "tango", "uniform", "victer", "whiskey", | |
126 | "x ray", "yankee", "zulu" | |
127 | }; | |
128 | ||
129 | /* array of 256 char pointers (one for each character description) | |
130 | * initialized to default_chars and user selectable via | |
131 | * /proc/speakup/characters */ | |
132 | char *characters[256]; | |
133 | ||
134 | char *default_chars[256] = { | |
135 | /*000*/ "null", "^a", "^b", "^c", "^d", "^e", "^f", "^g", | |
136 | /*008*/ "^h", "^i", "^j", "^k", "^l", "^m", "^n", "^o", | |
137 | /*016*/ "^p", "^q", "^r", "^s", "^t", "^u", "^v", "^w", | |
138 | /*024*/ "^x", "^y", "^z", "control", "control", "control", "control", "control", | |
139 | /*032*/ "space", "bang!", "quote", "number", "dollar", "percent", "and", "tick", | |
140 | /*040*/ "left paren", "right paren", "star", "plus", "comma", "dash", "dot", | |
141 | "slash", | |
142 | /*048*/ "zero", "one", "two", "three", "four", "five", "six", "seven", | |
143 | "eight", "nine", | |
144 | /*058*/ "colon", "semmy", "less", "equals", "greater", "question", "at", | |
145 | /*065*/ "EIGH", "B", "C", "D", "E", "F", "G", | |
146 | /*072*/ "H", "I", "J", "K", "L", "M", "N", "O", | |
147 | /*080*/ "P", "Q", "R", "S", "T", "U", "V", "W", "X", | |
148 | /*089*/ "Y", "ZED", "left bracket", "backslash", "right bracket", "caret", | |
149 | "line", | |
150 | /*096*/ "accent", "a", "b", "c", "d", "e", "f", "g", | |
151 | /*104*/ "h", "i", "j", "k", "l", "m", "n", "o", | |
152 | /*112*/ "p", "q", "r", "s", "t", "u", "v", "w", | |
153 | /*120*/ "x", "y", "zed", "left brace", "bar", "right brace", "tihlduh", | |
154 | /*127*/ "del", "control", "control", "control", "control", "control", "control", "control", "control", "control", "control", | |
155 | /*138*/ "control", "control", "control", "control", "control", "control", "control", "control", "control", "control", "control", "control", | |
156 | /*150*/ "control", "control", "control", "control", "control", "control", "control", "control", "control", "control", | |
157 | /*160*/ "nbsp", "inverted bang", | |
158 | /*162*/ "cents", "pounds", "currency", "yen", "broken bar", "section", | |
159 | /*168*/ "diaeresis", "copyright", "female ordinal", "double left angle", | |
160 | /*172*/ "not", "soft hyphen", "registered", "macron", | |
161 | /*176*/ "degrees", "plus or minus", "super two", "super three", | |
162 | /*180*/ "acute accent", "micro", "pilcrow", "middle dot", | |
163 | /*184*/ "cedilla", "super one", "male ordinal", "double right angle", | |
164 | /*188*/ "one quarter", "one half", "three quarters", "inverted question", | |
165 | /*192*/ "A GRAVE", "A ACUTE", "A CIRCUMFLEX", "A TILDE", "A OOMLAUT", "A RING", | |
166 | /*198*/ "AE", "C CIDELLA", "E GRAVE", "E ACUTE", "E CIRCUMFLEX", "E OOMLAUT", | |
167 | /*204*/ "I GRAVE", "I ACUTE", "I CIRCUMFLEX", "I OOMLAUT", "ETH", "N TILDE", | |
168 | /*210*/ "O GRAVE", "O ACUTE", "O CIRCUMFLEX", "O TILDE", "O OOMLAUT", | |
169 | /*215*/ "multiplied by", "O STROKE", "U GRAVE", "U ACUTE", "U CIRCUMFLEX", | |
170 | /*220*/ "U OOMLAUT", "Y ACUTE", "THORN", "sharp s", "a grave", | |
171 | /*225*/ "a acute", "a circumflex", "a tilde", "a oomlaut", "a ring", | |
172 | /*230*/ "ae", "c cidella", "e grave", "e acute", | |
173 | /*234*/ "e circumflex", "e oomlaut", "i grave", "i acute", "i circumflex", | |
174 | /*239*/ "i oomlaut", "eth", "n tilde","o grave", "o acute", "o circumflex", | |
175 | /*245*/"o tilde", "o oomlaut", "divided by", "o stroke", "u grave", "u acute", | |
176 | /* 251 */ "u circumflex", "u oomlaut", "y acute", "thorn", "y oomlaut" | |
177 | }; | |
178 | ||
179 | /* array of 256 u_short (one for each character) | |
180 | * initialized to default_chartab and user selectable via | |
181 | * /sys/module/speakup/parameters/chartab */ | |
182 | u_short spk_chartab[256]; | |
183 | ||
184 | static u_short default_chartab[256] = { | |
185 | B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /* 0-7 */ | |
186 | B_CTL, B_CTL, A_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /* 8-15 */ | |
187 | B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /*16-23 */ | |
188 | B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, B_CTL, /* 24-31 */ | |
189 | WDLM, A_PUNC, PUNC, PUNC, PUNC, PUNC, PUNC, A_PUNC, /* !"#$%&' */ | |
190 | PUNC, PUNC, PUNC, PUNC, A_PUNC, A_PUNC, A_PUNC, PUNC, /* ()*+, -./ */ | |
191 | NUM, NUM, NUM, NUM, NUM, NUM, NUM, NUM, /* 01234567 */ | |
192 | NUM, NUM, A_PUNC, PUNC, PUNC, PUNC, PUNC, A_PUNC, /* 89:;<=>? */ | |
193 | PUNC, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* @ABCDEFG */ | |
194 | A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* HIJKLMNO */ | |
195 | A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* PQRSTUVW */ | |
196 | A_CAP, A_CAP, A_CAP, PUNC, PUNC, PUNC, PUNC, PUNC, /* XYZ[\]^_ */ | |
197 | PUNC, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* `abcdefg */ | |
198 | ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* hijklmno */ | |
199 | ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* pqrstuvw */ | |
200 | ALPHA, ALPHA, ALPHA, PUNC, PUNC, PUNC, PUNC, 0, /* xyz{|}~ */ | |
201 | B_CAPSYM, B_CAPSYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 128-135 */ | |
202 | B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_CAPSYM, /* 136-143 */ | |
203 | B_CAPSYM, B_CAPSYM, B_SYM, B_CAPSYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 144-151 */ | |
204 | B_SYM, B_SYM, B_CAPSYM, B_CAPSYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 152-159 */ | |
205 | WDLM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_CAPSYM, B_SYM, /* 160-167 */ | |
206 | B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 168-175 */ | |
207 | B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 176-183 */ | |
208 | B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, B_SYM, /* 184-191 */ | |
209 | A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* 192-199 */ | |
210 | A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, /* 200-207 */ | |
211 | A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, B_SYM, /* 208-215 */ | |
212 | A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, A_CAP, ALPHA, /* 216-223 */ | |
213 | ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* 224-231 */ | |
214 | ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, /* 232-239 */ | |
215 | ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, B_SYM, /* 240-247 */ | |
216 | ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA, ALPHA /* 248-255 */ | |
217 | }; | |
218 | ||
219 | struct task_struct *speakup_task; | |
220 | struct bleep unprocessed_sound; | |
221 | static int spk_keydown; | |
222 | static u_char spk_lastkey, spk_close_press, keymap_flags; | |
223 | static u_char last_keycode, this_speakup_key; | |
224 | static u_long last_spk_jiffy; | |
225 | ||
226 | struct st_spk_t *speakup_console[MAX_NR_CONSOLES]; | |
227 | ||
228 | DEFINE_MUTEX(spk_mutex); | |
229 | ||
230 | static int keyboard_notifier_call(struct notifier_block *, | |
231 | unsigned long code, void *param); | |
232 | ||
233 | struct notifier_block keyboard_notifier_block = { | |
234 | .notifier_call = keyboard_notifier_call, | |
235 | }; | |
236 | ||
237 | static int vt_notifier_call(struct notifier_block *, | |
238 | unsigned long code, void *param); | |
239 | ||
240 | struct notifier_block vt_notifier_block = { | |
241 | .notifier_call = vt_notifier_call, | |
242 | }; | |
243 | ||
244 | static unsigned char get_attributes(u16 *pos) | |
245 | { | |
246 | return (u_char)(scr_readw(pos) >> 8); | |
247 | } | |
248 | ||
249 | static void speakup_date(struct vc_data *vc) | |
250 | { | |
251 | spk_x = spk_cx = vc->vc_x; | |
252 | spk_y = spk_cy = vc->vc_y; | |
253 | spk_pos = spk_cp = vc->vc_pos; | |
254 | spk_old_attr = spk_attr; | |
255 | spk_attr = get_attributes((u_short *) spk_pos); | |
256 | } | |
257 | ||
258 | static void bleep(u_short val) | |
259 | { | |
260 | static const short vals[] = { | |
261 | 350, 370, 392, 414, 440, 466, 491, 523, 554, 587, 619, 659 | |
262 | }; | |
263 | short freq; | |
264 | int time = bleep_time; | |
265 | freq = vals[val%12]; | |
266 | if (val > 11) | |
267 | freq *= (1 << (val/12)); | |
268 | unprocessed_sound.freq = freq; | |
269 | unprocessed_sound.jiffies = msecs_to_jiffies(time); | |
270 | unprocessed_sound.active = 1; | |
271 | /* We can only have 1 active sound at a time. */ | |
272 | } | |
273 | ||
274 | static void speakup_shut_up(struct vc_data *vc) | |
275 | { | |
276 | if (spk_killed) | |
277 | return; | |
278 | spk_shut_up |= 0x01; | |
279 | spk_parked &= 0xfe; | |
280 | speakup_date(vc); | |
281 | if (synth != NULL) | |
282 | do_flush(); | |
283 | } | |
284 | ||
285 | static void speech_kill(struct vc_data *vc) | |
286 | { | |
287 | char val = synth->is_alive(synth); | |
288 | if (val == 0) | |
289 | return; | |
290 | ||
291 | /* re-enables synth, if disabled */ | |
292 | if (val == 2 || spk_killed) { | |
293 | /* dead */ | |
294 | spk_shut_up &= ~0x40; | |
295 | synth_printf("%s\n", msg_get(MSG_IAM_ALIVE)); | |
296 | } else { | |
297 | synth_printf("%s\n", msg_get(MSG_YOU_KILLED_SPEAKUP)); | |
298 | spk_shut_up |= 0x40; | |
299 | } | |
300 | } | |
301 | ||
302 | static void speakup_off(struct vc_data *vc) | |
303 | { | |
304 | if (spk_shut_up & 0x80) { | |
305 | spk_shut_up &= 0x7f; | |
306 | synth_printf("%s\n", msg_get(MSG_HEY_THATS_BETTER)); | |
307 | } else { | |
308 | spk_shut_up |= 0x80; | |
309 | synth_printf("%s\n", msg_get(MSG_YOU_TURNED_ME_OFF)); | |
310 | } | |
311 | speakup_date(vc); | |
312 | } | |
313 | ||
314 | static void speakup_parked(struct vc_data *vc) | |
315 | { | |
316 | if (spk_parked & 0x80) { | |
317 | spk_parked = 0; | |
318 | synth_printf("%s\n", msg_get(MSG_UNPARKED)); | |
319 | } else { | |
320 | spk_parked |= 0x80; | |
321 | synth_printf("%s\n", msg_get(MSG_PARKED)); | |
322 | } | |
323 | } | |
324 | ||
325 | static void speakup_cut(struct vc_data *vc) | |
326 | { | |
327 | static const char err_buf[] = "set selection failed"; | |
328 | int ret; | |
329 | ||
330 | if (!mark_cut_flag) { | |
331 | mark_cut_flag = 1; | |
332 | xs = (u_short) spk_x; | |
333 | ys = (u_short) spk_y; | |
334 | spk_sel_cons = vc; | |
335 | synth_printf("%s\n", msg_get(MSG_MARK)); | |
336 | return; | |
337 | } | |
338 | xe = (u_short) spk_x; | |
339 | ye = (u_short) spk_y; | |
340 | mark_cut_flag = 0; | |
341 | synth_printf("%s\n", msg_get(MSG_CUT)); | |
342 | ||
343 | speakup_clear_selection(); | |
344 | ret = speakup_set_selection(tty); | |
345 | ||
346 | switch (ret) { | |
347 | case 0: | |
348 | break; /* no error */ | |
349 | case -EFAULT : | |
350 | pr_warn("%sEFAULT\n", err_buf); | |
351 | break; | |
352 | case -EINVAL : | |
353 | pr_warn("%sEINVAL\n", err_buf); | |
354 | break; | |
355 | case -ENOMEM : | |
356 | pr_warn("%sENOMEM\n", err_buf); | |
357 | break; | |
358 | } | |
359 | } | |
360 | ||
361 | static void speakup_paste(struct vc_data *vc) | |
362 | { | |
363 | if (mark_cut_flag) { | |
364 | mark_cut_flag = 0; | |
365 | synth_printf("%s\n", msg_get(MSG_MARK_CLEARED)); | |
366 | } else { | |
367 | synth_printf("%s\n", msg_get(MSG_PASTE)); | |
368 | speakup_paste_selection(tty); | |
369 | } | |
370 | } | |
371 | ||
372 | static void say_attributes(struct vc_data *vc) | |
373 | { | |
374 | int fg = spk_attr & 0x0f; | |
375 | int bg = spk_attr >> 4; | |
376 | if (fg > 8) { | |
377 | synth_printf("%s ", msg_get(MSG_BRIGHT)); | |
378 | fg -= 8; | |
379 | } | |
380 | synth_printf("%s", msg_get(MSG_COLORS_START + fg)); | |
381 | if (bg > 7) { | |
382 | synth_printf(" %s ", msg_get(MSG_ON_BLINKING)); | |
383 | bg -= 8; | |
384 | } else | |
385 | synth_printf(" %s ", msg_get(MSG_ON)); | |
386 | synth_printf("%s\n", msg_get(MSG_COLORS_START + bg)); | |
387 | } | |
388 | ||
389 | enum { | |
390 | edge_top = 1, | |
391 | edge_bottom, | |
392 | edge_left, | |
393 | edge_right, | |
394 | edge_quiet | |
395 | }; | |
396 | ||
397 | static void announce_edge(struct vc_data *vc, int msg_id) | |
398 | { | |
399 | if (bleeps & 1) | |
400 | bleep(spk_y); | |
401 | if ((bleeps & 2) && (msg_id < edge_quiet)) | |
402 | synth_printf("%s\n", msg_get(MSG_EDGE_MSGS_START + msg_id - 1)); | |
403 | } | |
404 | ||
405 | static void speak_char(u_char ch) | |
406 | { | |
407 | char *cp = characters[ch]; | |
408 | struct var_t *direct = get_var(DIRECT); | |
409 | if (direct && direct->u.n.value) { | |
410 | if (IS_CHAR(ch, B_CAP)) { | |
411 | pitch_shift++; | |
412 | synth_printf("%s", str_caps_start); | |
413 | } | |
414 | synth_printf("%c", ch); | |
415 | if (IS_CHAR(ch, B_CAP)) | |
416 | synth_printf("%s", str_caps_stop); | |
417 | return; | |
418 | } | |
419 | if (cp == NULL) { | |
420 | pr_info("speak_char: cp == NULL!\n"); | |
421 | return; | |
422 | } | |
423 | synth_buffer_add(SPACE); | |
424 | if (IS_CHAR(ch, B_CAP)) { | |
425 | pitch_shift++; | |
426 | synth_printf("%s", str_caps_start); | |
427 | synth_printf("%s", cp); | |
428 | synth_printf("%s", str_caps_stop); | |
429 | } else { | |
430 | if (*cp == '^') { | |
431 | synth_printf("%s", msg_get(MSG_CTRL)); | |
432 | cp++; | |
433 | } | |
434 | synth_printf("%s", cp); | |
435 | } | |
436 | synth_buffer_add(SPACE); | |
437 | } | |
438 | ||
439 | static u16 get_char(struct vc_data *vc, u16 *pos, u_char *attribs) | |
440 | { | |
441 | u16 ch = ' '; | |
442 | if (vc && pos) { | |
443 | u16 w = scr_readw(pos); | |
444 | u16 c = w & 0xff; | |
445 | ||
446 | if (w & vc->vc_hi_font_mask) | |
447 | c |= 0x100; | |
448 | ||
449 | ch = inverse_translate(vc, c, 0); | |
450 | *attribs = (w & 0xff00) >> 8; | |
451 | } | |
452 | return ch; | |
453 | } | |
454 | ||
455 | static void say_char(struct vc_data *vc) | |
456 | { | |
457 | u_short ch; | |
458 | spk_old_attr = spk_attr; | |
459 | ch = get_char(vc, (u_short *) spk_pos, &spk_attr); | |
460 | if (spk_attr != spk_old_attr) { | |
461 | if (attrib_bleep & 1) | |
462 | bleep(spk_y); | |
463 | if (attrib_bleep & 2) | |
464 | say_attributes(vc); | |
465 | } | |
466 | speak_char(ch & 0xff); | |
467 | } | |
468 | ||
469 | static void say_phonetic_char(struct vc_data *vc) | |
470 | { | |
471 | u_short ch; | |
472 | spk_old_attr = spk_attr; | |
473 | ch = get_char(vc, (u_short *) spk_pos, &spk_attr); | |
474 | if (isascii(ch) && isalpha(ch)) { | |
475 | ch &= 0x1f; | |
476 | synth_printf("%s\n", phonetic[--ch]); | |
477 | } else { | |
478 | if (IS_CHAR(ch, B_NUM)) | |
479 | synth_printf("%s ", msg_get(MSG_NUMBER)); | |
480 | speak_char(ch); | |
481 | } | |
482 | } | |
483 | ||
484 | static void say_prev_char(struct vc_data *vc) | |
485 | { | |
486 | spk_parked |= 0x01; | |
487 | if (spk_x == 0) { | |
488 | announce_edge(vc, edge_left); | |
489 | return; | |
490 | } | |
491 | spk_x--; | |
492 | spk_pos -= 2; | |
493 | say_char(vc); | |
494 | } | |
495 | ||
496 | static void say_next_char(struct vc_data *vc) | |
497 | { | |
498 | spk_parked |= 0x01; | |
499 | if (spk_x == vc->vc_cols - 1) { | |
500 | announce_edge(vc, edge_right); | |
501 | return; | |
502 | } | |
503 | spk_x++; | |
504 | spk_pos += 2; | |
505 | say_char(vc); | |
506 | } | |
507 | ||
508 | /* get_word - will first check to see if the character under the | |
509 | reading cursor is a space and if say_word_ctl is true it will | |
510 | return the word space. If say_word_ctl is not set it will check to | |
511 | see if there is a word starting on the next position to the right | |
512 | and return that word if it exists. If it does not exist it will | |
513 | move left to the beginning of any previous word on the line or the | |
514 | beginning off the line whichever comes first.. */ | |
515 | ||
516 | static u_long get_word(struct vc_data *vc) | |
517 | { | |
518 | u_long cnt = 0, tmpx = spk_x, tmp_pos = spk_pos; | |
519 | char ch; | |
520 | u_short attr_ch; | |
521 | u_char temp; | |
522 | spk_old_attr = spk_attr; | |
523 | ch = (char) get_char(vc, (u_short *) tmp_pos, &temp); | |
524 | ||
525 | /* decided to take out the sayword if on a space (mis-information */ | |
526 | if (say_word_ctl && ch == SPACE) { | |
527 | *buf = '\0'; | |
528 | synth_printf("%s\n", msg_get(MSG_SPACE)); | |
529 | return 0; | |
530 | } else if ((tmpx < vc->vc_cols - 2) | |
531 | && (ch == SPACE || ch == 0 || IS_WDLM(ch)) | |
532 | && ((char) get_char(vc, (u_short *) &tmp_pos+1, &temp) > SPACE)) { | |
533 | tmp_pos += 2; | |
534 | tmpx++; | |
535 | } else | |
536 | while (tmpx > 0) { | |
537 | ch = (char) get_char(vc, (u_short *) tmp_pos - 1, &temp); | |
538 | if ((ch == SPACE || ch == 0 || IS_WDLM(ch)) | |
539 | && ((char) get_char(vc, (u_short *) tmp_pos, &temp) > | |
540 | SPACE)) | |
541 | break; | |
542 | tmp_pos -= 2; | |
543 | tmpx--; | |
544 | } | |
545 | attr_ch = get_char(vc, (u_short *) tmp_pos, &spk_attr); | |
546 | buf[cnt++] = attr_ch & 0xff; | |
547 | while (tmpx < vc->vc_cols - 1) { | |
548 | tmp_pos += 2; | |
549 | tmpx++; | |
550 | ch = (char) get_char(vc, (u_short *) tmp_pos, &temp); | |
551 | if ((ch == SPACE) || ch == 0 || (IS_WDLM(buf[cnt-1]) && (ch > SPACE))) | |
552 | break; | |
553 | buf[cnt++] = ch; | |
554 | } | |
555 | buf[cnt] = '\0'; | |
556 | return cnt; | |
557 | } | |
558 | ||
559 | static void say_word(struct vc_data *vc) | |
560 | { | |
561 | u_long cnt = get_word(vc); | |
562 | u_short saved_punc_mask = punc_mask; | |
563 | if (cnt == 0) | |
564 | return; | |
565 | punc_mask = PUNC; | |
566 | buf[cnt++] = SPACE; | |
567 | spkup_write(buf, cnt); | |
568 | punc_mask = saved_punc_mask; | |
569 | } | |
570 | ||
571 | static void say_prev_word(struct vc_data *vc) | |
572 | { | |
573 | u_char temp; | |
574 | char ch; | |
575 | u_short edge_said = 0, last_state = 0, state = 0; | |
576 | spk_parked |= 0x01; | |
577 | ||
578 | if (spk_x == 0) { | |
579 | if (spk_y == 0) { | |
580 | announce_edge(vc, edge_top); | |
581 | return; | |
582 | } | |
583 | spk_y--; | |
584 | spk_x = vc->vc_cols; | |
585 | edge_said = edge_quiet; | |
586 | } | |
587 | while (1) { | |
588 | if (spk_x == 0) { | |
589 | if (spk_y == 0) { | |
590 | edge_said = edge_top; | |
591 | break; | |
592 | } | |
593 | if (edge_said != edge_quiet) | |
594 | edge_said = edge_left; | |
595 | if (state > 0) | |
596 | break; | |
597 | spk_y--; | |
598 | spk_x = vc->vc_cols - 1; | |
599 | } else | |
600 | spk_x--; | |
601 | spk_pos -= 2; | |
602 | ch = (char) get_char(vc, (u_short *) spk_pos, &temp); | |
603 | if (ch == SPACE || ch == 0) | |
604 | state = 0; | |
605 | else if (IS_WDLM(ch)) | |
606 | state = 1; | |
607 | else | |
608 | state = 2; | |
609 | if (state < last_state) { | |
610 | spk_pos += 2; | |
611 | spk_x++; | |
612 | break; | |
613 | } | |
614 | last_state = state; | |
615 | } | |
616 | if (spk_x == 0 && edge_said == edge_quiet) | |
617 | edge_said = edge_left; | |
618 | if (edge_said > 0 && edge_said < edge_quiet) | |
619 | announce_edge(vc, edge_said); | |
620 | say_word(vc); | |
621 | } | |
622 | ||
623 | static void say_next_word(struct vc_data *vc) | |
624 | { | |
625 | u_char temp; | |
626 | char ch; | |
627 | u_short edge_said = 0, last_state = 2, state = 0; | |
628 | spk_parked |= 0x01; | |
629 | ||
630 | if (spk_x == vc->vc_cols - 1 && spk_y == vc->vc_rows - 1) { | |
631 | announce_edge(vc, edge_bottom); | |
632 | return; | |
633 | } | |
634 | while (1) { | |
635 | ch = (char) get_char(vc, (u_short *) spk_pos, &temp); | |
636 | if (ch == SPACE || ch == 0) | |
637 | state = 0; | |
638 | else if (IS_WDLM(ch)) | |
639 | state = 1; | |
640 | else | |
641 | state = 2; | |
642 | if (state > last_state) | |
643 | break; | |
644 | if (spk_x >= vc->vc_cols - 1) { | |
645 | if (spk_y == vc->vc_rows - 1) { | |
646 | edge_said = edge_bottom; | |
647 | break; | |
648 | } | |
649 | state = 0; | |
650 | spk_y++; | |
651 | spk_x = 0; | |
652 | edge_said = edge_right; | |
653 | } else | |
654 | spk_x++; | |
655 | spk_pos += 2; | |
656 | last_state = state; | |
657 | } | |
658 | if (edge_said > 0) | |
659 | announce_edge(vc, edge_said); | |
660 | say_word(vc); | |
661 | } | |
662 | ||
663 | static void spell_word(struct vc_data *vc) | |
664 | { | |
665 | static char *delay_str[] = { "", ",", ".", ". .", ". . ." }; | |
666 | char *cp = buf, *str_cap = str_caps_stop; | |
667 | char *cp1, *last_cap = str_caps_stop; | |
668 | u_char ch; | |
669 | if (!get_word(vc)) | |
670 | return; | |
671 | while ((ch = (u_char) *cp)) { | |
672 | if (cp != buf) | |
673 | synth_printf(" %s ", delay_str[spell_delay]); | |
674 | if (IS_CHAR(ch, B_CAP)) { | |
675 | str_cap = str_caps_start; | |
676 | if (*str_caps_stop) | |
677 | pitch_shift++; | |
678 | else /* synth has no pitch */ | |
679 | last_cap = str_caps_stop; | |
680 | } else | |
681 | str_cap = str_caps_stop; | |
682 | if (str_cap != last_cap) { | |
683 | synth_printf("%s", str_cap); | |
684 | last_cap = str_cap; | |
685 | } | |
686 | if (this_speakup_key == SPELL_PHONETIC | |
687 | && (isascii(ch) && isalpha(ch))) { | |
688 | ch &= 31; | |
689 | cp1 = phonetic[--ch]; | |
690 | } else { | |
691 | cp1 = characters[ch]; | |
692 | if (*cp1 == '^') { | |
693 | synth_printf("%s", msg_get(MSG_CTRL)); | |
694 | cp1++; | |
695 | } | |
696 | } | |
697 | synth_printf("%s", cp1); | |
698 | cp++; | |
699 | } | |
700 | if (str_cap != str_caps_stop) | |
701 | synth_printf("%s", str_caps_stop); | |
702 | } | |
703 | ||
704 | static int get_line(struct vc_data *vc) | |
705 | { | |
706 | u_long tmp = spk_pos - (spk_x * 2); | |
707 | int i = 0; | |
708 | u_char tmp2; | |
709 | ||
710 | spk_old_attr = spk_attr; | |
711 | spk_attr = get_attributes((u_short *) spk_pos); | |
712 | for (i = 0; i < vc->vc_cols; i++) { | |
713 | buf[i] = (u_char) get_char(vc, (u_short *) tmp, &tmp2); | |
714 | tmp += 2; | |
715 | } | |
716 | for (--i; i >= 0; i--) | |
717 | if (buf[i] != SPACE) | |
718 | break; | |
719 | return ++i; | |
720 | } | |
721 | ||
722 | static void say_line(struct vc_data *vc) | |
723 | { | |
724 | int i = get_line(vc); | |
725 | char *cp; | |
726 | u_short saved_punc_mask = punc_mask; | |
727 | if (i == 0) { | |
728 | synth_printf("%s\n", msg_get(MSG_BLANK)); | |
729 | return; | |
730 | } | |
731 | buf[i++] = '\n'; | |
732 | if (this_speakup_key == SAY_LINE_INDENT) { | |
733 | for (cp = buf; *cp == SPACE; cp++) | |
734 | ; | |
735 | synth_printf("%d, ", (cp - buf) + 1); | |
736 | } | |
737 | punc_mask = punc_masks[reading_punc]; | |
738 | spkup_write(buf, i); | |
739 | punc_mask = saved_punc_mask; | |
740 | } | |
741 | ||
742 | static void say_prev_line(struct vc_data *vc) | |
743 | { | |
744 | spk_parked |= 0x01; | |
745 | if (spk_y == 0) { | |
746 | announce_edge(vc, edge_top); | |
747 | return; | |
748 | } | |
749 | spk_y--; | |
750 | spk_pos -= vc->vc_size_row; | |
751 | say_line(vc); | |
752 | } | |
753 | ||
754 | static void say_next_line(struct vc_data *vc) | |
755 | { | |
756 | spk_parked |= 0x01; | |
757 | if (spk_y == vc->vc_rows - 1) { | |
758 | announce_edge(vc, edge_bottom); | |
759 | return; | |
760 | } | |
761 | spk_y++; | |
762 | spk_pos += vc->vc_size_row; | |
763 | say_line(vc); | |
764 | } | |
765 | ||
766 | static int say_from_to(struct vc_data *vc, u_long from, u_long to, | |
767 | int read_punc) | |
768 | { | |
769 | int i = 0; | |
770 | u_char tmp; | |
771 | u_short saved_punc_mask = punc_mask; | |
772 | spk_old_attr = spk_attr; | |
773 | spk_attr = get_attributes((u_short *) from); | |
774 | while (from < to) { | |
775 | buf[i++] = (char) get_char(vc, (u_short *) from, &tmp); | |
776 | from += 2; | |
777 | if (i >= vc->vc_size_row) | |
778 | break; | |
779 | } | |
780 | for (--i; i >= 0; i--) | |
781 | if (buf[i] != SPACE) | |
782 | break; | |
783 | buf[++i] = SPACE; | |
784 | buf[++i] = '\0'; | |
785 | if (i < 1) | |
786 | return i; | |
787 | if (read_punc) | |
788 | punc_mask = punc_info[reading_punc].mask; | |
789 | spkup_write(buf, i); | |
790 | if (read_punc) | |
791 | punc_mask = saved_punc_mask; | |
792 | return i - 1; | |
793 | } | |
794 | ||
795 | static void say_line_from_to(struct vc_data *vc, u_long from, u_long to, | |
796 | int read_punc) | |
797 | { | |
798 | u_long start = vc->vc_origin + (spk_y * vc->vc_size_row); | |
799 | u_long end = start + (to * 2); | |
800 | start += from * 2; | |
801 | if (say_from_to(vc, start, end, read_punc) <= 0) | |
802 | if (cursor_track != read_all_mode) | |
803 | synth_printf("%s\n", msg_get(MSG_BLANK)); | |
804 | } | |
805 | ||
806 | /* Sentence Reading Commands */ | |
807 | ||
808 | void synth_insert_next_index(int); | |
809 | ||
810 | static int currsentence; | |
811 | static int numsentences[2]; | |
812 | static char *sentbufend[2]; | |
813 | static char *sentmarks[2][10]; | |
814 | static int currbuf; | |
815 | static int bn; | |
816 | static char sentbuf[2][256]; | |
817 | ||
818 | static int say_sentence_num(int num , int prev) | |
819 | { | |
820 | bn = currbuf; | |
821 | currsentence = num + 1; | |
822 | if (prev && --bn == -1) | |
823 | bn = 1; | |
824 | ||
825 | if (num > numsentences[bn]) | |
826 | return 0; | |
827 | ||
828 | spkup_write(sentmarks[bn][num], sentbufend[bn] - sentmarks[bn][num]); | |
829 | return 1; | |
830 | } | |
831 | ||
832 | static int get_sentence_buf(struct vc_data *vc, int read_punc) | |
833 | { | |
834 | u_long start, end; | |
835 | int i, bn; | |
836 | u_char tmp; | |
837 | ||
838 | currbuf++; | |
839 | if (currbuf == 2) | |
840 | currbuf = 0; | |
841 | bn = currbuf; | |
842 | start = vc->vc_origin + ((spk_y) * vc->vc_size_row); | |
843 | end = vc->vc_origin+((spk_y) * vc->vc_size_row) + vc->vc_cols * 2; | |
844 | ||
845 | numsentences[bn] = 0; | |
846 | sentmarks[bn][0] = &sentbuf[bn][0]; | |
847 | i = 0; | |
848 | spk_old_attr = spk_attr; | |
849 | spk_attr = get_attributes((u_short *) start); | |
850 | ||
851 | while (start < end) { | |
852 | sentbuf[bn][i] = (char) get_char(vc, (u_short *) start, &tmp); | |
853 | if (i > 0) { | |
854 | if (sentbuf[bn][i] == SPACE && sentbuf[bn][i-1] == '.' | |
855 | && numsentences[bn] < 9) { | |
856 | /* Sentence Marker */ | |
857 | numsentences[bn]++; | |
858 | sentmarks[bn][numsentences[bn]] = | |
859 | &sentbuf[bn][i]; | |
860 | } | |
861 | } | |
862 | i++; | |
863 | start += 2; | |
864 | if (i >= vc->vc_size_row) | |
865 | break; | |
866 | } | |
867 | ||
868 | for (--i; i >= 0; i--) | |
869 | if (sentbuf[bn][i] != SPACE) | |
870 | break; | |
871 | ||
872 | if (i < 1) | |
873 | return -1; | |
874 | ||
875 | sentbuf[bn][++i] = SPACE; | |
876 | sentbuf[bn][++i] = '\0'; | |
877 | ||
878 | sentbufend[bn] = &sentbuf[bn][i]; | |
879 | return numsentences[bn]; | |
880 | } | |
881 | ||
882 | static void say_screen_from_to(struct vc_data *vc, u_long from, u_long to) | |
883 | { | |
884 | u_long start = vc->vc_origin, end; | |
885 | if (from > 0) | |
886 | start += from * vc->vc_size_row; | |
887 | if (to > vc->vc_rows) | |
888 | to = vc->vc_rows; | |
889 | end = vc->vc_origin + (to * vc->vc_size_row); | |
890 | for (from = start; from < end; from = to) { | |
891 | to = from + vc->vc_size_row; | |
892 | say_from_to(vc, from, to, 1); | |
893 | } | |
894 | } | |
895 | ||
896 | static void say_screen(struct vc_data *vc) | |
897 | { | |
898 | say_screen_from_to(vc, 0, vc->vc_rows); | |
899 | } | |
900 | ||
901 | static void speakup_win_say(struct vc_data *vc) | |
902 | { | |
903 | u_long start, end, from, to; | |
904 | if (win_start < 2) { | |
905 | synth_printf("%s\n", msg_get(MSG_NO_WINDOW)); | |
906 | return; | |
907 | } | |
908 | start = vc->vc_origin + (win_top * vc->vc_size_row); | |
909 | end = vc->vc_origin + (win_bottom * vc->vc_size_row); | |
910 | while (start <= end) { | |
911 | from = start + (win_left * 2); | |
912 | to = start + (win_right * 2); | |
913 | say_from_to(vc, from, to, 1); | |
914 | start += vc->vc_size_row; | |
915 | } | |
916 | } | |
917 | ||
918 | static void top_edge(struct vc_data *vc) | |
919 | { | |
920 | spk_parked |= 0x01; | |
921 | spk_pos = vc->vc_origin + 2 * spk_x; | |
922 | spk_y = 0; | |
923 | say_line(vc); | |
924 | } | |
925 | ||
926 | static void bottom_edge(struct vc_data *vc) | |
927 | { | |
928 | spk_parked |= 0x01; | |
929 | spk_pos += (vc->vc_rows - spk_y - 1) * vc->vc_size_row; | |
930 | spk_y = vc->vc_rows - 1; | |
931 | say_line(vc); | |
932 | } | |
933 | ||
934 | static void left_edge(struct vc_data *vc) | |
935 | { | |
936 | spk_parked |= 0x01; | |
937 | spk_pos -= spk_x * 2; | |
938 | spk_x = 0; | |
939 | say_char(vc); | |
940 | } | |
941 | ||
942 | static void right_edge(struct vc_data *vc) | |
943 | { | |
944 | spk_parked |= 0x01; | |
945 | spk_pos += (vc->vc_cols - spk_x - 1) * 2; | |
946 | spk_x = vc->vc_cols - 1; | |
947 | say_char(vc); | |
948 | } | |
949 | ||
950 | static void say_first_char(struct vc_data *vc) | |
951 | { | |
952 | int i, len = get_line(vc); | |
953 | u_char ch; | |
954 | spk_parked |= 0x01; | |
955 | if (len == 0) { | |
956 | synth_printf("%s\n", msg_get(MSG_BLANK)); | |
957 | return; | |
958 | } | |
959 | for (i = 0; i < len; i++) | |
960 | if (buf[i] != SPACE) | |
961 | break; | |
962 | ch = buf[i]; | |
963 | spk_pos -= (spk_x - i) * 2; | |
964 | spk_x = i; | |
965 | synth_printf("%d, ", ++i); | |
966 | speak_char(ch); | |
967 | } | |
968 | ||
969 | static void say_last_char(struct vc_data *vc) | |
970 | { | |
971 | int len = get_line(vc); | |
972 | u_char ch; | |
973 | spk_parked |= 0x01; | |
974 | if (len == 0) { | |
975 | synth_printf("%s\n", msg_get(MSG_BLANK)); | |
976 | return; | |
977 | } | |
978 | ch = buf[--len]; | |
979 | spk_pos -= (spk_x - len) * 2; | |
980 | spk_x = len; | |
981 | synth_printf("%d, ", ++len); | |
982 | speak_char(ch); | |
983 | } | |
984 | ||
985 | static void say_position(struct vc_data *vc) | |
986 | { | |
987 | synth_printf(msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1, | |
988 | vc->vc_num + 1); | |
989 | synth_printf("\n"); | |
990 | } | |
991 | ||
992 | /* Added by brianb */ | |
993 | static void say_char_num(struct vc_data *vc) | |
994 | { | |
995 | u_char tmp; | |
996 | u_short ch = get_char(vc, (u_short *) spk_pos, &tmp); | |
997 | ch &= 0xff; | |
998 | synth_printf(msg_get(MSG_CHAR_INFO), ch, ch); | |
999 | } | |
1000 | ||
1001 | /* these are stub functions to keep keyboard.c happy. */ | |
1002 | ||
1003 | static void say_from_top(struct vc_data *vc) | |
1004 | { | |
1005 | say_screen_from_to(vc, 0, spk_y); | |
1006 | } | |
1007 | ||
1008 | static void say_to_bottom(struct vc_data *vc) | |
1009 | { | |
1010 | say_screen_from_to(vc, spk_y, vc->vc_rows); | |
1011 | } | |
1012 | ||
1013 | static void say_from_left(struct vc_data *vc) | |
1014 | { | |
1015 | say_line_from_to(vc, 0, spk_x, 1); | |
1016 | } | |
1017 | ||
1018 | static void say_to_right(struct vc_data *vc) | |
1019 | { | |
1020 | say_line_from_to(vc, spk_x, vc->vc_cols, 1); | |
1021 | } | |
1022 | ||
1023 | /* end of stub functions. */ | |
1024 | ||
1025 | static void spkup_write(const char *in_buf, int count) | |
1026 | { | |
1027 | static int rep_count = 0; | |
1028 | static u_char ch = '\0', old_ch = '\0'; | |
1029 | static u_short char_type = 0, last_type = 0; | |
1030 | int in_count = count; | |
1031 | spk_keydown = 0; | |
1032 | while (count--) { | |
1033 | if (cursor_track == read_all_mode) { | |
1034 | /* Insert Sentence Index */ | |
1035 | if ((in_buf == sentmarks[bn][currsentence]) && | |
1036 | (currsentence <= numsentences[bn])) | |
1037 | synth_insert_next_index(currsentence++); | |
1038 | } | |
1039 | ch = (u_char)*in_buf++; | |
1040 | char_type = spk_chartab[ch]; | |
1041 | if (ch == old_ch && !(char_type&B_NUM)) { | |
1042 | if (++rep_count > 2) | |
1043 | continue; | |
1044 | } else { | |
1045 | if ((last_type&CH_RPT) && rep_count > 2) { | |
1046 | synth_printf(" "); | |
1047 | synth_printf(msg_get(MSG_REPEAT_DESC), ++rep_count); | |
1048 | synth_printf(" "); | |
1049 | } | |
1050 | rep_count = 0; | |
1051 | } | |
1052 | if (ch == spk_lastkey) { | |
1053 | rep_count = 0; | |
1054 | if (key_echo == 1 && ch >= MINECHOCHAR) | |
1055 | speak_char(ch); | |
1056 | } else if (char_type & B_ALPHA) { | |
1057 | if ((synth_flags & SF_DEC) && (last_type & PUNC)) | |
1058 | synth_buffer_add(SPACE); | |
1059 | synth_printf("%c", ch); | |
1060 | } else if (char_type & B_NUM) { | |
1061 | rep_count = 0; | |
1062 | synth_printf("%c", ch); | |
1063 | } else if (char_type&punc_mask) { | |
1064 | speak_char(ch); | |
1065 | char_type &= ~PUNC; /* for dec nospell processing */ | |
1066 | } else if (char_type&SYNTH_OK) { | |
1067 | /* these are usually puncts like . and , which synth needs for expression. | |
1068 | * suppress multiple to get rid of long pausesand clear repeat count so if | |
1069 | *someone has repeats on you don't get nothing repeated count */ | |
1070 | if (ch != old_ch) | |
1071 | synth_printf("%c", ch); | |
1072 | else | |
1073 | rep_count = 0; | |
1074 | } else { | |
1075 | /* send space and record position, if next is num overwrite space */ | |
1076 | if (old_ch != ch) | |
1077 | synth_buffer_add(SPACE); | |
1078 | else | |
1079 | rep_count = 0; | |
1080 | } | |
1081 | old_ch = ch; | |
1082 | last_type = char_type; | |
1083 | } | |
1084 | spk_lastkey = 0; | |
1085 | if (in_count > 2 && rep_count > 2) { | |
1086 | if (last_type&CH_RPT) { | |
1087 | synth_printf(" "); | |
1088 | synth_printf(msg_get(MSG_REPEAT_DESC2), ++rep_count); | |
1089 | synth_printf(" "); | |
1090 | } | |
1091 | rep_count = 0; | |
1092 | } | |
1093 | } | |
1094 | ||
1095 | static const int NUM_CTL_LABELS = (MSG_CTL_END - MSG_CTL_START + 1); | |
1096 | ||
1097 | static void read_all_doc(struct vc_data *vc); | |
1098 | static void cursor_done(u_long data); | |
1099 | static DEFINE_TIMER(cursor_timer, cursor_done, 0, 0); | |
1100 | ||
1101 | static void do_handle_shift(struct vc_data *vc, u_char value, char up_flag) | |
1102 | { | |
1103 | unsigned long flags; | |
1104 | if (synth == NULL || up_flag || spk_killed) | |
1105 | return; | |
1106 | spk_lock(flags); | |
1107 | if (cursor_track == read_all_mode) { | |
1108 | switch (value) { | |
1109 | case KVAL(K_SHIFT): | |
1110 | del_timer(&cursor_timer); | |
1111 | spk_shut_up &= 0xfe; | |
1112 | do_flush(); | |
1113 | read_all_doc(vc); | |
1114 | break; | |
1115 | case KVAL(K_CTRL): | |
1116 | del_timer(&cursor_timer); | |
1117 | cursor_track = prev_cursor_track; | |
1118 | spk_shut_up &= 0xfe; | |
1119 | do_flush(); | |
1120 | break; | |
1121 | } | |
1122 | } else { | |
1123 | spk_shut_up &= 0xfe; | |
1124 | do_flush(); | |
1125 | } | |
1126 | if (say_ctrl && value < NUM_CTL_LABELS) | |
1127 | synth_printf("%s", msg_get(MSG_CTL_START + value)); | |
1128 | spk_unlock(flags); | |
1129 | } | |
1130 | ||
1131 | static void do_handle_latin(struct vc_data *vc, u_char value, char up_flag) | |
1132 | { | |
1133 | unsigned long flags; | |
1134 | spk_lock(flags); | |
1135 | if (up_flag) { | |
1136 | spk_lastkey = spk_keydown = 0; | |
1137 | spk_unlock(flags); | |
1138 | return; | |
1139 | } | |
1140 | if (synth == NULL || spk_killed) { | |
1141 | spk_unlock(flags); | |
1142 | return; | |
1143 | } | |
1144 | spk_shut_up &= 0xfe; | |
1145 | spk_lastkey = value; | |
1146 | spk_keydown++; | |
1147 | spk_parked &= 0xfe; | |
1148 | if (key_echo == 2 && value >= MINECHOCHAR) | |
1149 | speak_char(value); | |
1150 | spk_unlock(flags); | |
1151 | } | |
1152 | ||
1153 | int set_key_info(const u_char *key_info, u_char *k_buffer) | |
1154 | { | |
1155 | int i = 0, states, key_data_len; | |
1156 | const u_char *cp = key_info; | |
1157 | u_char *cp1 = k_buffer; | |
1158 | u_char ch, version, num_keys; | |
1159 | version = *cp++; | |
1160 | if (version != KEY_MAP_VER) | |
1161 | return -1; | |
1162 | num_keys = *cp; | |
1163 | states = (int) cp[1]; | |
1164 | key_data_len = (states + 1) * (num_keys + 1); | |
1165 | if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(key_buf)) | |
1166 | return -2; | |
1167 | memset(k_buffer, 0, SHIFT_TBL_SIZE); | |
1168 | memset(our_keys, 0, sizeof(our_keys)); | |
1169 | shift_table = k_buffer; | |
1170 | our_keys[0] = shift_table; | |
1171 | cp1 += SHIFT_TBL_SIZE; | |
1172 | memcpy(cp1, cp, key_data_len + 3); | |
1173 | /* get num_keys, states and data*/ | |
1174 | cp1 += 2; /* now pointing at shift states */ | |
1175 | for (i = 1; i <= states; i++) { | |
1176 | ch = *cp1++; | |
1177 | if (ch >= SHIFT_TBL_SIZE) | |
1178 | return -3; | |
1179 | shift_table[ch] = i; | |
1180 | } | |
1181 | keymap_flags = *cp1++; | |
1182 | while ((ch = *cp1)) { | |
1183 | if (ch >= MAX_KEY) | |
1184 | return -4; | |
1185 | our_keys[ch] = cp1; | |
1186 | cp1 += states + 1; | |
1187 | } | |
1188 | return 0; | |
1189 | } | |
1190 | ||
1191 | static struct var_t spk_vars[] = { | |
1192 | /* bell must be first to set high limit */ | |
1193 | { BELL_POS, .u.n = {NULL, 0, 0, 0, 0, 0, NULL }}, | |
1194 | { SPELL_DELAY, .u.n = {NULL, 0, 0, 4, 0, 0, NULL }}, | |
1195 | { ATTRIB_BLEEP, .u.n = {NULL, 1, 0, 3, 0, 0, NULL }}, | |
1196 | { BLEEPS, .u.n = {NULL, 3, 0, 3, 0, 0, NULL }}, | |
1197 | { BLEEP_TIME, .u.n = {NULL, 30, 1, 200, 0, 0, NULL }}, | |
1198 | { PUNC_LEVEL, .u.n = {NULL, 1, 0, 4, 0, 0, NULL }}, | |
1199 | { READING_PUNC, .u.n = {NULL, 1, 0, 4, 0, 0, NULL }}, | |
1200 | { CURSOR_TIME, .u.n = {NULL, 120, 50, 600, 0, 0, NULL }}, | |
1201 | { SAY_CONTROL, TOGGLE_0 }, | |
1202 | { SAY_WORD_CTL, TOGGLE_0 }, | |
1203 | { NO_INTERRUPT, TOGGLE_0 }, | |
1204 | { KEY_ECHO, .u.n = {NULL, 1, 0, 2, 0, 0, NULL }}, | |
1205 | V_LAST_VAR | |
1206 | }; | |
1207 | ||
1208 | ||
1209 | static void toggle_cursoring(struct vc_data *vc) | |
1210 | { | |
1211 | if (cursor_track == read_all_mode) | |
1212 | cursor_track = prev_cursor_track; | |
1213 | if (++cursor_track >= CT_Max) | |
1214 | cursor_track = 0; | |
1215 | synth_printf("%s\n", msg_get(MSG_CURSOR_MSGS_START + cursor_track)); | |
1216 | } | |
1217 | ||
1218 | void reset_default_chars(void) | |
1219 | { | |
1220 | int i; | |
1221 | ||
1222 | /* First, free any non-default */ | |
1223 | for (i = 0; i < 256; i++) { | |
1224 | if ((characters[i] != NULL) | |
1225 | && (characters[i] != default_chars[i])) | |
1226 | kfree(characters[i]); | |
1227 | } | |
1228 | ||
1229 | memcpy(characters, default_chars, sizeof(default_chars)); | |
1230 | } | |
1231 | ||
1232 | void reset_default_chartab(void) | |
1233 | { | |
1234 | memcpy(spk_chartab, default_chartab, sizeof(default_chartab)); | |
1235 | } | |
1236 | ||
1237 | static const struct st_bits_data *pb_edit = NULL; | |
1238 | ||
1239 | static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key) | |
1240 | { | |
1241 | short mask = pb_edit->mask, ch_type = spk_chartab[ch]; | |
1242 | if (type != KT_LATIN || (ch_type&B_NUM) || ch < SPACE) | |
1243 | return -1; | |
1244 | if (ch == SPACE) { | |
1245 | synth_printf("%s\n", msg_get(MSG_EDIT_DONE)); | |
1246 | special_handler = NULL; | |
1247 | return 1; | |
1248 | } | |
1249 | if (mask < PUNC && !(ch_type&PUNC)) | |
1250 | return -1; | |
1251 | spk_chartab[ch] ^= mask; | |
1252 | speak_char(ch); | |
1253 | synth_printf(" %s\n", | |
1254 | (spk_chartab[ch]&mask) ? msg_get(MSG_ON) : msg_get(MSG_OFF)); | |
1255 | return 1; | |
1256 | } | |
1257 | ||
1258 | /* Allocation concurrency is protected by the console semaphore */ | |
1259 | void speakup_allocate(struct vc_data *vc) | |
1260 | { | |
1261 | int vc_num; | |
1262 | ||
1263 | vc_num = vc->vc_num; | |
1264 | if (speakup_console[vc_num] == NULL) { | |
1265 | speakup_console[vc_num] = kzalloc(sizeof(*speakup_console[0]), | |
1266 | GFP_ATOMIC); | |
1267 | if (speakup_console[vc_num] == NULL) | |
1268 | return; | |
1269 | speakup_date(vc); | |
1270 | } else if (!spk_parked) | |
1271 | speakup_date(vc); | |
1272 | } | |
1273 | ||
1274 | void speakup_deallocate(struct vc_data *vc) | |
1275 | { | |
1276 | int vc_num; | |
1277 | ||
1278 | vc_num = vc->vc_num; | |
1279 | if (speakup_console[vc_num] != NULL) { | |
1280 | kfree(speakup_console[vc_num]); | |
1281 | speakup_console[vc_num] = NULL; | |
1282 | } | |
1283 | } | |
1284 | ||
1285 | static u_char is_cursor; | |
1286 | static u_long old_cursor_pos, old_cursor_x, old_cursor_y; | |
1287 | static int cursor_con; | |
1288 | ||
1289 | static void reset_highlight_buffers(struct vc_data *); | |
1290 | ||
1291 | static int read_all_key; | |
1292 | ||
1293 | void reset_index_count(int); | |
1294 | void get_index_count(int *, int *); | |
1295 | /*int synth_supports_indexing(void); */ | |
1296 | static void start_read_all_timer(struct vc_data *vc, int command); | |
1297 | ||
1298 | enum { | |
1299 | RA_NOTHING, | |
1300 | RA_NEXT_SENT, | |
1301 | RA_PREV_LINE, | |
1302 | RA_NEXT_LINE, | |
1303 | RA_PREV_SENT, | |
1304 | RA_DOWN_ARROW, | |
1305 | RA_TIMER, | |
1306 | RA_FIND_NEXT_SENT, | |
1307 | RA_FIND_PREV_SENT, | |
1308 | }; | |
1309 | ||
1310 | static void | |
1311 | kbd_fakekey2(struct vc_data *vc, int command) | |
1312 | { | |
1313 | del_timer(&cursor_timer); | |
1314 | speakup_fake_down_arrow(); | |
1315 | start_read_all_timer(vc, command); | |
1316 | } | |
1317 | ||
1318 | static void | |
1319 | read_all_doc(struct vc_data *vc) | |
1320 | { | |
1321 | if ((vc->vc_num != fg_console) || synth == NULL || spk_shut_up) | |
1322 | return; | |
1323 | if (!synth_supports_indexing()) | |
1324 | return; | |
1325 | if (cursor_track != read_all_mode) | |
1326 | prev_cursor_track = cursor_track; | |
1327 | cursor_track = read_all_mode; | |
1328 | reset_index_count(0); | |
1329 | if (get_sentence_buf(vc, 0) == -1) | |
1330 | kbd_fakekey2(vc, RA_DOWN_ARROW); | |
1331 | else { | |
1332 | say_sentence_num(0, 0); | |
1333 | synth_insert_next_index(0); | |
1334 | start_read_all_timer(vc, RA_TIMER); | |
1335 | } | |
1336 | } | |
1337 | ||
1338 | static void | |
1339 | stop_read_all(struct vc_data *vc) | |
1340 | { | |
1341 | del_timer(&cursor_timer); | |
1342 | cursor_track = prev_cursor_track; | |
1343 | spk_shut_up &= 0xfe; | |
1344 | do_flush(); | |
1345 | } | |
1346 | ||
1347 | static void | |
1348 | start_read_all_timer(struct vc_data *vc, int command) | |
1349 | { | |
1350 | struct var_t *cursor_timeout; | |
1351 | ||
1352 | cursor_con = vc->vc_num; | |
1353 | read_all_key = command; | |
1354 | cursor_timeout = get_var(CURSOR_TIME); | |
1355 | mod_timer(&cursor_timer, jiffies + msecs_to_jiffies(cursor_timeout->u.n.value)); | |
1356 | } | |
1357 | ||
1358 | static void | |
1359 | handle_cursor_read_all(struct vc_data *vc, int command) | |
1360 | { | |
1361 | int indcount, sentcount, rv, sn; | |
1362 | ||
1363 | switch (command) { | |
1364 | case RA_NEXT_SENT: | |
1365 | /* Get Current Sentence */ | |
1366 | get_index_count(&indcount, &sentcount); | |
1367 | /*printk("%d %d ", indcount, sentcount); */ | |
1368 | reset_index_count(sentcount+1); | |
1369 | if (indcount == 1) { | |
1370 | if (!say_sentence_num(sentcount+1, 0)) { | |
1371 | kbd_fakekey2(vc, RA_FIND_NEXT_SENT); | |
1372 | return; | |
1373 | } | |
1374 | synth_insert_next_index(0); | |
1375 | } else { | |
1376 | sn = 0; | |
1377 | if (!say_sentence_num(sentcount+1, 1)) { | |
1378 | sn = 1; | |
1379 | reset_index_count(sn); | |
1380 | } else | |
1381 | synth_insert_next_index(0); | |
1382 | if (!say_sentence_num(sn, 0)) { | |
1383 | kbd_fakekey2(vc, RA_FIND_NEXT_SENT); | |
1384 | return; | |
1385 | } | |
1386 | synth_insert_next_index(0); | |
1387 | } | |
1388 | start_read_all_timer(vc, RA_TIMER); | |
1389 | break; | |
1390 | case RA_PREV_SENT: | |
1391 | break; | |
1392 | case RA_NEXT_LINE: | |
1393 | read_all_doc(vc); | |
1394 | break; | |
1395 | case RA_PREV_LINE: | |
1396 | break; | |
1397 | case RA_DOWN_ARROW: | |
1398 | if (get_sentence_buf(vc, 0) == -1) { | |
1399 | kbd_fakekey2(vc, RA_DOWN_ARROW); | |
1400 | } else { | |
1401 | say_sentence_num(0, 0); | |
1402 | synth_insert_next_index(0); | |
1403 | start_read_all_timer(vc, RA_TIMER); | |
1404 | } | |
1405 | break; | |
1406 | case RA_FIND_NEXT_SENT: | |
1407 | rv = get_sentence_buf(vc, 0); | |
1408 | if (rv == -1) | |
1409 | read_all_doc(vc); | |
1410 | if (rv == 0) | |
1411 | kbd_fakekey2(vc, RA_FIND_NEXT_SENT); | |
1412 | else { | |
1413 | say_sentence_num(1, 0); | |
1414 | synth_insert_next_index(0); | |
1415 | start_read_all_timer(vc, RA_TIMER); | |
1416 | } | |
1417 | break; | |
1418 | case RA_FIND_PREV_SENT: | |
1419 | break; | |
1420 | case RA_TIMER: | |
1421 | get_index_count(&indcount, &sentcount); | |
1422 | if (indcount < 2) | |
1423 | kbd_fakekey2(vc, RA_DOWN_ARROW); | |
1424 | else | |
1425 | start_read_all_timer(vc, RA_TIMER); | |
1426 | break; | |
1427 | } | |
1428 | } | |
1429 | ||
1430 | static int pre_handle_cursor(struct vc_data *vc, u_char value, char up_flag) | |
1431 | { | |
1432 | unsigned long flags; | |
1433 | spk_lock(flags); | |
1434 | if (cursor_track == read_all_mode) { | |
1435 | spk_parked &= 0xfe; | |
1436 | if (synth == NULL || up_flag || spk_shut_up) { | |
1437 | spk_unlock(flags); | |
1438 | return NOTIFY_STOP; | |
1439 | } | |
1440 | del_timer(&cursor_timer); | |
1441 | spk_shut_up &= 0xfe; | |
1442 | do_flush(); | |
1443 | start_read_all_timer(vc, value+1); | |
1444 | spk_unlock(flags); | |
1445 | return NOTIFY_STOP; | |
1446 | } | |
1447 | spk_unlock(flags); | |
1448 | return NOTIFY_OK; | |
1449 | } | |
1450 | ||
1451 | static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag) | |
1452 | { | |
1453 | unsigned long flags; | |
1454 | struct var_t *cursor_timeout; | |
1455 | ||
1456 | spk_lock(flags); | |
1457 | spk_parked &= 0xfe; | |
1458 | if (synth == NULL || up_flag || spk_shut_up || cursor_track == CT_Off) { | |
1459 | spk_unlock(flags); | |
1460 | return; | |
1461 | } | |
1462 | spk_shut_up &= 0xfe; | |
1463 | if (no_intr) | |
1464 | do_flush(); | |
1465 | /* the key press flushes if !no_inter but we want to flush on cursor | |
1466 | * moves regardless of no_inter state */ | |
1467 | is_cursor = value + 1; | |
1468 | old_cursor_pos = vc->vc_pos; | |
1469 | old_cursor_x = vc->vc_x; | |
1470 | old_cursor_y = vc->vc_y; | |
1471 | speakup_console[vc->vc_num]->ht.cy = vc->vc_y; | |
1472 | cursor_con = vc->vc_num; | |
1473 | if (cursor_track == CT_Highlight) | |
1474 | reset_highlight_buffers(vc); | |
1475 | cursor_timeout = get_var(CURSOR_TIME); | |
1476 | mod_timer(&cursor_timer, jiffies + msecs_to_jiffies(cursor_timeout->u.n.value)); | |
1477 | spk_unlock(flags); | |
1478 | } | |
1479 | ||
1480 | static void | |
1481 | update_color_buffer(struct vc_data *vc , const char *ic , int len) | |
1482 | { | |
1483 | int i, bi, hi; | |
1484 | int vc_num = vc->vc_num; | |
1485 | ||
1486 | bi = ((vc->vc_attr & 0x70) >> 4) ; | |
1487 | hi = speakup_console[vc_num]->ht.highsize[bi]; | |
1488 | ||
1489 | i = 0; | |
1490 | if (speakup_console[vc_num]->ht.highsize[bi] == 0) { | |
1491 | speakup_console[vc_num]->ht.rpos[bi] = vc->vc_pos; | |
1492 | speakup_console[vc_num]->ht.rx[bi] = vc->vc_x; | |
1493 | speakup_console[vc_num]->ht.ry[bi] = vc->vc_y; | |
1494 | } | |
1495 | while ((hi < COLOR_BUFFER_SIZE) && (i < len)) { | |
1496 | if ((ic[i] > 32) && (ic[i] < 127)) { | |
1497 | speakup_console[vc_num]->ht.highbuf[bi][hi] = ic[i]; | |
1498 | hi++; | |
1499 | } else if ((ic[i] == 32) && (hi != 0)) { | |
1500 | if (speakup_console[vc_num]->ht.highbuf[bi][hi-1] != | |
1501 | 32) { | |
1502 | speakup_console[vc_num]->ht.highbuf[bi][hi] = | |
1503 | ic[i]; | |
1504 | hi++; | |
1505 | } | |
1506 | } | |
1507 | i++; | |
1508 | } | |
1509 | speakup_console[vc_num]->ht.highsize[bi] = hi; | |
1510 | } | |
1511 | ||
1512 | static void | |
1513 | reset_highlight_buffers(struct vc_data *vc) | |
1514 | { | |
1515 | int i; | |
1516 | int vc_num = vc->vc_num; | |
1517 | for (i = 0 ; i < 8 ; i++) | |
1518 | speakup_console[vc_num]->ht.highsize[i] = 0; | |
1519 | } | |
1520 | ||
1521 | static int | |
1522 | count_highlight_color(struct vc_data *vc) | |
1523 | { | |
1524 | int i, bg; | |
1525 | int cc; | |
1526 | int vc_num = vc->vc_num; | |
1527 | u16 ch; | |
1528 | u16 *start = (u16 *) vc->vc_origin; | |
1529 | ||
1530 | for (i = 0; i < 8; i++) | |
1531 | speakup_console[vc_num]->ht.bgcount[i] = 0; | |
1532 | ||
1533 | for (i = 0; i < vc->vc_rows; i++) { | |
1534 | u16 *end = start + vc->vc_cols*2; | |
1535 | u16 *ptr; | |
1536 | for (ptr = start; ptr < end; ptr++) { | |
1537 | ch = get_attributes(ptr); | |
1538 | bg = (ch & 0x70) >> 4; | |
1539 | speakup_console[vc_num]->ht.bgcount[bg]++; | |
1540 | } | |
1541 | start += vc->vc_size_row; | |
1542 | } | |
1543 | ||
1544 | cc = 0; | |
1545 | for (i = 0; i < 8; i++) | |
1546 | if (speakup_console[vc_num]->ht.bgcount[i] > 0) | |
1547 | cc++; | |
1548 | return cc; | |
1549 | } | |
1550 | ||
1551 | static int | |
1552 | get_highlight_color(struct vc_data *vc) | |
1553 | { | |
1554 | int i, j; | |
1555 | unsigned int cptr[8], tmp; | |
1556 | int vc_num = vc->vc_num; | |
1557 | ||
1558 | for (i = 0; i < 8; i++) | |
1559 | cptr[i] = i; | |
1560 | ||
1561 | for (i = 0; i < 7; i++) | |
1562 | for (j = i + 1; j < 8; j++) | |
1563 | if (speakup_console[vc_num]->ht.bgcount[cptr[i]] > | |
1564 | speakup_console[vc_num]->ht.bgcount[cptr[j]]) { | |
1565 | tmp = cptr[i]; | |
1566 | cptr[i] = cptr[j]; | |
1567 | cptr[j] = tmp; | |
1568 | } | |
1569 | ||
1570 | for (i = 0; i < 8; i++) | |
1571 | if (speakup_console[vc_num]->ht.bgcount[cptr[i]] != 0) | |
1572 | if (speakup_console[vc_num]->ht.highsize[cptr[i]] > 0) | |
1573 | return cptr[i]; | |
1574 | return -1; | |
1575 | } | |
1576 | ||
1577 | static int | |
1578 | speak_highlight(struct vc_data *vc) | |
1579 | { | |
1580 | int hc, d; | |
1581 | int vc_num = vc->vc_num; | |
1582 | if (count_highlight_color(vc) == 1) | |
1583 | return 0; | |
1584 | hc = get_highlight_color(vc); | |
1585 | if (hc != -1) { | |
1586 | d = vc->vc_y-speakup_console[vc_num]->ht.cy; | |
1587 | if ((d == 1) || (d == -1)) | |
1588 | if (speakup_console[vc_num]->ht.ry[hc] != vc->vc_y) | |
1589 | return 0; | |
1590 | spk_parked |= 0x01; | |
1591 | do_flush(); | |
1592 | spkup_write(speakup_console[vc_num]->ht.highbuf[hc], | |
1593 | speakup_console[vc_num]->ht.highsize[hc]); | |
1594 | spk_pos = spk_cp = speakup_console[vc_num]->ht.rpos[hc]; | |
1595 | spk_x = spk_cx = speakup_console[vc_num]->ht.rx[hc]; | |
1596 | spk_y = spk_cy = speakup_console[vc_num]->ht.ry[hc]; | |
1597 | return 1; | |
1598 | } | |
1599 | return 0; | |
1600 | } | |
1601 | ||
1602 | static void | |
1603 | cursor_done(u_long data) | |
1604 | { | |
1605 | struct vc_data *vc = vc_cons[cursor_con].d; | |
1606 | unsigned long flags; | |
1607 | del_timer(&cursor_timer); | |
1608 | spk_lock(flags); | |
1609 | if (cursor_con != fg_console) { | |
1610 | is_cursor = 0; | |
1611 | goto out; | |
1612 | } | |
1613 | speakup_date(vc); | |
1614 | if (win_enabled) { | |
1615 | if (vc->vc_x >= win_left && vc->vc_x <= win_right && | |
1616 | vc->vc_y >= win_top && vc->vc_y <= win_bottom) { | |
1617 | spk_keydown = is_cursor = 0; | |
1618 | goto out; | |
1619 | } | |
1620 | } | |
1621 | if (cursor_track == read_all_mode) { | |
1622 | handle_cursor_read_all(vc, read_all_key); | |
1623 | goto out; | |
1624 | } | |
1625 | if (cursor_track == CT_Highlight) { | |
1626 | if (speak_highlight(vc)) { | |
1627 | spk_keydown = is_cursor = 0; | |
1628 | goto out; | |
1629 | } | |
1630 | } | |
1631 | if (cursor_track == CT_Window) | |
1632 | speakup_win_say(vc); | |
1633 | else if (is_cursor == 1 || is_cursor == 4) | |
1634 | say_line_from_to(vc, 0, vc->vc_cols, 0); | |
1635 | else | |
1636 | say_char(vc); | |
1637 | spk_keydown = is_cursor = 0; | |
1638 | out: | |
1639 | spk_unlock(flags); | |
1640 | } | |
1641 | ||
1642 | /* called by: vt_notifier_call() */ | |
1643 | static void speakup_bs(struct vc_data *vc) | |
1644 | { | |
1645 | unsigned long flags; | |
1646 | if (!speakup_console[vc->vc_num]) | |
1647 | return; | |
1648 | if (!spk_trylock(flags)) | |
1649 | /* Speakup output, discard */ | |
1650 | return; | |
1651 | if (!spk_parked) | |
1652 | speakup_date(vc); | |
1653 | if (spk_shut_up || synth == NULL) { | |
1654 | spk_unlock(flags); | |
1655 | return; | |
1656 | } | |
1657 | if (vc->vc_num == fg_console && spk_keydown) { | |
1658 | spk_keydown = 0; | |
1659 | if (!is_cursor) | |
1660 | say_char(vc); | |
1661 | } | |
1662 | spk_unlock(flags); | |
1663 | } | |
1664 | ||
1665 | /* called by: vt_notifier_call() */ | |
1666 | static void speakup_con_write(struct vc_data *vc, const char *str, int len) | |
1667 | { | |
1668 | unsigned long flags; | |
1669 | if ((vc->vc_num != fg_console) || spk_shut_up || synth == NULL) | |
1670 | return; | |
1671 | if (!spk_trylock(flags)) | |
1672 | /* Speakup output, discard */ | |
1673 | return; | |
1674 | if (bell_pos && spk_keydown && (vc->vc_x == bell_pos - 1)) | |
1675 | bleep(3); | |
1676 | if ((is_cursor) || (cursor_track == read_all_mode)) { | |
1677 | if (cursor_track == CT_Highlight) | |
1678 | update_color_buffer(vc, str, len); | |
1679 | spk_unlock(flags); | |
1680 | return; | |
1681 | } | |
1682 | if (win_enabled) { | |
1683 | if (vc->vc_x >= win_left && vc->vc_x <= win_right && | |
1684 | vc->vc_y >= win_top && vc->vc_y <= win_bottom) { | |
1685 | spk_unlock(flags); | |
1686 | return; | |
1687 | } | |
1688 | } | |
1689 | ||
1690 | spkup_write(str, len); | |
1691 | spk_unlock(flags); | |
1692 | } | |
1693 | ||
1694 | void | |
1695 | speakup_con_update(struct vc_data *vc) | |
1696 | { | |
1697 | unsigned long flags; | |
1698 | if (speakup_console[vc->vc_num] == NULL || spk_parked) | |
1699 | return; | |
1700 | if (!spk_trylock(flags)) | |
1701 | /* Speakup output, discard */ | |
1702 | return; | |
1703 | speakup_date(vc); | |
1704 | spk_unlock(flags); | |
1705 | } | |
1706 | ||
1707 | static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag) | |
1708 | { | |
1709 | unsigned long flags; | |
1710 | int on_off = 2; | |
1711 | char *label; | |
1712 | if (synth == NULL || up_flag || spk_killed) | |
1713 | return; | |
1714 | spk_lock(flags); | |
1715 | spk_shut_up &= 0xfe; | |
1716 | if (no_intr) | |
1717 | do_flush(); | |
1718 | switch (value) { | |
1719 | case KVAL(K_CAPS): | |
1720 | label = msg_get(MSG_KEYNAME_CAPSLOCK); | |
1721 | on_off = (vc_kbd_led(kbd_table + vc->vc_num, VC_CAPSLOCK)); | |
1722 | break; | |
1723 | case KVAL(K_NUM): | |
1724 | label = msg_get(MSG_KEYNAME_NUMLOCK); | |
1725 | on_off = (vc_kbd_led(kbd_table + vc->vc_num, VC_NUMLOCK)); | |
1726 | break; | |
1727 | case KVAL(K_HOLD): | |
1728 | label = msg_get(MSG_KEYNAME_SCROLLLOCK); | |
1729 | on_off = (vc_kbd_led(kbd_table + vc->vc_num, VC_SCROLLOCK)); | |
1730 | if (speakup_console[vc->vc_num]) | |
1731 | speakup_console[vc->vc_num]->tty_stopped = on_off; | |
1732 | break; | |
1733 | default: | |
1734 | spk_parked &= 0xfe; | |
1735 | spk_unlock(flags); | |
1736 | return; | |
1737 | } | |
1738 | if (on_off < 2) | |
1739 | synth_printf("%s %s\n", | |
1740 | label, msg_get(MSG_STATUS_START + on_off)); | |
1741 | spk_unlock(flags); | |
1742 | } | |
1743 | ||
1744 | static int | |
1745 | inc_dec_var(u_char value) | |
1746 | { | |
1747 | struct st_var_header *p_header; | |
1748 | struct var_t *var_data; | |
1749 | char num_buf[32]; | |
1750 | char *cp = num_buf; | |
1751 | char *pn; | |
1752 | int var_id = (int)value - VAR_START; | |
1753 | int how = (var_id&1) ? E_INC : E_DEC; | |
1754 | var_id = var_id/2+FIRST_SET_VAR; | |
1755 | p_header = get_var_header(var_id); | |
1756 | if (p_header == NULL) | |
1757 | return -1; | |
1758 | if (p_header->var_type != VAR_NUM) | |
1759 | return -1; | |
1760 | var_data = p_header->data; | |
1761 | if (set_num_var(1, p_header, how) != 0) | |
1762 | return -1; | |
1763 | if (!spk_close_press) { | |
1764 | for (pn = p_header->name; *pn; pn++) { | |
1765 | if (*pn == '_') | |
1766 | *cp = SPACE; | |
1767 | else | |
1768 | *cp++ = *pn; | |
1769 | } | |
1770 | } | |
1771 | snprintf(cp, sizeof(num_buf) - (cp - num_buf), " %d ", | |
1772 | var_data->u.n.value); | |
1773 | synth_printf("%s", num_buf); | |
1774 | return 0; | |
1775 | } | |
1776 | ||
1777 | static void | |
1778 | speakup_win_set(struct vc_data *vc) | |
1779 | { | |
1780 | char info[40]; | |
1781 | if (win_start > 1) { | |
1782 | synth_printf("%s\n", msg_get(MSG_WINDOW_ALREADY_SET)); | |
1783 | return; | |
1784 | } | |
1785 | if (spk_x < win_left || spk_y < win_top) { | |
1786 | synth_printf("%s\n", msg_get(MSG_END_BEFORE_START)); | |
1787 | return; | |
1788 | } | |
1789 | if (win_start && spk_x == win_left && spk_y == win_top) { | |
1790 | win_left = 0; | |
1791 | win_right = vc->vc_cols-1; | |
1792 | win_bottom = spk_y; | |
1793 | snprintf(info, sizeof(info), msg_get(MSG_WINDOW_LINE), | |
1794 | (int)win_top+1); | |
1795 | } else { | |
1796 | if (!win_start) { | |
1797 | win_top = spk_y; | |
1798 | win_left = spk_x; | |
1799 | } else { | |
1800 | win_bottom = spk_y; | |
1801 | win_right = spk_x; | |
1802 | } | |
1803 | snprintf(info, sizeof(info), msg_get(MSG_WINDOW_BOUNDARY), | |
1804 | (win_start) ? msg_get(MSG_END) : msg_get(MSG_START), | |
1805 | (int)spk_y+1, (int)spk_x+1); | |
1806 | } | |
1807 | synth_printf("%s\n", info); | |
1808 | win_start++; | |
1809 | } | |
1810 | ||
1811 | static void | |
1812 | speakup_win_clear(struct vc_data *vc) | |
1813 | { | |
1814 | win_top = win_bottom = 0; | |
1815 | win_left = win_right = 0; | |
1816 | win_start = 0; | |
1817 | synth_printf("%s\n", msg_get(MSG_WINDOW_CLEARED)); | |
1818 | } | |
1819 | ||
1820 | static void | |
1821 | speakup_win_enable(struct vc_data *vc) | |
1822 | { | |
1823 | if (win_start < 2) { | |
1824 | synth_printf("%s\n", msg_get(MSG_NO_WINDOW)); | |
1825 | return; | |
1826 | } | |
1827 | win_enabled ^= 1; | |
1828 | if (win_enabled) | |
1829 | synth_printf("%s\n", msg_get(MSG_WINDOW_SILENCED)); | |
1830 | else | |
1831 | synth_printf("%s\n", msg_get(MSG_WINDOW_SILENCE_DISABLED)); | |
1832 | } | |
1833 | ||
1834 | static void | |
1835 | speakup_bits(struct vc_data *vc) | |
1836 | { | |
1837 | int val = this_speakup_key - (FIRST_EDIT_BITS - 1); | |
1838 | if (special_handler != NULL || val < 1 || val > 6) { | |
1839 | synth_printf("%s\n", msg_get(MSG_ERROR)); | |
1840 | return; | |
1841 | } | |
1842 | pb_edit = &punc_info[val]; | |
1843 | synth_printf(msg_get(MSG_EDIT_PROMPT), pb_edit->name); | |
1844 | special_handler = edit_bits; | |
1845 | } | |
1846 | ||
1847 | static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key) | |
1848 | { | |
1849 | static u_char *goto_buf = "\0\0\0\0\0\0"; | |
1850 | static int num = 0; | |
1851 | int maxlen, go_pos; | |
1852 | char *cp; | |
1853 | if (type == KT_SPKUP && ch == SPEAKUP_GOTO) | |
1854 | goto do_goto; | |
1855 | if (type == KT_LATIN && ch == '\n') | |
1856 | goto do_goto; | |
1857 | if (type != 0) | |
1858 | goto oops; | |
1859 | if (ch == 8) { | |
1860 | if (num == 0) | |
1861 | return -1; | |
1862 | ch = goto_buf[--num]; | |
1863 | goto_buf[num] = '\0'; | |
1864 | spkup_write(&ch, 1); | |
1865 | return 1; | |
1866 | } | |
1867 | if (ch < '+' || ch > 'y') | |
1868 | goto oops; | |
1869 | goto_buf[num++] = ch; | |
1870 | goto_buf[num] = '\0'; | |
1871 | spkup_write(&ch, 1); | |
1872 | maxlen = (*goto_buf >= '0') ? 3 : 4; | |
1873 | if ((ch == '+' || ch == '-') && num == 1) | |
1874 | return 1; | |
1875 | if (ch >= '0' && ch <= '9' && num < maxlen) | |
1876 | return 1; | |
1877 | if (num < maxlen-1 || num > maxlen) | |
1878 | goto oops; | |
1879 | if (ch < 'x' || ch > 'y') { | |
1880 | oops: | |
1881 | if (!spk_killed) | |
1882 | synth_printf(" %s\n", msg_get(MSG_GOTO_CANCELED)); | |
1883 | goto_buf[num = 0] = '\0'; | |
1884 | special_handler = NULL; | |
1885 | return 1; | |
1886 | } | |
1887 | cp = speakup_s2i(goto_buf, &go_pos); | |
1888 | goto_pos = (u_long)go_pos; | |
1889 | if (*cp == 'x') { | |
1890 | if (*goto_buf < '0') | |
1891 | goto_pos += spk_x; | |
1892 | else | |
1893 | goto_pos--; | |
1894 | if (goto_pos < 0) | |
1895 | goto_pos = 0; | |
1896 | if (goto_pos >= vc->vc_cols) | |
1897 | goto_pos = vc->vc_cols-1; | |
1898 | goto_x = 1; | |
1899 | } else { | |
1900 | if (*goto_buf < '0') | |
1901 | goto_pos += spk_y; | |
1902 | else | |
1903 | goto_pos--; | |
1904 | if (goto_pos < 0) | |
1905 | goto_pos = 0; | |
1906 | if (goto_pos >= vc->vc_rows) | |
1907 | goto_pos = vc->vc_rows-1; | |
1908 | goto_x = 0; | |
1909 | } | |
1910 | goto_buf[num = 0] = '\0'; | |
1911 | do_goto: | |
1912 | special_handler = NULL; | |
1913 | spk_parked |= 0x01; | |
1914 | if (goto_x) { | |
1915 | spk_pos -= spk_x * 2; | |
1916 | spk_x = goto_pos; | |
1917 | spk_pos += goto_pos * 2; | |
1918 | say_word(vc); | |
1919 | } else { | |
1920 | spk_y = goto_pos; | |
1921 | spk_pos = vc->vc_origin + (goto_pos * vc->vc_size_row); | |
1922 | say_line(vc); | |
1923 | } | |
1924 | return 1; | |
1925 | } | |
1926 | ||
1927 | static void | |
1928 | speakup_goto(struct vc_data *vc) | |
1929 | { | |
1930 | if (special_handler != NULL) { | |
1931 | synth_printf("%s\n", msg_get(MSG_ERROR)); | |
1932 | return; | |
1933 | } | |
1934 | synth_printf("%s\n", msg_get(MSG_GOTO)); | |
1935 | special_handler = handle_goto; | |
1936 | return; | |
1937 | } | |
1938 | ||
1939 | static void speakup_help(struct vc_data *vc) | |
1940 | { | |
1941 | handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0); | |
1942 | } | |
1943 | ||
1944 | static void | |
1945 | do_nothing(struct vc_data *vc) | |
1946 | { | |
1947 | return; /* flush done in do_spkup */ | |
1948 | } | |
1949 | static u_char key_speakup, spk_key_locked; | |
1950 | ||
1951 | static void | |
1952 | speakup_lock(struct vc_data *vc) | |
1953 | { | |
1954 | if (!spk_key_locked) | |
1955 | spk_key_locked = key_speakup = 16; | |
1956 | else | |
1957 | spk_key_locked = key_speakup = 0; | |
1958 | } | |
1959 | ||
1960 | typedef void(*spkup_hand)(struct vc_data *); | |
1961 | spkup_hand spkup_handler[] = { | |
1962 | /* must be ordered same as defines in speakup.h */ | |
1963 | do_nothing, speakup_goto, speech_kill, speakup_shut_up, | |
1964 | speakup_cut, speakup_paste, say_first_char, say_last_char, | |
1965 | say_char, say_prev_char, say_next_char, | |
1966 | say_word, say_prev_word, say_next_word, | |
1967 | say_line, say_prev_line, say_next_line, | |
1968 | top_edge, bottom_edge, left_edge, right_edge, | |
1969 | spell_word, spell_word, say_screen, | |
1970 | say_position, say_attributes, | |
1971 | speakup_off, speakup_parked, say_line, /* this is for indent */ | |
1972 | say_from_top, say_to_bottom, | |
1973 | say_from_left, say_to_right, | |
1974 | say_char_num, speakup_bits, speakup_bits, say_phonetic_char, | |
1975 | speakup_bits, speakup_bits, speakup_bits, | |
1976 | speakup_win_set, speakup_win_clear, speakup_win_enable, speakup_win_say, | |
1977 | speakup_lock, speakup_help, toggle_cursoring, read_all_doc, NULL | |
1978 | }; | |
1979 | ||
1980 | static void do_spkup(struct vc_data *vc, u_char value) | |
1981 | { | |
1982 | if (spk_killed && value != SPEECH_KILL) | |
1983 | return; | |
1984 | spk_keydown = 0; | |
1985 | spk_lastkey = 0; | |
1986 | spk_shut_up &= 0xfe; | |
1987 | this_speakup_key = value; | |
1988 | if (value < SPKUP_MAX_FUNC && spkup_handler[value]) { | |
1989 | do_flush(); | |
1990 | (*spkup_handler[value])(vc); | |
1991 | } else { | |
1992 | if (inc_dec_var(value) < 0) | |
1993 | bleep(9); | |
1994 | } | |
1995 | } | |
1996 | ||
1997 | static const char *pad_chars = "0123456789+-*/\015,.?()"; | |
1998 | ||
1999 | int | |
2000 | speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, | |
2001 | int up_flag) | |
2002 | { | |
2003 | unsigned long flags; | |
2004 | int kh; | |
2005 | u_char *key_info; | |
2006 | u_char type = KTYP(keysym), value = KVAL(keysym), new_key = 0; | |
2007 | u_char shift_info, offset; | |
2008 | int ret = 0; | |
2009 | if (synth == NULL) | |
2010 | return 0; | |
2011 | ||
2012 | spk_lock(flags); | |
5b19208a | 2013 | tty = vc->port.tty; |
c6e3fd22 WH |
2014 | if (type >= 0xf0) |
2015 | type -= 0xf0; | |
2016 | if (type == KT_PAD && | |
2017 | (vc_kbd_led(kbd_table + fg_console, VC_NUMLOCK))) { | |
2018 | if (up_flag) { | |
2019 | spk_keydown = 0; | |
2020 | goto out; | |
2021 | } | |
2022 | value = spk_lastkey = pad_chars[value]; | |
2023 | spk_keydown++; | |
2024 | spk_parked &= 0xfe; | |
2025 | goto no_map; | |
2026 | } | |
2027 | if (keycode >= MAX_KEY) | |
2028 | goto no_map; | |
2029 | key_info = our_keys[keycode]; | |
2030 | if (key_info == 0) | |
2031 | goto no_map; | |
2032 | /* Check valid read all mode keys */ | |
2033 | if ((cursor_track == read_all_mode) && (!up_flag)) { | |
2034 | switch (value) { | |
2035 | case KVAL(K_DOWN): | |
2036 | case KVAL(K_UP): | |
2037 | case KVAL(K_LEFT): | |
2038 | case KVAL(K_RIGHT): | |
2039 | case KVAL(K_PGUP): | |
2040 | case KVAL(K_PGDN): | |
2041 | break; | |
2042 | default: | |
2043 | stop_read_all(vc); | |
2044 | break; | |
2045 | } | |
2046 | } | |
2047 | shift_info = (shift_state&0x0f) + key_speakup; | |
2048 | offset = shift_table[shift_info]; | |
2049 | if (offset) { | |
2050 | new_key = key_info[offset]; | |
2051 | if (new_key) { | |
2052 | ret = 1; | |
2053 | if (new_key == SPK_KEY) { | |
2054 | if (!spk_key_locked) | |
2055 | key_speakup = (up_flag) ? 0 : 16; | |
2056 | if (up_flag || spk_killed) | |
2057 | goto out; | |
2058 | spk_shut_up &= 0xfe; | |
2059 | do_flush(); | |
2060 | goto out; | |
2061 | } | |
2062 | if (up_flag) | |
2063 | goto out; | |
2064 | if (last_keycode == keycode && | |
2065 | last_spk_jiffy+MAX_DELAY > jiffies) { | |
2066 | spk_close_press = 1; | |
2067 | offset = shift_table[shift_info+32]; | |
2068 | /* double press? */ | |
2069 | if (offset && key_info[offset]) | |
2070 | new_key = key_info[offset]; | |
2071 | } | |
2072 | last_keycode = keycode; | |
2073 | last_spk_jiffy = jiffies; | |
2074 | type = KT_SPKUP; | |
2075 | value = new_key; | |
2076 | } | |
2077 | } | |
2078 | no_map: | |
2079 | if (type == KT_SPKUP && special_handler == NULL) { | |
2080 | do_spkup(vc, new_key); | |
2081 | spk_close_press = 0; | |
2082 | ret = 1; | |
2083 | goto out; | |
2084 | } | |
2085 | if (up_flag || spk_killed || type == KT_SHIFT) | |
2086 | goto out; | |
2087 | spk_shut_up &= 0xfe; | |
2088 | kh = (value == KVAL(K_DOWN)) | |
2089 | || (value == KVAL(K_UP)) | |
2090 | || (value == KVAL(K_LEFT)) | |
2091 | || (value == KVAL(K_RIGHT)); | |
2092 | if ((cursor_track != read_all_mode) || !kh) | |
2093 | if (!no_intr) | |
2094 | do_flush(); | |
2095 | if (special_handler) { | |
2096 | if (type == KT_SPEC && value == 1) { | |
2097 | value = '\n'; | |
2098 | type = KT_LATIN; | |
2099 | } else if (type == KT_LETTER) | |
2100 | type = KT_LATIN; | |
2101 | else if (value == 0x7f) | |
2102 | value = 8; /* make del = backspace */ | |
2103 | ret = (*special_handler)(vc, type, value, keycode); | |
2104 | spk_close_press = 0; | |
2105 | if (ret < 0) | |
2106 | bleep(9); | |
2107 | goto out; | |
2108 | } | |
2109 | last_keycode = 0; | |
2110 | out: | |
2111 | spk_unlock(flags); | |
2112 | return ret; | |
2113 | } | |
2114 | ||
2115 | static int keyboard_notifier_call(struct notifier_block *nb, | |
2116 | unsigned long code, void *_param) | |
2117 | { | |
2118 | struct keyboard_notifier_param *param = _param; | |
2119 | struct vc_data *vc = param->vc; | |
2120 | int up = !param->down; | |
2121 | int ret = NOTIFY_OK; | |
2122 | static int keycode; /* to hold the current keycode */ | |
2123 | ||
2124 | if (vc->vc_mode == KD_GRAPHICS) | |
2125 | return ret; | |
2126 | ||
2127 | /* | |
2128 | * First, determine whether we are handling a fake keypress on | |
2129 | * the current processor. If we are, then return NOTIFY_OK, | |
2130 | * to pass the keystroke up the chain. This prevents us from | |
2131 | * trying to take the Speakup lock while it is held by the | |
2132 | * processor on which the simulated keystroke was generated. | |
2133 | * Also, the simulated keystrokes should be ignored by Speakup. | |
2134 | */ | |
2135 | ||
2136 | if (speakup_fake_key_pressed()) | |
2137 | return ret; | |
2138 | ||
2139 | switch (code) { | |
2140 | case KBD_KEYCODE: | |
2141 | /* speakup requires keycode and keysym currently */ | |
2142 | keycode = param->value; | |
2143 | break; | |
2144 | case KBD_UNBOUND_KEYCODE: | |
2145 | /* not used yet */ | |
2146 | break; | |
2147 | case KBD_UNICODE: | |
2148 | /* not used yet */ | |
2149 | break; | |
2150 | case KBD_KEYSYM: | |
2151 | if (speakup_key(vc, param->shift, keycode, param->value, up)) | |
2152 | ret = NOTIFY_STOP; | |
2153 | else | |
2154 | if (KTYP(param->value) == KT_CUR) | |
2155 | ret = pre_handle_cursor(vc, | |
2156 | KVAL(param->value), up); | |
2157 | break; | |
2158 | case KBD_POST_KEYSYM: { | |
2159 | unsigned char type = KTYP(param->value) - 0xf0; | |
2160 | unsigned char val = KVAL(param->value); | |
2161 | switch (type) { | |
2162 | case KT_SHIFT: | |
2163 | do_handle_shift(vc, val, up); | |
2164 | break; | |
2165 | case KT_LATIN: | |
2166 | case KT_LETTER: | |
2167 | do_handle_latin(vc, val, up); | |
2168 | break; | |
2169 | case KT_CUR: | |
2170 | do_handle_cursor(vc, val, up); | |
2171 | break; | |
2172 | case KT_SPEC: | |
2173 | do_handle_spec(vc, val, up); | |
2174 | break; | |
2175 | } | |
2176 | break; | |
2177 | } | |
2178 | } | |
2179 | return ret; | |
2180 | } | |
2181 | ||
2182 | static int vt_notifier_call(struct notifier_block *nb, | |
2183 | unsigned long code, void *_param) | |
2184 | { | |
2185 | struct vt_notifier_param *param = _param; | |
2186 | struct vc_data *vc = param->vc; | |
2187 | switch (code) { | |
2188 | case VT_ALLOCATE: | |
2189 | if (vc->vc_mode == KD_TEXT) | |
2190 | speakup_allocate(vc); | |
2191 | break; | |
2192 | case VT_DEALLOCATE: | |
2193 | speakup_deallocate(vc); | |
2194 | break; | |
2195 | case VT_WRITE: | |
2196 | if (param->c == '\b') | |
2197 | speakup_bs(vc); | |
2198 | else | |
2199 | if (param->c < 0x100) { | |
2200 | char d = param->c; | |
2201 | speakup_con_write(vc, &d, 1); | |
2202 | } | |
2203 | break; | |
2204 | case VT_UPDATE: | |
2205 | speakup_con_update(vc); | |
2206 | break; | |
2207 | } | |
2208 | return NOTIFY_OK; | |
2209 | } | |
2210 | ||
2211 | /* called by: module_exit() */ | |
2212 | static void __exit speakup_exit(void) | |
2213 | { | |
2214 | int i; | |
2215 | ||
2216 | free_user_msgs(); | |
2217 | unregister_keyboard_notifier(&keyboard_notifier_block); | |
2218 | unregister_vt_notifier(&vt_notifier_block); | |
2219 | speakup_unregister_devsynth(); | |
2220 | del_timer(&cursor_timer); | |
2221 | ||
2222 | kthread_stop(speakup_task); | |
2223 | speakup_task = NULL; | |
2224 | mutex_lock(&spk_mutex); | |
2225 | synth_release(); | |
2226 | mutex_unlock(&spk_mutex); | |
2227 | ||
2228 | for (i = 0; i < MAXVARS; i++) | |
2229 | speakup_unregister_var(i); | |
2230 | ||
2231 | for (i = 0; i < 256; i++) { | |
2232 | if (characters[i] != default_chars[i]) | |
2233 | kfree(characters[i]); | |
2234 | } | |
2235 | for (i = 0; speakup_console[i]; i++) | |
2236 | kfree(speakup_console[i]); | |
2237 | speakup_kobj_exit(); | |
2238 | speakup_remove_virtual_keyboard(); | |
2239 | } | |
2240 | ||
2241 | /* call by: module_init() */ | |
2242 | static int __init speakup_init(void) | |
2243 | { | |
2244 | int i; | |
2245 | int err; | |
2246 | struct st_spk_t *first_console; | |
2247 | struct vc_data *vc = vc_cons[fg_console].d; | |
2248 | struct var_t *var; | |
2249 | ||
2250 | err = speakup_add_virtual_keyboard(); | |
2251 | if (err) | |
2252 | return err; | |
2253 | ||
2254 | initialize_msgs(); /* Initialize arrays for i18n. */ | |
2255 | first_console = kzalloc(sizeof(*first_console), GFP_KERNEL); | |
2256 | if (!first_console) | |
2257 | return -ENOMEM; | |
2258 | if (speakup_kobj_init() < 0) | |
2259 | return -ENOMEM; | |
2260 | ||
2261 | reset_default_chars(); | |
2262 | reset_default_chartab(); | |
2263 | ||
2264 | speakup_console[vc->vc_num] = first_console; | |
2265 | speakup_date(vc); | |
2266 | pr_info("speakup %s: initialized\n", SPEAKUP_VERSION); | |
2267 | ||
2268 | strlwr(synth_name); | |
2269 | spk_vars[0].u.n.high = vc->vc_cols; | |
2270 | for (var = spk_vars; var->var_id !=MAXVARS; var++) | |
2271 | speakup_register_var(var); | |
2272 | for (var = synth_time_vars; (var->var_id >= 0) && (var->var_id < MAXVARS); var++) | |
2273 | speakup_register_var(var); | |
2274 | for (i = 1; punc_info[i].mask != 0; i++) | |
2275 | set_mask_bits(0, i, 2); | |
2276 | ||
2277 | set_key_info(key_defaults, key_buf); | |
2278 | if (quiet_boot) | |
2279 | spk_shut_up |= 0x01; | |
2280 | ||
2281 | for (i = 0; i < MAX_NR_CONSOLES; i++) | |
2282 | if (vc_cons[i].d) | |
2283 | speakup_allocate(vc_cons[i].d); | |
2284 | ||
2285 | pr_warn("synth name on entry is: %s\n", synth_name); | |
2286 | synth_init(synth_name); | |
2287 | speakup_register_devsynth(); | |
2288 | ||
2289 | register_keyboard_notifier(&keyboard_notifier_block); | |
2290 | register_vt_notifier(&vt_notifier_block); | |
2291 | ||
2292 | speakup_task = kthread_create(speakup_thread, NULL, "speakup"); | |
2293 | set_user_nice(speakup_task, 10); | |
2294 | if ( ! IS_ERR(speakup_task)) | |
2295 | wake_up_process(speakup_task); | |
2296 | else | |
2297 | return -ENOMEM; | |
2298 | return 0; | |
2299 | } | |
2300 | ||
2301 | ||
2302 | module_init(speakup_init); | |
2303 | module_exit(speakup_exit); | |
2304 |