?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wineps.drv: Constify a variable.
[wine.git] / dlls / kernel32 / term.c
blob814b937c0f8fe6b7e6ec43a3dedd09f6dc33fc35
1 /*
2 * Interface to terminfo and termcap libraries
3 *
4 * Copyright 2010 Eric Pouech
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #ifdef HAVE_NCURSES_H
27 # include <ncurses.h>
28 #elif defined(HAVE_CURSES_H)
29 # include <curses.h>
30 #endif
31 /* avoid redefinition warnings */
32 #undef KEY_EVENT
33 #undef MOUSE_MOVED
34
35 #if defined(HAVE_CURSES_H) || defined(HAVE_NCURSES_H)
36 #include <term.h>
37 #endif
38
39 #include <windef.h>
40 #include <winbase.h>
41 #include <winnls.h>
42 #include <wincon.h>
43 #include "console_private.h"
44 #include "wine/library.h"
45 #include "wine/debug.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(console);
48
49 static const int vkkeyscan_table[256] =
50 {
51 0,0,0,0,0,0,0,0,8,9,0,0,0,13,0,0,0,0,0,19,145,556,0,0,0,0,0,27,0,0,0,
52 0,32,305,478,307,308,309,311,222,313,304,312,443,188,189,190,191,48,
53 49,50,51,52,53,54,55,56,57,442,186,444,187,446,447,306,321,322,323,
54 324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,
55 341,342,343,344,345,346,219,220,221,310,445,192,65,66,67,68,69,70,71,
56 72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,475,476,477,
57 448,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
58 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
59 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
60 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,400,0,0,0,0,0,0
61 };
62
63 static const int mapvkey_0[256] =
64 {
65 0,0,0,0,0,0,0,0,14,15,0,0,0,28,0,0,42,29,56,69,58,0,0,0,0,0,0,1,0,0,
66 0,0,57,73,81,79,71,75,72,77,80,0,0,0,55,82,83,0,11,2,3,4,5,6,7,8,9,
67 10,0,0,0,0,0,0,0,30,48,46,32,18,33,34,35,23,36,37,38,50,49,24,25,16,
68 19,31,20,22,47,17,45,21,44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,55,78,0,74,
69 0,53,59,60,61,62,63,64,65,66,67,68,87,88,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
70 0,0,0,0,0,0,69,70,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
71 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,39,13,51,12,52,53,41,0,0,0,0,0,0,0,0,0,
72 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,43,27,40,76,96,0,0,0,0,0,0,0,0,
73 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
74 };
75
76 static inline void init_complex_char(INPUT_RECORD* ir, BOOL down, WORD vk, WORD kc, DWORD cks)
77 {
78 ir->EventType = KEY_EVENT;
79 ir->Event.KeyEvent.bKeyDown = down;
80 ir->Event.KeyEvent.wRepeatCount = 1;
81 ir->Event.KeyEvent.wVirtualScanCode = vk;
82 ir->Event.KeyEvent.wVirtualKeyCode = kc;
83 ir->Event.KeyEvent.dwControlKeyState = cks;
84 ir->Event.KeyEvent.uChar.UnicodeChar = 0;
85 }
86
87 /******************************************************************
88 * TERM_FillSimpleChar
89 *
90 */
91 unsigned TERM_FillSimpleChar(WCHAR real_inchar, INPUT_RECORD* ir)
92 {
93 unsigned vk;
94 WCHAR inchar;
95 unsigned numEvent = 0;
96 DWORD cks = 0;
97
98 switch (real_inchar)
99 {
100 case 9: inchar = real_inchar;
101 real_inchar = 27; /* so that we don't think key is ctrl- something */
102 break;
103 case 13:
104 case 10: inchar = '\r';
105 real_inchar = 27; /* Fixme: so that we don't think key is ctrl- something */
106 break;
107 case 127: inchar = '\b';
108 break;
109 default:
110 inchar = real_inchar;
111 break;
112 }
113 vk = (inchar < 256) ? vkkeyscan_table[inchar] : 0;
114 if (vk & 0x0100)
115 init_complex_char(&ir[numEvent++], 1, 0x2a, 0x10, SHIFT_PRESSED);
116 if ((vk & 0x0200) || (unsigned char)real_inchar <= 26)
117 init_complex_char(&ir[numEvent++], 1, 0x1d, 0x11, LEFT_CTRL_PRESSED);
118 if (vk & 0x0400)
119 init_complex_char(&ir[numEvent++], 1, 0x38, 0x12, LEFT_ALT_PRESSED);
120
121 ir[numEvent].EventType = KEY_EVENT;
122 ir[numEvent].Event.KeyEvent.bKeyDown = 1;
123 ir[numEvent].Event.KeyEvent.wRepeatCount = 1;
124 ir[numEvent].Event.KeyEvent.dwControlKeyState = cks;
125 if (vk & 0x0100)
126 ir[numEvent].Event.KeyEvent.dwControlKeyState |= SHIFT_PRESSED;
127 if ((vk & 0x0200) || (unsigned char)real_inchar <= 26)
128 ir[numEvent].Event.KeyEvent.dwControlKeyState |= LEFT_CTRL_PRESSED;
129 if (vk & 0x0400)
130 ir[numEvent].Event.KeyEvent.dwControlKeyState |= LEFT_ALT_PRESSED;
131 ir[numEvent].Event.KeyEvent.wVirtualKeyCode = vk;
132 ir[numEvent].Event.KeyEvent.wVirtualScanCode = mapvkey_0[vk & 0x00ff]; /* VirtualKeyCodes to ScanCode */
133
134 ir[numEvent].Event.KeyEvent.uChar.UnicodeChar = inchar;
135 ir[numEvent + 1] = ir[numEvent];
136 ir[numEvent + 1].Event.KeyEvent.bKeyDown = 0;
137
138 numEvent += 2;
139
140 if (vk & 0x0400)
141 init_complex_char(&ir[numEvent++], 0, 0x38, 0x12, LEFT_ALT_PRESSED);
142 if ((vk & 0x0200) || (unsigned char)real_inchar <= 26)
143 init_complex_char(&ir[numEvent++], 0, 0x1d, 0x11, 0);
144 if (vk & 0x0100)
145 init_complex_char(&ir[numEvent++], 0, 0x2a, 0x10, 0);
146 return numEvent;
147 }
148
149 #if defined(SONAME_LIBCURSES) || defined(SONAME_LIBNCURSES)
150
151 #ifdef HAVE_NCURSES_H
152 # define CURSES_NAME "ncurses"
153 #else
154 # define CURSES_NAME "curses"
155 #endif
156
157 static void *nc_handle = NULL;
158
159 #define MAKE_FUNCPTR(f) static typeof(f) * p_##f;
160
161 MAKE_FUNCPTR(putp)
162 MAKE_FUNCPTR(setupterm)
163 MAKE_FUNCPTR(tigetstr)
164 MAKE_FUNCPTR(tparm)
165
166 #undef MAKE_FUNCPTR
167
168 /**********************************************************************/
169
170 static BOOL TERM_bind_libcurses(void)
171 {
172 #ifdef SONAME_LIBNCURSES
173 static const char ncname[] = SONAME_LIBNCURSES;
174 #else
175 static const char ncname[] = SONAME_LIBCURSES;
176 #endif
177
178 if (!(nc_handle = wine_dlopen(ncname, RTLD_NOW, NULL, 0)))
179 {
180 MESSAGE("Wine cannot find the " CURSES_NAME " library (%s).\n", ncname);
181 return FALSE;
182 }
183
184 #define LOAD_FUNCPTR(f) \
185 if((p_##f = wine_dlsym(nc_handle, #f, NULL, 0)) == NULL) \
186 { \
187 WARN("Can't find symbol %s\n", #f); \
188 goto sym_not_found; \
189 }
190
191 LOAD_FUNCPTR(putp)
192 LOAD_FUNCPTR(setupterm)
193 LOAD_FUNCPTR(tigetstr)
194 LOAD_FUNCPTR(tparm)
195
196 #undef LOAD_FUNCPTR
197
198 return TRUE;
199
200 sym_not_found:
201 MESSAGE(
202 "Wine cannot find certain functions that it needs inside the "
203 CURSES_NAME "\nlibrary. To enable Wine to use " CURSES_NAME
204 " please upgrade your " CURSES_NAME "\nlibraries\n");
205 wine_dlclose(nc_handle, NULL, 0);
206 nc_handle = NULL;
207 return FALSE;
208 }
209
210 #define putp p_putp
211 #define setupterm p_setupterm
212 #define tigetstr p_tigetstr
213 #define tparm p_tparm
214
215 struct dbkey_descr
216 {
217 enum dbkey_kind {dbk_simple, dbk_complex} kind;
218 DWORD_PTR p1;
219 DWORD_PTR p2;
220 DWORD_PTR p3;
221 };
222
223 struct dbkey_init
224 {
225 const char* string_normal;
226 const char* string_xterm;
227 struct dbkey_descr descr;
228 };
229
230 static struct dbkey_init TERM_dbkey_init[] = {
231 {"kcud1", "kDN", {dbk_complex, 0x50, 0x28, 0}},
232 {"kcuu1", "kUP", {dbk_complex, 0x48, 0x26, 0}},
233 {"kcub1", "kLFT", {dbk_complex, 0x4b, 0x25, 0}},
234 {"kcuf1", "kRIT", {dbk_complex, 0x4d, 0x27, 0}},
235 {"khome", "kHOM", {dbk_complex, 0x47, 0x24, 0}},
236 {"kbs", NULL, {dbk_simple, 0x7f, 0x00, 0}},
237 {"kf1", NULL, {dbk_complex, 0x3b, 0x70, 0}},
238 {"kf2", NULL, {dbk_complex, 0x3c, 0x71, 0}},
239 {"kf3", NULL, {dbk_complex, 0x3d, 0x72, 0}},
240 {"kf4", NULL, {dbk_complex, 0x3e, 0x73, 0}},
241 {"kf5", NULL, {dbk_complex, 0x3f, 0x74, 0}},
242 {"kf6", NULL, {dbk_complex, 0x40, 0x75, 0}},
243 {"kf7", NULL, {dbk_complex, 0x41, 0x76, 0}},
244 {"kf8", NULL, {dbk_complex, 0x42, 0x77, 0}},
245 {"kf9", NULL, {dbk_complex, 0x43, 0x78, 0}},
246 {"kf10", NULL, {dbk_complex, 0x44, 0x79, 0}},
247 {"kf11", NULL, {dbk_complex, 0xd9, 0x7a, 0}},
248 {"kf12", NULL, {dbk_complex, 0xda, 0x7b, 0}},
249 {"kf13", NULL, {dbk_complex, 0x3b, 0x70, SHIFT_PRESSED}},
250 {"kf14", NULL, {dbk_complex, 0x3c, 0x71, SHIFT_PRESSED}},
251 {"kf15", NULL, {dbk_complex, 0x3d, 0x72, SHIFT_PRESSED}},
252 {"kf16", NULL, {dbk_complex, 0x3e, 0x73, SHIFT_PRESSED}},
253 {"kf17", NULL, {dbk_complex, 0x3f, 0x74, SHIFT_PRESSED}},
254 {"kf18", NULL, {dbk_complex, 0x40, 0x75, SHIFT_PRESSED}},
255 {"kf19", NULL, {dbk_complex, 0x41, 0x76, SHIFT_PRESSED}},
256 {"kf20", NULL, {dbk_complex, 0x42, 0x77, SHIFT_PRESSED}},
257 {"kf21", NULL, {dbk_complex, 0x43, 0x78, SHIFT_PRESSED}},
258 {"kf22", NULL, {dbk_complex, 0x44, 0x79, SHIFT_PRESSED}},
259 {"kf23", NULL, {dbk_complex, 0xd9, 0x7a, SHIFT_PRESSED}},
260 {"kf24", NULL, {dbk_complex, 0xda, 0x7b, SHIFT_PRESSED}},
261 {"kf25", NULL, {dbk_complex, 0x3b, 0x70, LEFT_CTRL_PRESSED}},
262 {"kf26", NULL, {dbk_complex, 0x3c, 0x71, LEFT_CTRL_PRESSED}},
263 {"kf27", NULL, {dbk_complex, 0x3d, 0x72, LEFT_CTRL_PRESSED}},
264 {"kf28", NULL, {dbk_complex, 0x3e, 0x73, LEFT_CTRL_PRESSED}},
265 {"kf29", NULL, {dbk_complex, 0x3f, 0x74, LEFT_CTRL_PRESSED}},
266 {"kf30", NULL, {dbk_complex, 0x40, 0x75, LEFT_CTRL_PRESSED}},
267 {"kf31", NULL, {dbk_complex, 0x41, 0x76, LEFT_CTRL_PRESSED}},
268 {"kf32", NULL, {dbk_complex, 0x42, 0x77, LEFT_CTRL_PRESSED}},
269 {"kf33", NULL, {dbk_complex, 0x43, 0x78, LEFT_CTRL_PRESSED}},
270 {"kf34", NULL, {dbk_complex, 0x44, 0x79, LEFT_CTRL_PRESSED}},
271 {"kf35", NULL, {dbk_complex, 0xd9, 0x7a, LEFT_CTRL_PRESSED}},
272 {"kf36", NULL, {dbk_complex, 0xda, 0x7b, LEFT_CTRL_PRESSED}},
273 {"kf37", NULL, {dbk_complex, 0x3b, 0x70, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
274 {"kf38", NULL, {dbk_complex, 0x3c, 0x71, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
275 {"kf39", NULL, {dbk_complex, 0x3d, 0x72, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
276 {"kf40", NULL, {dbk_complex, 0x3e, 0x73, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
277 {"kf41", NULL, {dbk_complex, 0x3f, 0x74, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
278 {"kf42", NULL, {dbk_complex, 0x40, 0x75, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
279 {"kf43", NULL, {dbk_complex, 0x41, 0x76, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
280 {"kf44", NULL, {dbk_complex, 0x42, 0x77, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
281 {"kf45", NULL, {dbk_complex, 0x43, 0x78, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
282 {"kf46", NULL, {dbk_complex, 0x44, 0x79, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
283 {"kf47", NULL, {dbk_complex, 0xd9, 0x7a, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
284 {"kf48", NULL, {dbk_complex, 0xda, 0x7b, LEFT_CTRL_PRESSED|SHIFT_PRESSED}},
285 {"kf49", NULL, {dbk_complex, 0x3b, 0x70, LEFT_ALT_PRESSED}},
286 {"kf50", NULL, {dbk_complex, 0x3c, 0x71, LEFT_ALT_PRESSED}},
287 {"kf51", NULL, {dbk_complex, 0x3d, 0x72, LEFT_ALT_PRESSED}},
288 {"kf52", NULL, {dbk_complex, 0x3e, 0x73, LEFT_ALT_PRESSED}},
289 {"kf53", NULL, {dbk_complex, 0x3f, 0x74, LEFT_ALT_PRESSED}},
290 {"kf54", NULL, {dbk_complex, 0x40, 0x75, LEFT_ALT_PRESSED}},
291 {"kf55", NULL, {dbk_complex, 0x41, 0x76, LEFT_ALT_PRESSED}},
292 {"kf56", NULL, {dbk_complex, 0x42, 0x77, LEFT_ALT_PRESSED}},
293 {"kf57", NULL, {dbk_complex, 0x43, 0x78, LEFT_ALT_PRESSED}},
294 {"kf58", NULL, {dbk_complex, 0x44, 0x79, LEFT_ALT_PRESSED}},
295 {"kf59", NULL, {dbk_complex, 0xd9, 0x7a, LEFT_ALT_PRESSED}},
296 {"kf60", NULL, {dbk_complex, 0xda, 0x7b, LEFT_ALT_PRESSED}},
297 {"kf61", NULL, {dbk_complex, 0x3b, 0x70, LEFT_ALT_PRESSED|SHIFT_PRESSED}},
298 {"kf62", NULL, {dbk_complex, 0x3c, 0x71, LEFT_ALT_PRESSED|SHIFT_PRESSED}},
299 {"kf63", NULL, {dbk_complex, 0x3d, 0x72, LEFT_ALT_PRESSED|SHIFT_PRESSED}},
300
301 {"kdch1", "kDC", {dbk_complex, 0x53, 0x2e, 0}},
302 {"kich1", "kIC", {dbk_complex, 0x52, 0x2d, 0}},
303 {"knp", "kNXT", {dbk_complex, 0x51, 0x22, 0}},
304 {"kpp", "kPRV", {dbk_complex, 0x49, 0x21, 0}},
305 {"kcbt", NULL, {dbk_simple, 0x09, 0x00, SHIFT_PRESSED}},
306 {"kend", "kEND", {dbk_complex, 0x4f, 0x23, 0}},
307
308 /* {"kmous", NULL, }, */
309 /* Still some keys to manage:
310 KEY_DL KEY_IL KEY_EIC KEY_CLEAR KEY_EOS
311 KEY_EOL KEY_SF KEY_SR KEY_STAB KEY_CTAB
312 KEY_CATAB KEY_ENTER KEY_SRESET KEY_RESET KEY_PRINT
313 KEY_LL KEY_A1 KEY_A3 KEY_B2 KEY_C1
314 KEY_C3 KEY_BEG KEY_CANCEL KEY_CLOSE KEY_COMMAND
315 KEY_COPY KEY_CREATE KEY_EXIT KEY_FIND KEY_HELP
316 KEY_MARK KEY_MESSAGE KEY_MOVE KEY_NEXT KEY_OPEN
317 KEY_OPTIONS KEY_PREVIOUS KEY_REDO KEY_REFERENCE KEY_REFRESH
318 KEY_REPLACE KEY_RESTART KEY_RESUME KEY_SAVE KEY_SBEG
319 KEY_SCANCEL KEY_SCOMMAND KEY_SCOPY KEY_SCREATE KEY_RESIZE
320 KEY_SDL KEY_SELECT KEY_SEOL KEY_SEXIT KEY_SFIND
321 KEY_SHELP KEY_SMESSAGE KEY_SMOVE KEY_SNEXT KEY_SOPTIONS
322 KEY_SPREVIOUS KEY_SPRINT KEY_SREDO KEY_SREPLACE KEY_SRSUME
323 KEY_SSAVE KEY_SSUSPEND KEY_SUNDO KEY_SUSPEND KEY_UNDO
324 */
325 };
326
327 struct dbkey_pair
328 {
329 const char* string;
330 unsigned string_len;
331 struct dbkey_descr descr;
332 };
333
334 static struct dbkey_pair* TERM_dbkey;
335 static unsigned TERM_dbkey_size;
336 static unsigned TERM_dbkey_index;
337
338 static int TERM_dbkey_cmp(const void* p1, const void* p2)
339 {
340 const struct dbkey_pair* kp1 = p1;
341 const struct dbkey_pair* kp2 = p2;
342 return strcmp(kp1->string, kp2->string);
343 }
344
345 static BOOL TERM_AddKeyDescr(const char* string, struct dbkey_descr* descr)
346 {
347 if (!string || string == (const char*)-1) return TRUE;
348 if (!TERM_dbkey)
349 {
350 TERM_dbkey_size = 32;
351 TERM_dbkey = HeapAlloc(GetProcessHeap(), 0, TERM_dbkey_size * sizeof(struct dbkey_pair));
352 if (!TERM_dbkey) return FALSE;
353 }
354 if (TERM_dbkey_index == TERM_dbkey_size)
355 {
356 struct dbkey_pair* new;
357
358 new = HeapReAlloc(GetProcessHeap(), 0, TERM_dbkey, (2 * TERM_dbkey_size) * sizeof(struct dbkey_pair));
359 if (!new) return FALSE;
360 TERM_dbkey = new;
361 TERM_dbkey_size *= 2;
362 }
363 TERM_dbkey[TERM_dbkey_index].string = string;
364 TERM_dbkey[TERM_dbkey_index].string_len = strlen(string);
365 TERM_dbkey[TERM_dbkey_index].descr = *descr;
366 TERM_dbkey_index++;
367 return TRUE;
368 }
369
370 static BOOL TERM_BuildKeyDB(void)
371 {
372 unsigned i, j, len;
373 struct dbkey_descr descr;
374 char tmp[64];
375
376 for (i = 0; i < sizeof(TERM_dbkey_init) / sizeof(TERM_dbkey_init[0]); i++)
377 {
378 if (!TERM_AddKeyDescr(tigetstr((char *)TERM_dbkey_init[i].string_normal), &TERM_dbkey_init[i].descr))
379 return FALSE;
380 if (TERM_dbkey_init[i].string_xterm)
381 {
382 descr = TERM_dbkey_init[i].descr;
383 strcpy(tmp, TERM_dbkey_init[i].string_xterm);
384 len = strlen(tmp);
385 tmp[len + 1] = '\0';
386 #define X(v, f) do { tmp[len] = v; descr.p3 = (f); if (!TERM_AddKeyDescr(tigetstr(tmp), &descr)) return FALSE; } while (0)
387 X('\0', SHIFT_PRESSED);
388 X('3', LEFT_ALT_PRESSED);
389 X('4', SHIFT_PRESSED | LEFT_ALT_PRESSED);
390 X('5', LEFT_CTRL_PRESSED);
391 X('6', LEFT_CTRL_PRESSED|SHIFT_PRESSED);
392 X('7', LEFT_CTRL_PRESSED|LEFT_ALT_PRESSED);
393 X('8', LEFT_CTRL_PRESSED|LEFT_ALT_PRESSED|SHIFT_PRESSED);
394 #undef X
395 }
396 }
397 for (i = 0; i < TERM_dbkey_index; i++)
398 {
399 for (j = 0; j < TERM_dbkey_index; j++)
400 {
401 if (i != j &&
402 TERM_dbkey[i].string_len >= TERM_dbkey[j].string_len &&
403 !memcmp(TERM_dbkey[i].string, TERM_dbkey[j].string, TERM_dbkey[j].string_len))
404 FIXME("substring %d/%s %d/%s\n", i, TERM_dbkey[i].string, j, TERM_dbkey[j].string);
405 }
406 }
407 qsort(TERM_dbkey, TERM_dbkey_index, sizeof(TERM_dbkey[0]), TERM_dbkey_cmp);
408 return TRUE;
409 }
410
411 static BOOL TERM_init_done /* = FALSE */;
412
413 BOOL TERM_Init(void)
414 {
415 /* if we're not attached to a tty, don't fire the curses support */
416 if (!isatty(0) || !isatty(1)) return FALSE;
417 if (!getenv("TERM")) return FALSE;
418 if (!TERM_bind_libcurses()) return FALSE;
419 if (setupterm(NULL, 1 /* really ?? */, NULL) == -1) return FALSE;
420 TERM_init_done = TRUE;
421 TERM_BuildKeyDB();
422 /* set application key mode */
423 putp(tigetstr((char *)"smkx"));
424 return TRUE;
425 }
426
427 BOOL TERM_Exit(void)
428 {
429 if (TERM_init_done)
430 {
431 /* put back the cursor key mode */
432 putp(tigetstr((char *)"rmkx"));
433 }
434 return TRUE;
435 }
436
437 /* -1 not found, 0 cannot decide, > 0 found */
438 int TERM_FillInputRecord(const char* in, size_t len, INPUT_RECORD* ir)
439 {
440 int low = 0, high = TERM_dbkey_index - 1, mid, res;
441 struct dbkey_descr* found;
442
443 while (low <= high)
444 {
445 mid = low + (high - low) / 2;
446 res = memcmp(in, TERM_dbkey[mid].string, len);
447 if (!res)
448 {
449 if (len < TERM_dbkey[mid].string_len) return 0;
450 found = &TERM_dbkey[mid].descr;
451 switch (found->kind)
452 {
453 case dbk_simple:
454 return TERM_FillSimpleChar(found->p1, ir);
455 case dbk_complex:
456 init_complex_char(&ir[0], 1, found->p1, found->p2, ENHANCED_KEY | found->p3);
457 init_complex_char(&ir[1], 0, found->p1, found->p2, ENHANCED_KEY | found->p3);
458 return 2;
459 }
460 return -1;
461 }
462 else if (res < 0) high = mid - 1;
463 else low = mid + 1;
464 }
465 return -1;
466 }
467
468 #else
469 BOOL TERM_Init(void) {return FALSE;}
470 BOOL TERM_Exit(void) {return FALSE;}
471 int TERM_FillInputRecord(const char* in, size_t len, INPUT_RECORD* ir) {return -1;}
472 #endif
Windows API implementation