2 * line edition function for Win32 console
4 * Copyright 2001 Eric Pouech
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.
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.
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
22 #include "wine/port.h"
30 #include "wine/unicode.h"
32 #include "wine/debug.h"
33 #include "console_private.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(console);
41 WCHAR val; /* vk or unicode char */
42 void (*func)(struct WCEL_Context* ctx);
47 DWORD keyState; /* keyState (from INPUT_RECORD) to match */
48 BOOL chkChar; /* check vk or char */
49 KeyEntry* entries; /* array of entries */
52 typedef struct WCEL_Context {
53 WCHAR* line; /* the line being edited */
54 size_t alloc; /* number of WCHAR in line */
55 unsigned len; /* number of chars in line */
56 unsigned ofs; /* offset for cursor in current line */
57 WCHAR* yanked; /* yanked line */
58 unsigned mark; /* marked point (emacs mode only) */
59 CONSOLE_SCREEN_BUFFER_INFO csbi; /* current state (initial cursor, window size, attribute) */
62 unsigned done : 1, /* to 1 when we're done with editing */
63 error : 1, /* to 1 when an error occurred in the editing */
64 can_wrap : 1; /* to 1 when multi-line edition can take place */
71 static void WCEL_Dump(WCEL_Context* ctx, const char* pfx)
73 MESSAGE("%s: [line=%s[alloc=%u] ofs=%u len=%u start=(%d,%d) mask=%c%c%c]\n"
74 "\t\thist=(size=%u pos=%u curr=%s)\n"
76 pfx, debugstr_w(ctx->line), ctx->alloc, ctx->ofs, ctx->len,
77 ctx->csbi.dwCursorPosition.X, ctx->csbi.dwCursorPosition.Y,
78 ctx->done ? 'D' : 'd', ctx->error ? 'E' : 'e', ctx->can_wrap ? 'W' : 'w',
79 ctx->histSize, ctx->histPos, debugstr_w(ctx->histCurr),
80 debugstr_w(ctx->yanked));
84 /* ====================================================================
86 * Console helper functions
88 * ====================================================================*/
90 static BOOL WCEL_Get(WCEL_Context* ctx, INPUT_RECORD* ir)
92 if (ReadConsoleInputW(ctx->hConIn, ir, 1, NULL)) return TRUE;
93 ERR("hmm bad situation\n");
98 static inline void WCEL_Beep(WCEL_Context* ctx)
103 static inline BOOL WCEL_IsSingleLine(WCEL_Context* ctx, size_t len)
105 return ctx->csbi.dwCursorPosition.X + ctx->len + len <= ctx->csbi.dwSize.X;
108 static inline COORD WCEL_GetCoord(WCEL_Context* ctx, int ofs)
111 int len = ctx->csbi.dwSize.X - ctx->csbi.dwCursorPosition.X;
113 c.Y = ctx->csbi.dwCursorPosition.Y;
117 c.X = ofs % ctx->csbi.dwSize.X;
118 c.Y += 1 + ofs / ctx->csbi.dwSize.X;
120 else c.X = ctx->csbi.dwCursorPosition.X + ofs;
124 static inline void WCEL_Update(WCEL_Context* ctx, int beg, int len)
126 WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[beg], len,
127 WCEL_GetCoord(ctx, beg), NULL);
128 FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, len,
129 WCEL_GetCoord(ctx, beg), NULL);
132 /* ====================================================================
134 * context manipulation functions
136 * ====================================================================*/
138 static BOOL WCEL_Grow(WCEL_Context* ctx, size_t len)
140 if (!WCEL_IsSingleLine(ctx, len) && !ctx->can_wrap)
142 FIXME("Mode doesn't allow to wrap. However, we should allow to overwrite current string\n");
146 if (ctx->len + len >= ctx->alloc)
151 /* round up size to 32 byte-WCHAR boundary */
152 newsize = (ctx->len + len + 1 + 31) & ~31;
155 newline = HeapReAlloc(GetProcessHeap(), 0, ctx->line, sizeof(WCHAR) * newsize);
157 newline = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * newsize);
159 if (!newline) return FALSE;
161 ctx->alloc = newsize;
166 static void WCEL_DeleteString(WCEL_Context* ctx, int beg, int end)
168 unsigned str_len = end - beg;
169 COORD cbeg = WCEL_GetCoord(ctx, ctx->len - str_len);
170 COORD cend = WCEL_GetCoord(ctx, ctx->len);
174 memmove(&ctx->line[beg], &ctx->line[end], (ctx->len - end) * sizeof(WCHAR));
175 /* we need to clean from ctx->len - str_len to ctx->len */
177 ci.Char.UnicodeChar = ' ';
178 ci.Attributes = ctx->csbi.wAttributes;
180 if (cbeg.Y == cend.Y)
182 /* partial erase of sole line */
183 CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
184 cend.X - cbeg.X, &ci);
189 /* erase til eol on first line */
190 CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
191 ctx->csbi.dwSize.X - cbeg.X, &ci);
192 /* completely erase all the others (full lines) */
193 for (i = cbeg.Y + 1; i < cend.Y; i++)
194 CONSOLE_FillLineUniform(ctx->hConOut, 0, i, ctx->csbi.dwSize.X, &ci);
195 /* erase from beginning of line until last pos on last line */
196 CONSOLE_FillLineUniform(ctx->hConOut, 0, cend.Y, cend.X, &ci);
199 WCEL_Update(ctx, 0, ctx->len);
200 ctx->line[ctx->len] = 0;
203 static void WCEL_InsertString(WCEL_Context* ctx, const WCHAR* str)
205 size_t len = lstrlenW(str);
207 if (!len || !WCEL_Grow(ctx, len)) return;
208 if (ctx->len > ctx->ofs)
209 memmove(&ctx->line[ctx->ofs + len], &ctx->line[ctx->ofs], (ctx->len - ctx->ofs) * sizeof(WCHAR));
210 memcpy(&ctx->line[ctx->ofs], str, len * sizeof(WCHAR));
212 ctx->line[ctx->len] = 0;
213 WCEL_Update(ctx, ctx->ofs, ctx->len - ctx->ofs);
218 static void WCEL_InsertChar(WCEL_Context* ctx, WCHAR c)
222 /* do not insert 0..31 control characters */
223 if (c < ' ' && c != '\t') return;
227 WCEL_InsertString(ctx, buffer);
230 static void WCEL_FreeYank(WCEL_Context* ctx)
232 HeapFree(GetProcessHeap(), 0, ctx->yanked);
236 static void WCEL_SaveYank(WCEL_Context* ctx, int beg, int end)
239 if (len <= 0) return;
242 /* After WCEL_FreeYank ctx->yanked is empty */
243 ctx->yanked = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
244 if (!ctx->yanked) return;
245 memcpy(ctx->yanked, &ctx->line[beg], len * sizeof(WCHAR));
246 ctx->yanked[len] = 0;
249 /* FIXME NTDLL doesn't export iswalnum, and I don't want to link in msvcrt when most
250 * of the data lay in unicode lib
252 static inline BOOL WCEL_iswalnum(WCHAR wc)
254 return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
257 static int WCEL_GetLeftWordTransition(WCEL_Context* ctx, int ofs)
260 while (ofs >= 0 && !WCEL_iswalnum(ctx->line[ofs])) ofs--;
261 while (ofs >= 0 && WCEL_iswalnum(ctx->line[ofs])) ofs--;
266 static int WCEL_GetRightWordTransition(WCEL_Context* ctx, int ofs)
269 while (ofs <= ctx->len && WCEL_iswalnum(ctx->line[ofs])) ofs++;
270 while (ofs <= ctx->len && !WCEL_iswalnum(ctx->line[ofs])) ofs++;
271 return min(ofs, ctx->len);
274 static WCHAR* WCEL_GetHistory(WCEL_Context* ctx, int idx)
278 if (idx == ctx->histSize - 1)
280 ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(ctx->histCurr) + 1) * sizeof(WCHAR));
281 lstrcpyW(ptr, ctx->histCurr);
285 int len = CONSOLE_GetHistory(idx, NULL, 0);
287 if ((ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
289 CONSOLE_GetHistory(idx, ptr, len);
295 static void WCEL_HistoryInit(WCEL_Context* ctx)
297 ctx->histPos = CONSOLE_GetNumHistoryEntries();
298 ctx->histSize = ctx->histPos + 1;
299 ctx->histCurr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR));
302 static void WCEL_MoveToHist(WCEL_Context* ctx, int idx)
304 WCHAR* data = WCEL_GetHistory(ctx, idx);
305 int len = lstrlenW(data) + 1;
307 /* save current line edition for recall when needed (FIXME seems broken to me) */
308 if (ctx->histPos == ctx->histSize - 1)
310 HeapFree(GetProcessHeap(), 0, ctx->histCurr);
311 ctx->histCurr = HeapAlloc(GetProcessHeap(), 0, (ctx->len + 1) * sizeof(WCHAR));
312 memcpy(ctx->histCurr, ctx->line, (ctx->len + 1) * sizeof(WCHAR));
314 /* need to clean also the screen if new string is shorter than old one */
315 WCEL_DeleteString(ctx, 0, ctx->len);
317 /* insert new string */
318 if (WCEL_Grow(ctx, len))
320 WCEL_InsertString(ctx, data);
321 HeapFree(GetProcessHeap(), 0, data);
326 static void WCEL_FindPrevInHist(WCEL_Context* ctx)
328 int startPos = ctx->histPos;
330 unsigned int len, oldofs;
332 if (ctx->histPos && ctx->histPos == ctx->histSize) {
338 data = WCEL_GetHistory(ctx, ctx->histPos);
340 if (ctx->histPos) ctx->histPos--;
341 else ctx->histPos = (ctx->histSize-1);
343 len = lstrlenW(data) + 1;
344 if ((len >= ctx->ofs) &&
345 (memcmp(ctx->line, data, ctx->ofs * sizeof(WCHAR)) == 0)) {
347 /* need to clean also the screen if new string is shorter than old one */
348 WCEL_DeleteString(ctx, 0, ctx->len);
350 if (WCEL_Grow(ctx, len))
354 WCEL_InsertString(ctx, data);
356 SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
357 HeapFree(GetProcessHeap(), 0, data);
361 } while (ctx->histPos != startPos);
366 /* ====================================================================
368 * basic edition functions
370 * ====================================================================*/
372 static void WCEL_Done(WCEL_Context* ctx)
375 if (!WCEL_Grow(ctx, 2)) return;
376 ctx->line[ctx->len++] = '\r';
377 ctx->line[ctx->len++] = '\n';
378 ctx->line[ctx->len] = 0;
379 WriteConsoleW(ctx->hConOut, &nl, 1, NULL, NULL);
383 static void WCEL_MoveLeft(WCEL_Context* ctx)
385 if (ctx->ofs > 0) ctx->ofs--;
388 static void WCEL_MoveRight(WCEL_Context* ctx)
390 if (ctx->ofs < ctx->len) ctx->ofs++;
393 static void WCEL_MoveToLeftWord(WCEL_Context* ctx)
395 unsigned int new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
396 if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
399 static void WCEL_MoveToRightWord(WCEL_Context* ctx)
401 unsigned int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
402 if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
405 static void WCEL_MoveToBeg(WCEL_Context* ctx)
410 static void WCEL_MoveToEnd(WCEL_Context* ctx)
415 static void WCEL_SetMark(WCEL_Context* ctx)
417 ctx->mark = ctx->ofs;
420 static void WCEL_ExchangeMark(WCEL_Context* ctx)
424 if (ctx->mark > ctx->len) return;
426 ctx->ofs = ctx->mark;
430 static void WCEL_CopyMarkedZone(WCEL_Context* ctx)
434 if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
435 if (ctx->mark > ctx->ofs)
437 beg = ctx->ofs; end = ctx->mark;
441 beg = ctx->mark; end = ctx->ofs;
443 WCEL_SaveYank(ctx, beg, end);
446 static void WCEL_TransposeChar(WCEL_Context* ctx)
450 if (!ctx->ofs || ctx->ofs == ctx->len) return;
452 c = ctx->line[ctx->ofs];
453 ctx->line[ctx->ofs] = ctx->line[ctx->ofs - 1];
454 ctx->line[ctx->ofs - 1] = c;
456 WCEL_Update(ctx, ctx->ofs - 1, 2);
460 static void WCEL_TransposeWords(WCEL_Context* ctx)
462 unsigned int left_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs),
463 right_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
464 if (left_ofs < ctx->ofs && right_ofs > ctx->ofs)
466 unsigned len_r = right_ofs - ctx->ofs;
467 unsigned len_l = ctx->ofs - left_ofs;
469 char* tmp = HeapAlloc(GetProcessHeap(), 0, len_r * sizeof(WCHAR));
472 memcpy(tmp, &ctx->line[ctx->ofs], len_r * sizeof(WCHAR));
473 memmove(&ctx->line[left_ofs + len_r], &ctx->line[left_ofs], len_l * sizeof(WCHAR));
474 memcpy(&ctx->line[left_ofs], tmp, len_r * sizeof(WCHAR));
476 HeapFree(GetProcessHeap(), 0, tmp);
477 WCEL_Update(ctx, left_ofs, len_l + len_r);
478 ctx->ofs = right_ofs;
482 static void WCEL_LowerCaseWord(WCEL_Context* ctx)
484 unsigned int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
485 if (new_ofs != ctx->ofs)
488 for (i = ctx->ofs; i <= new_ofs; i++)
489 ctx->line[i] = tolowerW(ctx->line[i]);
490 WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
495 static void WCEL_UpperCaseWord(WCEL_Context* ctx)
497 unsigned int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
498 if (new_ofs != ctx->ofs)
501 for (i = ctx->ofs; i <= new_ofs; i++)
502 ctx->line[i] = toupperW(ctx->line[i]);
503 WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
508 static void WCEL_CapitalizeWord(WCEL_Context* ctx)
510 unsigned int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
511 if (new_ofs != ctx->ofs)
515 ctx->line[ctx->ofs] = toupperW(ctx->line[ctx->ofs]);
516 for (i = ctx->ofs + 1; i <= new_ofs; i++)
517 ctx->line[i] = tolowerW(ctx->line[i]);
518 WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
523 static void WCEL_Yank(WCEL_Context* ctx)
525 WCEL_InsertString(ctx, ctx->yanked);
528 static void WCEL_KillToEndOfLine(WCEL_Context* ctx)
530 WCEL_SaveYank(ctx, ctx->ofs, ctx->len);
531 WCEL_DeleteString(ctx, ctx->ofs, ctx->len);
534 static void WCEL_KillMarkedZone(WCEL_Context* ctx)
538 if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
539 if (ctx->mark > ctx->ofs)
541 beg = ctx->ofs; end = ctx->mark;
545 beg = ctx->mark; end = ctx->ofs;
547 WCEL_SaveYank(ctx, beg, end);
548 WCEL_DeleteString(ctx, beg, end);
552 static void WCEL_DeletePrevChar(WCEL_Context* ctx)
556 WCEL_DeleteString(ctx, ctx->ofs - 1, ctx->ofs);
561 static void WCEL_DeleteCurrChar(WCEL_Context* ctx)
563 if (ctx->ofs < ctx->len)
564 WCEL_DeleteString(ctx, ctx->ofs, ctx->ofs + 1);
567 static void WCEL_DeleteLeftWord(WCEL_Context* ctx)
569 unsigned int new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
570 if (new_ofs != ctx->ofs)
572 WCEL_DeleteString(ctx, new_ofs, ctx->ofs);
577 static void WCEL_DeleteRightWord(WCEL_Context* ctx)
579 unsigned int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
580 if (new_ofs != ctx->ofs)
582 WCEL_DeleteString(ctx, ctx->ofs, new_ofs);
586 static void WCEL_MoveToPrevHist(WCEL_Context* ctx)
588 if (ctx->histPos) WCEL_MoveToHist(ctx, ctx->histPos - 1);
591 static void WCEL_MoveToNextHist(WCEL_Context* ctx)
593 if (ctx->histPos < ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histPos + 1);
596 static void WCEL_MoveToFirstHist(WCEL_Context* ctx)
598 if (ctx->histPos != 0) WCEL_MoveToHist(ctx, 0);
601 static void WCEL_MoveToLastHist(WCEL_Context* ctx)
603 if (ctx->histPos != ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histSize - 1);
606 static void WCEL_Redraw(WCEL_Context* ctx)
608 COORD c = WCEL_GetCoord(ctx, ctx->len);
611 WCEL_Update(ctx, 0, ctx->len);
613 ci.Char.UnicodeChar = ' ';
614 ci.Attributes = ctx->csbi.wAttributes;
616 CONSOLE_FillLineUniform(ctx->hConOut, c.X, c.Y, ctx->csbi.dwSize.X - c.X, &ci);
619 static void WCEL_RepeatCount(WCEL_Context* ctx)
622 /* FIXME: wait until all console code is in kernel32 */
626 while (WCEL_Get(ctx, &ir, FALSE))
628 if (ir.EventType != KEY_EVENT) break;
629 if (ir.Event.KeyEvent.bKeyDown)
631 if ((ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON)) != 0)
633 if (ir.Event.KeyEvent.uChar.UnicodeChar < '0' ||
634 ir.Event.KeyEvent.uChar.UnicodeChar > '9')
636 repeat = repeat * 10 + ir.Event.KeyEvent.uChar.UnicodeChar - '0';
638 WCEL_Get(ctx, &ir, TRUE);
640 FIXME("=> %u\n", repeat);
644 /* ====================================================================
648 * ====================================================================*/
650 #define CTRL(x) ((x) - '@')
651 static KeyEntry StdKeyMap[] =
653 {/*BACK*/0x08, WCEL_DeletePrevChar },
654 {/*RETURN*/0x0d, WCEL_Done },
655 {/*DEL*/127, WCEL_DeleteCurrChar },
659 static KeyEntry Win32ExtraStdKeyMap[] =
661 {/*VK_F8*/ 0x77, WCEL_FindPrevInHist },
666 static KeyEntry EmacsKeyMapCtrl[] =
668 { CTRL('@'), WCEL_SetMark },
669 { CTRL('A'), WCEL_MoveToBeg },
670 { CTRL('B'), WCEL_MoveLeft },
671 /* C: done in server */
672 { CTRL('D'), WCEL_DeleteCurrChar },
673 { CTRL('E'), WCEL_MoveToEnd },
674 { CTRL('F'), WCEL_MoveRight },
675 { CTRL('G'), WCEL_Beep },
676 { CTRL('H'), WCEL_DeletePrevChar },
677 /* I: meaningless (or tab ???) */
678 { CTRL('J'), WCEL_Done },
679 { CTRL('K'), WCEL_KillToEndOfLine },
680 { CTRL('L'), WCEL_Redraw },
681 { CTRL('M'), WCEL_Done },
682 { CTRL('N'), WCEL_MoveToNextHist },
683 /* O; insert line... meaningless */
684 { CTRL('P'), WCEL_MoveToPrevHist },
685 /* Q: [NIY] quoting... */
686 /* R: [NIY] search backwards... */
687 /* S: [NIY] search forwards... */
688 { CTRL('T'), WCEL_TransposeChar },
689 { CTRL('U'), WCEL_RepeatCount },
690 /* V: paragraph down... meaningless */
691 { CTRL('W'), WCEL_KillMarkedZone },
692 { CTRL('X'), WCEL_ExchangeMark },
693 { CTRL('Y'), WCEL_Yank },
698 static KeyEntry EmacsKeyMapAlt[] =
700 {/*DEL*/127, WCEL_DeleteLeftWord },
701 { '<', WCEL_MoveToFirstHist },
702 { '>', WCEL_MoveToLastHist },
704 { 'b', WCEL_MoveToLeftWord },
705 { 'c', WCEL_CapitalizeWord },
706 { 'd', WCEL_DeleteRightWord },
707 { 'f', WCEL_MoveToRightWord },
708 { 'l', WCEL_LowerCaseWord },
709 { 't', WCEL_TransposeWords },
710 { 'u', WCEL_UpperCaseWord },
711 { 'w', WCEL_CopyMarkedZone },
715 static KeyEntry EmacsKeyMapExtended[] =
717 {/*RETURN*/ 0x0d, WCEL_Done },
718 {/*VK_PRIOR*/0x21, WCEL_MoveToPrevHist },
719 {/*VK_NEXT*/ 0x22, WCEL_MoveToNextHist },
720 {/*VK_END*/ 0x23, WCEL_MoveToEnd },
721 {/*VK_HOME*/ 0x24, WCEL_MoveToBeg },
722 {/*VK_RIGHT*/0x27, WCEL_MoveRight },
723 {/*VK_LEFT*/ 0x25, WCEL_MoveLeft },
724 {/*VK_DEL*/ 0x2e, WCEL_DeleteCurrChar },
728 static KeyMap EmacsKeyMap[] =
730 {0x00000000, 1, StdKeyMap},
731 {0x00000001, 1, EmacsKeyMapAlt}, /* left alt */
732 {0x00000002, 1, EmacsKeyMapAlt}, /* right alt */
733 {0x00000004, 1, EmacsKeyMapCtrl}, /* left ctrl */
734 {0x00000008, 1, EmacsKeyMapCtrl}, /* right ctrl */
735 {0x00000100, 0, EmacsKeyMapExtended},
739 static KeyEntry Win32KeyMapExtended[] =
741 {/*VK_LEFT*/ 0x25, WCEL_MoveLeft },
742 {/*VK_RIGHT*/0x27, WCEL_MoveRight },
743 {/*VK_HOME*/ 0x24, WCEL_MoveToBeg },
744 {/*VK_END*/ 0x23, WCEL_MoveToEnd },
745 {/*VK_UP*/ 0x26, WCEL_MoveToPrevHist },
746 {/*VK_DOWN*/ 0x28, WCEL_MoveToNextHist },
747 {/*VK_DEL*/ 0x2e, WCEL_DeleteCurrChar },
751 static KeyEntry Win32KeyMapCtrlExtended[] =
753 {/*VK_LEFT*/ 0x25, WCEL_MoveToLeftWord },
754 {/*VK_RIGHT*/0x27, WCEL_MoveToRightWord },
755 {/*VK_END*/ 0x23, WCEL_KillToEndOfLine },
759 KeyMap Win32KeyMap[] =
761 {0x00000000, 1, StdKeyMap},
762 {0x00000000, 0, Win32ExtraStdKeyMap},
763 {0x00000100, 0, Win32KeyMapExtended},
764 {0x00000104, 0, Win32KeyMapCtrlExtended},
765 {0x00000108, 0, Win32KeyMapCtrlExtended},
770 /* ====================================================================
772 * Read line master function
774 * ====================================================================*/
776 WCHAR* CONSOLE_Readline(HANDLE hConsoleIn)
783 void (*func)(struct WCEL_Context* ctx);
787 memset(&ctx, 0, sizeof(ctx));
788 ctx.hConIn = hConsoleIn;
789 WCEL_HistoryInit(&ctx);
791 if (!CONSOLE_GetEditionMode(hConsoleIn, &use_emacs))
794 if ((ctx.hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
795 OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE ||
796 !GetConsoleScreenBufferInfo(ctx.hConOut, &ctx.csbi))
798 ctx.can_wrap = (GetConsoleMode(ctx.hConOut, &ks) && (ks & ENABLE_WRAP_AT_EOL_OUTPUT)) ? 1 : 0;
800 if (!WCEL_Grow(&ctx, 1))
802 CloseHandle(ctx.hConOut);
807 /* EPP WCEL_Dump(&ctx, "init"); */
809 while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
811 if (ir.EventType != KEY_EVENT) continue;
812 TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08lx\n",
813 ir.Event.KeyEvent.bKeyDown ? "Down" : "Up ", ir.Event.KeyEvent.wRepeatCount,
814 ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
815 ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);
816 if (!ir.Event.KeyEvent.bKeyDown) continue;
818 /* EPP WCEL_Dump(&ctx, "before func"); */
820 /* mask out some bits which don't interest us */
821 ks = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON);
824 for (km = (use_emacs) ? EmacsKeyMap : Win32KeyMap; km->entries != NULL; km++)
826 if (km->keyState != ks)
830 for (ke = &km->entries[0]; ke->func != 0; ke++)
831 if (ke->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
835 for (ke = &km->entries[0]; ke->func != 0; ke++)
836 if (ke->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
848 else if (!(ir.Event.KeyEvent.dwControlKeyState & (ENHANCED_KEY|LEFT_ALT_PRESSED)))
849 WCEL_InsertChar(&ctx, ir.Event.KeyEvent.uChar.UnicodeChar);
850 else TRACE("Dropped event\n");
852 /* EPP WCEL_Dump(&ctx, "after func"); */
854 SetConsoleCursorPosition(ctx.hConOut, WCEL_GetCoord(&ctx, ctx.ofs));
858 HeapFree(GetProcessHeap(), 0, ctx.line);
863 CONSOLE_AppendHistory(ctx.line);
865 CloseHandle(ctx.hConOut);
866 HeapFree(GetProcessHeap(), 0, ctx.histCurr);