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