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