?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20030408.
[wine/gsoc-2012-control.git] / dlls / kernel / editline.c
blob086b2bc0ee3b8cf16c4058ff4576ff2c18bb8cde
1 /*
2 * line edition function for Win32 console
3 *
4 * Copyright 2001 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <string.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wincon.h"
29 #include "wine/unicode.h"
30 #include "winnls.h"
31 #include "wine/debug.h"
32 #include "console_private.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(console);
35
36 struct WCEL_Context;
37
38 typedef struct
39 {
40 WCHAR val; /* vk or unicode char */
41 void (*func)(struct WCEL_Context* ctx);
42 } KeyEntry;
43
44 typedef struct
45 {
46 DWORD keyState; /* keyState (from INPUT_RECORD) to match */
47 BOOL chkChar; /* check vk or char */
48 KeyEntry* entries; /* array of entries */
49 } KeyMap;
50
51 typedef struct WCEL_Context {
52 WCHAR* line; /* the line being edited */
53 size_t alloc; /* number of WCHAR in line */
54 unsigned len; /* number of chars in line */
55 unsigned ofs; /* offset for cursor in current line */
56 WCHAR* yanked; /* yanked line */
57 unsigned mark; /* marked point (emacs mode only) */
58 CONSOLE_SCREEN_BUFFER_INFO csbi; /* current state (initial cursor, window size, attribute) */
59 HANDLE hConIn;
60 HANDLE hConOut;
61 unsigned done : 1, /* to 1 when we're done with editing */
62 error : 1, /* to 1 when an error occurred in the editing */
63 can_wrap : 1; /* to 1 when multi-line edition can take place */
64 unsigned histSize;
65 unsigned histPos;
66 WCHAR* histCurr;
67 } WCEL_Context;
68
69 #if 0
70 static void WCEL_Dump(WCEL_Context* ctx, const char* pfx)
71 {
72 MESSAGE("%s: [line=%s[alloc=%u] ofs=%u len=%u start=(%d,%d) mask=%c%c%c]\n"
73 "\t\thist=(size=%u pos=%u curr=%s)\n"
74 "\t\tyanked=%s\n",
75 pfx, debugstr_w(ctx->line), ctx->alloc, ctx->ofs, ctx->len,
76 ctx->csbi.dwCursorPosition.X, ctx->csbi.dwCursorPosition.Y,
77 ctx->done ? 'D' : 'd', ctx->error ? 'E' : 'e', ctx->can_wrap ? 'W' : 'w',
78 ctx->histSize, ctx->histPos, debugstr_w(ctx->histCurr),
79 debugstr_w(ctx->yanked));
80 }
81 #endif
82
83 /* ====================================================================
84 *
85 * Console helper functions
86 *
87 * ====================================================================*/
88
89 static BOOL WCEL_Get(WCEL_Context* ctx, INPUT_RECORD* ir)
90 {
91 DWORD retv;
92
93 for (;;)
94 {
95 /* data available ? */
96 if (ReadConsoleInputW(ctx->hConIn, ir, 1, &retv) && retv == 1)
97 return TRUE;
98 /* then wait... */
99 switch (WaitForSingleObject(ctx->hConIn, INFINITE))
100 {
101 case WAIT_OBJECT_0:
102 break;
103 default:
104 /* we have checked that hConIn was a console handle (could be sb) */
105 ERR("Shouldn't happen\n");
106 /* fall thru */
107 case WAIT_ABANDONED:
108 case WAIT_TIMEOUT:
109 ctx->error = 1;
110 ERR("hmm bad situation\n");
111 return FALSE;
112 }
113 }
114 }
115
116 static inline void WCEL_Beep(WCEL_Context* ctx)
117 {
118 Beep(400, 300);
119 }
120
121 static inline BOOL WCEL_IsSingleLine(WCEL_Context* ctx, size_t len)
122 {
123 return ctx->csbi.dwCursorPosition.X + ctx->len + len <= ctx->csbi.dwSize.X;
124 }
125
126 static inline COORD WCEL_GetCoord(WCEL_Context* ctx, int ofs)
127 {
128 COORD c;
129 unsigned len = ctx->csbi.dwSize.X - ctx->csbi.dwCursorPosition.X;
130
131 c.Y = ctx->csbi.dwCursorPosition.Y;
132 if (ofs >= len)
133 {
134 ofs -= len;
135 c.X = ofs % ctx->csbi.dwSize.X;
136 c.Y += 1 + ofs / ctx->csbi.dwSize.X;
137 }
138 else c.X = ctx->csbi.dwCursorPosition.X + ofs;
139 return c;
140 }
141
142 static inline void WCEL_Update(WCEL_Context* ctx, int beg, int len)
143 {
144 WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[beg], len,
145 WCEL_GetCoord(ctx, beg), NULL);
146 FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, len,
147 WCEL_GetCoord(ctx, beg), NULL);
148 }
149
150 /* ====================================================================
151 *
152 * context manipulation functions
153 *
154 * ====================================================================*/
155
156 static BOOL WCEL_Grow(WCEL_Context* ctx, size_t len)
157 {
158 if (!WCEL_IsSingleLine(ctx, len) && !ctx->can_wrap)
159 {
160 FIXME("Mode doesn't allow to wrap. However, we should allow to overwrite current string\n");
161 return FALSE;
162 }
163
164 if (ctx->len + len >= ctx->alloc)
165 {
166 WCHAR* newline;
167 size_t newsize;
168
169 /* round up size to 32 byte-WCHAR boundary */
170 newsize = (ctx->len + len + 1 + 31) & ~31;
171 newline = HeapReAlloc(GetProcessHeap(), 0, ctx->line, sizeof(WCHAR) * newsize);
172 if (!newline) return FALSE;
173 ctx->line = newline;
174 ctx->alloc = newsize;
175 }
176 return TRUE;
177 }
178
179 static void WCEL_DeleteString(WCEL_Context* ctx, int beg, int end)
180 {
181 unsigned str_len = end - beg;
182 COORD cbeg = WCEL_GetCoord(ctx, ctx->len - str_len);
183 COORD cend = WCEL_GetCoord(ctx, ctx->len);
184 CHAR_INFO ci;
185
186 if (end < ctx->len)
187 memmove(&ctx->line[beg], &ctx->line[end], (ctx->len - end) * sizeof(WCHAR));
188 /* we need to clean from ctx->len - str_len to ctx->len */
189
190 ci.Char.UnicodeChar = ' ';
191 ci.Attributes = ctx->csbi.wAttributes;
192
193 if (cbeg.Y == cend.Y)
194 {
195 /* partial erase of sole line */
196 CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
197 cend.X - cbeg.X, &ci);
198 }
199 else
200 {
201 int i;
202 /* erase til eol on first line */
203 CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
204 ctx->csbi.dwSize.X - cbeg.X, &ci);
205 /* completly erase all the others (full lines) */
206 for (i = cbeg.Y + 1; i < cend.Y; i++)
207 CONSOLE_FillLineUniform(ctx->hConOut, 0, i, ctx->csbi.dwSize.X, &ci);
208 /* erase from beg of line until last pos on last line */
209 CONSOLE_FillLineUniform(ctx->hConOut, 0, cend.Y, cend.X, &ci);
210 }
211 ctx->len -= str_len;
212 WCEL_Update(ctx, 0, ctx->len);
213 ctx->line[ctx->len] = 0;
214 }
215
216 static void WCEL_InsertString(WCEL_Context* ctx, const WCHAR* str)
217 {
218 size_t len = lstrlenW(str);
219
220 if (!len || !WCEL_Grow(ctx, len)) return;
221 if (ctx->len > ctx->ofs)
222 memmove(&ctx->line[ctx->ofs + len], &ctx->line[ctx->ofs], (ctx->len - ctx->ofs) * sizeof(WCHAR));
223 memcpy(&ctx->line[ctx->ofs], str, len * sizeof(WCHAR));
224 ctx->len += len;
225 ctx->line[ctx->len] = 0;
226 WCEL_Update(ctx, ctx->ofs, ctx->len - ctx->ofs);
227
228 ctx->ofs += len;
229 }
230
231 static void WCEL_InsertChar(WCEL_Context* ctx, WCHAR c)
232 {
233 WCHAR buffer[2];
234
235 /* do not insert 0..31 control characters */
236 if (c < ' ' && c != '\t') return;
237
238 buffer[0] = c;
239 buffer[1] = 0;
240 WCEL_InsertString(ctx, buffer);
241 }
242
243 static void WCEL_FreeYank(WCEL_Context* ctx)
244 {
245 if (ctx->yanked)
246 {
247 HeapFree(GetProcessHeap(), 0, ctx->yanked);
248 ctx->yanked = NULL;
249 }
250 }
251
252 static void WCEL_SaveYank(WCEL_Context* ctx, int beg, int end)
253 {
254 int len = end - beg;
255 if (len <= 0) return;
256
257 WCEL_FreeYank(ctx);
258 ctx->yanked = HeapReAlloc(GetProcessHeap(), 0, ctx->yanked, (len + 1) * sizeof(WCHAR));
259 if (!ctx->yanked) return;
260 memcpy(ctx->yanked, &ctx->line[beg], len * sizeof(WCHAR));
261 ctx->yanked[len] = 0;
262 }
263
264 /* FIXME NTDLL doesn't export iswalnum, and I don't want to link in msvcrt when most
265 * of the data lay in unicode lib
266 */
267 static inline BOOL WCEL_iswalnum(WCHAR wc)
268 {
269 return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
270 }
271
272 static int WCEL_GetLeftWordTransition(WCEL_Context* ctx, int ofs)
273 {
274 ofs--;
275 while (ofs >= 0 && !WCEL_iswalnum(ctx->line[ofs])) ofs--;
276 while (ofs >= 0 && WCEL_iswalnum(ctx->line[ofs])) ofs--;
277 if (ofs >= 0) ofs++;
278 return max(ofs, 0);
279 }
280
281 static int WCEL_GetRightWordTransition(WCEL_Context* ctx, int ofs)
282 {
283 ofs++;
284 while (ofs <= ctx->len && WCEL_iswalnum(ctx->line[ofs])) ofs++;
285 while (ofs <= ctx->len && !WCEL_iswalnum(ctx->line[ofs])) ofs++;
286 return min(ofs, ctx->len);
287 }
288
289 static WCHAR* WCEL_GetHistory(WCEL_Context* ctx, int idx)
290 {
291 WCHAR* ptr;
292
293 if (idx == ctx->histSize - 1)
294 {
295 ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(ctx->histCurr) + 1) * sizeof(WCHAR));
296 lstrcpyW(ptr, ctx->histCurr);
297 }
298 else
299 {
300 int len = CONSOLE_GetHistory(idx, NULL, 0);
301
302 if ((ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
303 {
304 CONSOLE_GetHistory(idx, ptr, len);
305 }
306 }
307 return ptr;
308 }
309
310 static void WCEL_HistoryInit(WCEL_Context* ctx)
311 {
312 ctx->histPos = CONSOLE_GetNumHistoryEntries();
313 ctx->histSize = ctx->histPos + 1;
314 ctx->histCurr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR));
315 }
316
317 static void WCEL_MoveToHist(WCEL_Context* ctx, int idx)
318 {
319 WCHAR* data = WCEL_GetHistory(ctx, idx);
320 int len = lstrlenW(data) + 1;
321
322 /* save current line edition for recall when needed (FIXME seems broken to me) */
323 if (ctx->histPos == ctx->histSize - 1)
324 {
325 if (ctx->histCurr) HeapFree(GetProcessHeap(), 0, ctx->histCurr);
326 ctx->histCurr = HeapAlloc(GetProcessHeap(), 0, (ctx->len + 1) * sizeof(WCHAR));
327 memcpy(ctx->histCurr, ctx->line, (ctx->len + 1) * sizeof(WCHAR));
328 }
329 /* need to clean also the screen if new string is shorter than old one */
330 WCEL_DeleteString(ctx, 0, ctx->len);
331 ctx->ofs = 0;
332 /* insert new string */
333 if (WCEL_Grow(ctx, len))
334 {
335 WCEL_InsertString(ctx, data);
336 HeapFree(GetProcessHeap(), 0, data);
337 ctx->histPos = idx;
338 }
339 }
340
341 static void WCEL_FindPrevInHist(WCEL_Context* ctx)
342 {
343 int startPos = ctx->histPos;
344 WCHAR* data;
345 int len, oldofs;
346
347 if (ctx->histPos && ctx->histPos == ctx->histSize) {
348 startPos--;
349 ctx->histPos--;
350 }
351
352 do {
353 data = WCEL_GetHistory(ctx, ctx->histPos);
354
355 if (ctx->histPos) ctx->histPos--;
356 else ctx->histPos = (ctx->histSize-1);
357
358 len = lstrlenW(data) + 1;
359 if ((len >= ctx->ofs) &&
360 (memcmp(ctx->line, data, ctx->ofs * sizeof(WCHAR)) == 0)) {
361
362 /* need to clean also the screen if new string is shorter than old one */
363 WCEL_DeleteString(ctx, 0, ctx->len);
364
365 if (WCEL_Grow(ctx, len))
366 {
367 oldofs = ctx->ofs;
368 ctx->ofs = 0;
369 WCEL_InsertString(ctx, data);
370 ctx->ofs = oldofs;
371 SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
372 HeapFree(GetProcessHeap(), 0, data);
373 return;
374 }
375 }
376 } while (ctx->histPos != startPos);
377
378 return;
379 }
380
381 /* ====================================================================
382 *
383 * basic edition functions
384 *
385 * ====================================================================*/
386
387 static void WCEL_Done(WCEL_Context* ctx)
388 {
389 WCHAR nl = '\n';
390 if (!WCEL_Grow(ctx, 1)) return;
391 ctx->line[ctx->len++] = '\n';
392 ctx->line[ctx->len] = 0;
393 WriteConsoleW(ctx->hConOut, &nl, 1, NULL, NULL);
394 ctx->done = 1;
395 }
396
397 static void WCEL_MoveLeft(WCEL_Context* ctx)
398 {
399 if (ctx->ofs > 0) ctx->ofs--;
400 }
401
402 static void WCEL_MoveRight(WCEL_Context* ctx)
403 {
404 if (ctx->ofs < ctx->len) ctx->ofs++;
405 }
406
407 static void WCEL_MoveToLeftWord(WCEL_Context* ctx)
408 {
409 int new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
410 if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
411 }
412
413 static void WCEL_MoveToRightWord(WCEL_Context* ctx)
414 {
415 int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
416 if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
417 }
418
419 static void WCEL_MoveToBeg(WCEL_Context* ctx)
420 {
421 ctx->ofs = 0;
422 }
423
424 static void WCEL_MoveToEnd(WCEL_Context* ctx)
425 {
426 ctx->ofs = ctx->len;
427 }
428
429 static void WCEL_SetMark(WCEL_Context* ctx)
430 {
431 ctx->mark = ctx->ofs;
432 }
433
434 static void WCEL_ExchangeMark(WCEL_Context* ctx)
435 {
436 unsigned tmp;
437
438 if (ctx->mark > ctx->len) return;
439 tmp = ctx->ofs;
440 ctx->ofs = ctx->mark;
441 ctx->mark = tmp;
442 }
443
444 static void WCEL_CopyMarkedZone(WCEL_Context* ctx)
445 {
446 unsigned beg, end;
447
448 if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
449 if (ctx->mark > ctx->ofs)
450 {
451 beg = ctx->ofs; end = ctx->mark;
452 }
453 else
454 {
455 beg = ctx->mark; end = ctx->ofs;
456 }
457 WCEL_SaveYank(ctx, beg, end);
458 }
459
460 static void WCEL_TransposeChar(WCEL_Context* ctx)
461 {
462 WCHAR c;
463
464 if (!ctx->ofs || ctx->ofs == ctx->len) return;
465
466 c = ctx->line[ctx->ofs];
467 ctx->line[ctx->ofs] = ctx->line[ctx->ofs - 1];
468 ctx->line[ctx->ofs - 1] = c;
469
470 WCEL_Update(ctx, ctx->ofs - 1, 2);
471 ctx->ofs++;
472 }
473
474 static void WCEL_TransposeWords(WCEL_Context* ctx)
475 {
476 int left_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs),
477 right_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
478 if (left_ofs < ctx->ofs && right_ofs > ctx->ofs)
479 {
480 unsigned len_r = right_ofs - ctx->ofs;
481 unsigned len_l = ctx->ofs - left_ofs;
482
483 char* tmp = HeapAlloc(GetProcessHeap(), 0, len_r * sizeof(WCHAR));
484 if (!tmp) return;
485
486 memcpy(tmp, &ctx->line[ctx->ofs], len_r * sizeof(WCHAR));
487 memmove(&ctx->line[left_ofs + len_r], &ctx->line[left_ofs], len_l * sizeof(WCHAR));
488 memcpy(&ctx->line[left_ofs], tmp, len_r * sizeof(WCHAR));
489
490 HeapFree(GetProcessHeap(), 0, tmp);
491 WCEL_Update(ctx, left_ofs, len_l + len_r);
492 ctx->ofs = right_ofs;
493 }
494 }
495
496 static void WCEL_LowerCaseWord(WCEL_Context* ctx)
497 {
498 int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
499 if (new_ofs != ctx->ofs)
500 {
501 int i;
502 for (i = ctx->ofs; i <= new_ofs; i++)
503 ctx->line[i] = tolowerW(ctx->line[i]);
504 WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
505 ctx->ofs = new_ofs;
506 }
507 }
508
509 static void WCEL_UpperCaseWord(WCEL_Context* ctx)
510 {
511 int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
512 if (new_ofs != ctx->ofs)
513 {
514 int i;
515 for (i = ctx->ofs; i <= new_ofs; i++)
516 ctx->line[i] = toupperW(ctx->line[i]);
517 WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
518 ctx->ofs = new_ofs;
519 }
520 }
521
522 static void WCEL_CapitalizeWord(WCEL_Context* ctx)
523 {
524 int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
525 if (new_ofs != ctx->ofs)
526 {
527 int i;
528
529 ctx->line[ctx->ofs] = toupperW(ctx->line[ctx->ofs]);
530 for (i = ctx->ofs + 1; i <= new_ofs; i++)
531 ctx->line[i] = tolowerW(ctx->line[i]);
532 WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
533 ctx->ofs = new_ofs;
534 }
535 }
536
537 static void WCEL_Yank(WCEL_Context* ctx)
538 {
539 WCEL_InsertString(ctx, ctx->yanked);
540 }
541
542 static void WCEL_KillToEndOfLine(WCEL_Context* ctx)
543 {
544 WCEL_SaveYank(ctx, ctx->ofs, ctx->len);
545 WCEL_DeleteString(ctx, ctx->ofs, ctx->len);
546 }
547
548 static void WCEL_KillMarkedZone(WCEL_Context* ctx)
549 {
550 unsigned beg, end;
551
552 if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
553 if (ctx->mark > ctx->ofs)
554 {
555 beg = ctx->ofs; end = ctx->mark;
556 }
557 else
558 {
559 beg = ctx->mark; end = ctx->ofs;
560 }
561 WCEL_SaveYank(ctx, beg, end);
562 WCEL_DeleteString(ctx, beg, end);
563 ctx->ofs = beg;
564 }
565
566 static void WCEL_DeletePrevChar(WCEL_Context* ctx)
567 {
568 if (ctx->ofs)
569 {
570 WCEL_DeleteString(ctx, ctx->ofs - 1, ctx->ofs);
571 ctx->ofs--;
572 }
573 }
574
575 static void WCEL_DeleteCurrChar(WCEL_Context* ctx)
576 {
577 if (ctx->ofs < ctx->len)
578 WCEL_DeleteString(ctx, ctx->ofs, ctx->ofs + 1);
579 }
580
581 static void WCEL_DeleteLeftWord(WCEL_Context* ctx)
582 {
583 int new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
584 if (new_ofs != ctx->ofs)
585 {
586 WCEL_DeleteString(ctx, new_ofs, ctx->ofs);
587 ctx->ofs = new_ofs;
588 }
589 }
590
591 static void WCEL_DeleteRightWord(WCEL_Context* ctx)
592 {
593 int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
594 if (new_ofs != ctx->ofs)
595 {
596 WCEL_DeleteString(ctx, ctx->ofs, new_ofs);
597 }
598 }
599
600 static void WCEL_MoveToPrevHist(WCEL_Context* ctx)
601 {
602 if (ctx->histPos) WCEL_MoveToHist(ctx, ctx->histPos - 1);
603 }
604
605 static void WCEL_MoveToNextHist(WCEL_Context* ctx)
606 {
607 if (ctx->histPos < ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histPos + 1);
608 }
609
610 static void WCEL_MoveToFirstHist(WCEL_Context* ctx)
611 {
612 if (ctx->histPos != 0) WCEL_MoveToHist(ctx, 0);
613 }
614
615 static void WCEL_MoveToLastHist(WCEL_Context* ctx)
616 {
617 if (ctx->histPos != ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histSize - 1);
618 }
619
620 static void WCEL_Redraw(WCEL_Context* ctx)
621 {
622 COORD c = WCEL_GetCoord(ctx, ctx->len);
623 CHAR_INFO ci;
624
625 WCEL_Update(ctx, 0, ctx->len);
626
627 ci.Char.UnicodeChar = ' ';
628 ci.Attributes = ctx->csbi.wAttributes;
629
630 CONSOLE_FillLineUniform(ctx->hConOut, c.X, c.Y, ctx->csbi.dwSize.X - c.X, &ci);
631 }
632
633 static void WCEL_RepeatCount(WCEL_Context* ctx)
634 {
635 #if 0
636 /* FIXME: wait untill all console code is in kernel32 */
637 INPUT_RECORD ir;
638 unsigned repeat = 0;
639
640 while (WCEL_Get(ctx, &ir, FALSE))
641 {
642 if (ir.EventType != KEY_EVENT) break;
643 if (ir.Event.KeyEvent.bKeyDown)
644 {
645 if ((ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON)) != 0)
646 break;
647 if (ir.Event.KeyEvent.uChar.UnicodeChar < '0' ||
648 ir.Event.KeyEvent.uChar.UnicodeChar > '9')
649 break;
650 repeat = repeat * 10 + ir.Event.KeyEvent.uChar.UnicodeChar - '0';
651 }
652 WCEL_Get(ctx, &ir, TRUE);
653 }
654 FIXME("=> %u\n", repeat);
655 #endif
656 }
657
658 /* ====================================================================
659 *
660 * Key Maps
661 *
662 * ====================================================================*/
663
664 #define CTRL(x) ((x) - '@')
665 static KeyEntry StdKeyMap[] =
666 {
667 {/*BACK*/0x08, WCEL_DeletePrevChar },
668 {/*RETURN*/0x0d, WCEL_Done },
669 {/*DEL*/127, WCEL_DeleteCurrChar },
670 { 0, NULL }
671 };
672
673 static KeyEntry Win32ExtraStdKeyMap[] =
674 {
675 {/*VK_F8*/ 0x77, WCEL_FindPrevInHist },
676 { 0, NULL }
677 };
678
679
680 static KeyEntry EmacsKeyMapCtrl[] =
681 {
682 { CTRL('@'), WCEL_SetMark },
683 { CTRL('A'), WCEL_MoveToBeg },
684 { CTRL('B'), WCEL_MoveLeft },
685 /* C: done in server */
686 { CTRL('D'), WCEL_DeleteCurrChar },
687 { CTRL('E'), WCEL_MoveToEnd },
688 { CTRL('F'), WCEL_MoveRight },
689 { CTRL('G'), WCEL_Beep },
690 { CTRL('H'), WCEL_DeletePrevChar },
691 /* I: meaningless (or tab ???) */
692 { CTRL('J'), WCEL_Done },
693 { CTRL('K'), WCEL_KillToEndOfLine },
694 { CTRL('L'), WCEL_Redraw },
695 { CTRL('M'), WCEL_Done },
696 { CTRL('N'), WCEL_MoveToNextHist },
697 /* O; insert line... meaningless */
698 { CTRL('P'), WCEL_MoveToPrevHist },
699 /* Q: [NIY] quoting... */
700 /* R: [NIY] search backwards... */
701 /* S: [NIY] search forwards... */
702 { CTRL('T'), WCEL_TransposeChar },
703 { CTRL('U'), WCEL_RepeatCount },
704 /* V: paragraph down... meaningless */
705 { CTRL('W'), WCEL_KillMarkedZone },
706 { CTRL('X'), WCEL_ExchangeMark },
707 { CTRL('Y'), WCEL_Yank },
708 /* Z: meaningless */
709 { 0, NULL }
710 };
711
712 static KeyEntry EmacsKeyMapAlt[] =
713 {
714 {/*DEL*/127, WCEL_DeleteLeftWord },
715 { '<', WCEL_MoveToFirstHist },
716 { '>', WCEL_MoveToLastHist },
717 { '?', WCEL_Beep },
718 { 'b', WCEL_MoveToLeftWord },
719 { 'c', WCEL_CapitalizeWord },
720 { 'd', WCEL_DeleteRightWord },
721 { 'f', WCEL_MoveToRightWord },
722 { 'l', WCEL_LowerCaseWord },
723 { 't', WCEL_TransposeWords },
724 { 'u', WCEL_UpperCaseWord },
725 { 'w', WCEL_CopyMarkedZone },
726 { 0, NULL }
727 };
728
729 static KeyEntry EmacsKeyMapExtended[] =
730 {
731 {/*RETURN*/ 0x0d, WCEL_Done },
732 {/*VK_PRIOR*/0x21, WCEL_MoveToPrevHist },
733 {/*VK_NEXT*/ 0x22, WCEL_MoveToNextHist },
734 {/*VK_END*/ 0x23, WCEL_MoveToEnd },
735 {/*VK_HOME*/ 0x24, WCEL_MoveToBeg },
736 {/*VK_RIGHT*/0x27, WCEL_MoveRight },
737 {/*VK_LEFT*/ 0x25, WCEL_MoveLeft },
738 {/*VK_DEL*/ 0x2e, WCEL_DeleteCurrChar },
739 { 0, NULL }
740 };
741
742 static KeyMap EmacsKeyMap[] =
743 {
744 {0x00000000, 1, StdKeyMap},
745 {0x00000001, 1, EmacsKeyMapAlt}, /* left alt */
746 {0x00000002, 1, EmacsKeyMapAlt}, /* right alt */
747 {0x00000004, 1, EmacsKeyMapCtrl}, /* left ctrl */
748 {0x00000008, 1, EmacsKeyMapCtrl}, /* right ctrl */
749 {0x00000100, 0, EmacsKeyMapExtended},
750 {0, 0, 0}
751 };
752
753 static KeyEntry Win32KeyMapExtended[] =
754 {
755 {/*VK_LEFT*/ 0x25, WCEL_MoveLeft },
756 {/*VK_RIGHT*/0x27, WCEL_MoveRight },
757 {/*VK_HOME*/ 0x24, WCEL_MoveToBeg },
758 {/*VK_END*/ 0x23, WCEL_MoveToEnd },
759 {/*VK_UP*/ 0x26, WCEL_MoveToPrevHist },
760 {/*VK_DOWN*/ 0x28, WCEL_MoveToNextHist },
761 {/*VK_DEL*/ 0x2e, WCEL_DeleteCurrChar },
762 { 0, NULL }
763 };
764
765 static KeyEntry Win32KeyMapCtrlExtended[] =
766 {
767 {/*VK_LEFT*/ 0x25, WCEL_MoveToLeftWord },
768 {/*VK_RIGHT*/0x27, WCEL_MoveToRightWord },
769 {/*VK_END*/ 0x23, WCEL_KillToEndOfLine },
770 { 0, NULL }
771 };
772
773 KeyMap Win32KeyMap[] =
774 {
775 {0x00000000, 1, StdKeyMap},
776 {0x00000000, 0, Win32ExtraStdKeyMap},
777 {0x00000100, 0, Win32KeyMapExtended},
778 {0x00000104, 0, Win32KeyMapCtrlExtended},
779 {0x00000108, 0, Win32KeyMapCtrlExtended},
780 {0, 0, 0}
781 };
782 #undef CTRL
783
784 /* ====================================================================
785 *
786 * Read line master function
787 *
788 * ====================================================================*/
789
790 WCHAR* CONSOLE_Readline(HANDLE hConsoleIn)
791 {
792 WCEL_Context ctx;
793 INPUT_RECORD ir;
794 KeyMap* km;
795 KeyEntry* ke;
796 unsigned ofs;
797 void (*func)(struct WCEL_Context* ctx);
798 DWORD ks;
799 int use_emacs;
800
801 memset(&ctx, 0, sizeof(ctx));
802 ctx.hConIn = hConsoleIn;
803 WCEL_HistoryInit(&ctx);
804
805 if (!CONSOLE_GetEditionMode(hConsoleIn, &use_emacs))
806 use_emacs = 0;
807
808 if ((ctx.hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
809 OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE ||
810 !GetConsoleScreenBufferInfo(ctx.hConOut, &ctx.csbi))
811 return NULL;
812 ctx.can_wrap = (GetConsoleMode(ctx.hConOut, &ks) && (ks & ENABLE_WRAP_AT_EOL_OUTPUT)) ? 1 : 0;
813
814 if (!WCEL_Grow(&ctx, 1))
815 {
816 CloseHandle(ctx.hConOut);
817 return NULL;
818 }
819 ctx.line[0] = 0;
820
821 /* EPP WCEL_Dump(&ctx, "init"); */
822
823 while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
824 {
825 if (ir.EventType != KEY_EVENT || !ir.Event.KeyEvent.bKeyDown) continue;
826 TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08lx\n",
827 ir.Event.KeyEvent.bKeyDown ? "Down" : "Up ", ir.Event.KeyEvent.wRepeatCount,
828 ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
829 ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);
830
831 /* EPP WCEL_Dump(&ctx, "before func"); */
832 ofs = ctx.ofs;
833 /* mask out some bits which don't interest us */
834 ks = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON);
835
836 func = NULL;
837 for (km = (use_emacs) ? EmacsKeyMap : Win32KeyMap; km->entries != NULL; km++)
838 {
839 if (km->keyState != ks)
840 continue;
841 if (km->chkChar)
842 {
843 for (ke = &km->entries[0]; ke->func != 0; ke++)
844 if (ke->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
845 }
846 else
847 {
848 for (ke = &km->entries[0]; ke->func != 0; ke++)
849 if (ke->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
850
851 }
852 if (ke->func)
853 {
854 func = ke->func;
855 break;
856 }
857 }
858
859 if (func)
860 (func)(&ctx);
861 else if (!(ir.Event.KeyEvent.dwControlKeyState & (ENHANCED_KEY|LEFT_ALT_PRESSED)))
862 WCEL_InsertChar(&ctx, ir.Event.KeyEvent.uChar.UnicodeChar);
863 else TRACE("Dropped event\n");
864
865 /* EPP WCEL_Dump(&ctx, "after func"); */
866 if (ctx.ofs != ofs)
867 SetConsoleCursorPosition(ctx.hConOut, WCEL_GetCoord(&ctx, ctx.ofs));
868 }
869 if (ctx.error)
870 {
871 HeapFree(GetProcessHeap(), 0, ctx.line);
872 ctx.line = NULL;
873 }
874 WCEL_FreeYank(&ctx);
875 if (ctx.line)
876 CONSOLE_AppendHistory(ctx.line);
877
878 CloseHandle(ctx.hConOut);
879 if (ctx.histCurr) HeapFree(GetProcessHeap(), 0, ctx.histCurr);
880 return ctx.line;
881 }
GSOC 2012 project to enhance the control panel