[CONSRV]
[reactos.git] / win32ss / user / consrv / lineinput.c
1 /*
2 * LICENSE: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Console Server DLL
4 * FILE: win32ss/user/consrv/tuiconsole.c
5 * PURPOSE: Console line input functions
6 * PROGRAMMERS: Jeffrey Morlan
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "consrv.h"
12 #include "conio.h"
13
14 #define NDEBUG
15 #include <debug.h>
16
17 typedef struct _HISTORY_BUFFER
18 {
19 LIST_ENTRY ListEntry;
20 UINT Position;
21 UINT MaxEntries;
22 UINT NumEntries;
23 PUNICODE_STRING Entries;
24 UNICODE_STRING ExeName;
25 } HISTORY_BUFFER, *PHISTORY_BUFFER;
26
27 /* FUNCTIONS *****************************************************************/
28
29 static PHISTORY_BUFFER
30 HistoryCurrentBuffer(PCONSOLE Console)
31 {
32 /* TODO: use actual EXE name sent from process that called ReadConsole */
33 UNICODE_STRING ExeName = { 14, 14, L"cmd.exe" };
34 PLIST_ENTRY Entry = Console->HistoryBuffers.Flink;
35 PHISTORY_BUFFER Hist;
36
37 for (; Entry != &Console->HistoryBuffers; Entry = Entry->Flink)
38 {
39 Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
40 if (RtlEqualUnicodeString(&ExeName, &Hist->ExeName, FALSE))
41 return Hist;
42 }
43
44 /* Couldn't find the buffer, create a new one */
45 Hist = HeapAlloc(ConSrvHeap, 0, sizeof(HISTORY_BUFFER) + ExeName.Length);
46 if (!Hist)
47 return NULL;
48 Hist->MaxEntries = Console->HistoryBufferSize;
49 Hist->NumEntries = 0;
50 Hist->Entries = HeapAlloc(ConSrvHeap, 0, Hist->MaxEntries * sizeof(UNICODE_STRING));
51 if (!Hist->Entries)
52 {
53 HeapFree(ConSrvHeap, 0, Hist);
54 return NULL;
55 }
56 Hist->ExeName.Length = Hist->ExeName.MaximumLength = ExeName.Length;
57 Hist->ExeName.Buffer = (PWCHAR)(Hist + 1);
58 memcpy(Hist->ExeName.Buffer, ExeName.Buffer, ExeName.Length);
59 InsertHeadList(&Console->HistoryBuffers, &Hist->ListEntry);
60 return Hist;
61 }
62
63 static VOID
64 HistoryAddEntry(PCONSOLE Console)
65 {
66 UNICODE_STRING NewEntry;
67 PHISTORY_BUFFER Hist;
68 INT i;
69
70 NewEntry.Length = NewEntry.MaximumLength = Console->LineSize * sizeof(WCHAR);
71 NewEntry.Buffer = Console->LineBuffer;
72
73 if (!(Hist = HistoryCurrentBuffer(Console)))
74 return;
75
76 /* Don't add blank or duplicate entries */
77 if (NewEntry.Length == 0 || Hist->MaxEntries == 0 ||
78 (Hist->NumEntries > 0 &&
79 RtlEqualUnicodeString(&Hist->Entries[Hist->NumEntries - 1], &NewEntry, FALSE)))
80 {
81 return;
82 }
83
84 if (Console->HistoryNoDup)
85 {
86 /* Check if this line has been entered before */
87 for (i = Hist->NumEntries - 1; i >= 0; i--)
88 {
89 if (RtlEqualUnicodeString(&Hist->Entries[i], &NewEntry, FALSE))
90 {
91 /* Just rotate the list to bring this entry to the end */
92 NewEntry = Hist->Entries[i];
93 memmove(&Hist->Entries[i], &Hist->Entries[i + 1],
94 (Hist->NumEntries - (i + 1)) * sizeof(UNICODE_STRING));
95 Hist->Entries[Hist->NumEntries - 1] = NewEntry;
96 Hist->Position = Hist->NumEntries - 1;
97 return;
98 }
99 }
100 }
101
102 if (Hist->NumEntries == Hist->MaxEntries)
103 {
104 /* List is full, remove oldest entry */
105 RtlFreeUnicodeString(&Hist->Entries[0]);
106 memmove(&Hist->Entries[0], &Hist->Entries[1],
107 --Hist->NumEntries * sizeof(UNICODE_STRING));
108 }
109
110 if (NT_SUCCESS(RtlDuplicateUnicodeString(0, &NewEntry, &Hist->Entries[Hist->NumEntries])))
111 Hist->NumEntries++;
112 Hist->Position = Hist->NumEntries - 1;
113 }
114
115 static VOID
116 HistoryGetCurrentEntry(PCONSOLE Console, PUNICODE_STRING Entry)
117 {
118 PHISTORY_BUFFER Hist;
119 if (!(Hist = HistoryCurrentBuffer(Console)) || Hist->NumEntries == 0)
120 Entry->Length = 0;
121 else
122 *Entry = Hist->Entries[Hist->Position];
123 }
124
125 static PHISTORY_BUFFER
126 HistoryFindBuffer(PCONSOLE Console, PUNICODE_STRING ExeName)
127 {
128 PLIST_ENTRY Entry = Console->HistoryBuffers.Flink;
129 while (Entry != &Console->HistoryBuffers)
130 {
131 /* For the history APIs, the caller is allowed to give only part of the name */
132 PHISTORY_BUFFER Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
133 if (RtlPrefixUnicodeString(ExeName, &Hist->ExeName, TRUE))
134 return Hist;
135 Entry = Entry->Flink;
136 }
137 return NULL;
138 }
139
140 VOID FASTCALL
141 HistoryDeleteBuffer(PHISTORY_BUFFER Hist)
142 {
143 if (!Hist)
144 return;
145 while (Hist->NumEntries != 0)
146 RtlFreeUnicodeString(&Hist->Entries[--Hist->NumEntries]);
147 HeapFree(ConSrvHeap, 0, Hist->Entries);
148 RemoveEntryList(&Hist->ListEntry);
149 HeapFree(ConSrvHeap, 0, Hist);
150 }
151
152 CSR_API(SrvGetConsoleCommandHistoryLength)
153 {
154 PCONSOLE_GETCOMMANDHISTORYLENGTH GetCommandHistoryLengthRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetCommandHistoryLengthRequest;
155 PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
156 PCONSOLE Console;
157 NTSTATUS Status;
158 PHISTORY_BUFFER Hist;
159 ULONG Length = 0;
160 INT i;
161
162 if (!CsrValidateMessageBuffer(ApiMessage,
163 (PVOID*)&GetCommandHistoryLengthRequest->ExeName.Buffer,
164 GetCommandHistoryLengthRequest->ExeName.Length,
165 sizeof(BYTE)))
166 {
167 return STATUS_INVALID_PARAMETER;
168 }
169
170 Status = ConioConsoleFromProcessData(ProcessData, &Console);
171 if (NT_SUCCESS(Status))
172 {
173 Hist = HistoryFindBuffer(Console, &GetCommandHistoryLengthRequest->ExeName);
174 if (Hist)
175 {
176 for (i = 0; i < Hist->NumEntries; i++)
177 Length += Hist->Entries[i].Length + sizeof(WCHAR);
178 }
179 GetCommandHistoryLengthRequest->Length = Length;
180 ConioUnlockConsole(Console);
181 }
182 return Status;
183 }
184
185 CSR_API(SrvGetConsoleCommandHistory)
186 {
187 PCONSOLE_GETCOMMANDHISTORY GetCommandHistoryRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetCommandHistoryRequest;
188 PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
189 PCONSOLE Console;
190 NTSTATUS Status;
191 PHISTORY_BUFFER Hist;
192 PBYTE Buffer = (PBYTE)GetCommandHistoryRequest->History;
193 ULONG BufferSize = GetCommandHistoryRequest->Length;
194 INT i;
195
196 if ( !CsrValidateMessageBuffer(ApiMessage,
197 (PVOID*)&GetCommandHistoryRequest->History,
198 GetCommandHistoryRequest->Length,
199 sizeof(BYTE)) ||
200 !CsrValidateMessageBuffer(ApiMessage,
201 (PVOID*)&GetCommandHistoryRequest->ExeName.Buffer,
202 GetCommandHistoryRequest->ExeName.Length,
203 sizeof(BYTE)) )
204 {
205 return STATUS_INVALID_PARAMETER;
206 }
207
208 Status = ConioConsoleFromProcessData(ProcessData, &Console);
209 if (NT_SUCCESS(Status))
210 {
211 Hist = HistoryFindBuffer(Console, &GetCommandHistoryRequest->ExeName);
212 if (Hist)
213 {
214 for (i = 0; i < Hist->NumEntries; i++)
215 {
216 if (BufferSize < (Hist->Entries[i].Length + sizeof(WCHAR)))
217 {
218 Status = STATUS_BUFFER_OVERFLOW;
219 break;
220 }
221 memcpy(Buffer, Hist->Entries[i].Buffer, Hist->Entries[i].Length);
222 Buffer += Hist->Entries[i].Length;
223 *(PWCHAR)Buffer = L'\0';
224 Buffer += sizeof(WCHAR);
225 }
226 }
227 GetCommandHistoryRequest->Length = Buffer - (PBYTE)GetCommandHistoryRequest->History;
228 ConioUnlockConsole(Console);
229 }
230 return Status;
231 }
232
233 CSR_API(SrvExpungeConsoleCommandHistory)
234 {
235 PCONSOLE_EXPUNGECOMMANDHISTORY ExpungeCommandHistoryRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.ExpungeCommandHistoryRequest;
236 PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
237 PCONSOLE Console;
238 PHISTORY_BUFFER Hist;
239 NTSTATUS Status;
240
241 if (!CsrValidateMessageBuffer(ApiMessage,
242 (PVOID*)&ExpungeCommandHistoryRequest->ExeName.Buffer,
243 ExpungeCommandHistoryRequest->ExeName.Length,
244 sizeof(BYTE)))
245 {
246 return STATUS_INVALID_PARAMETER;
247 }
248
249 Status = ConioConsoleFromProcessData(ProcessData, &Console);
250 if (NT_SUCCESS(Status))
251 {
252 Hist = HistoryFindBuffer(Console, &ExpungeCommandHistoryRequest->ExeName);
253 HistoryDeleteBuffer(Hist);
254 ConioUnlockConsole(Console);
255 }
256 return Status;
257 }
258
259 CSR_API(SrvSetConsoleNumberOfCommands)
260 {
261 PCONSOLE_SETHISTORYNUMBERCOMMANDS SetHistoryNumberCommandsRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.SetHistoryNumberCommandsRequest;
262 PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
263 PCONSOLE Console;
264 PHISTORY_BUFFER Hist;
265 NTSTATUS Status;
266 UINT MaxEntries = SetHistoryNumberCommandsRequest->NumCommands;
267 PUNICODE_STRING OldEntryList, NewEntryList;
268
269 if (!CsrValidateMessageBuffer(ApiMessage,
270 (PVOID*)&SetHistoryNumberCommandsRequest->ExeName.Buffer,
271 SetHistoryNumberCommandsRequest->ExeName.Length,
272 sizeof(BYTE)))
273 {
274 return STATUS_INVALID_PARAMETER;
275 }
276
277 Status = ConioConsoleFromProcessData(ProcessData, &Console);
278 if (NT_SUCCESS(Status))
279 {
280 Hist = HistoryFindBuffer(Console, &SetHistoryNumberCommandsRequest->ExeName);
281 if (Hist)
282 {
283 OldEntryList = Hist->Entries;
284 NewEntryList = HeapAlloc(ConSrvHeap, 0,
285 MaxEntries * sizeof(UNICODE_STRING));
286 if (!NewEntryList)
287 {
288 Status = STATUS_NO_MEMORY;
289 }
290 else
291 {
292 /* If necessary, shrink by removing oldest entries */
293 for (; Hist->NumEntries > MaxEntries; Hist->NumEntries--)
294 {
295 RtlFreeUnicodeString(Hist->Entries++);
296 Hist->Position += (Hist->Position == 0);
297 }
298
299 Hist->MaxEntries = MaxEntries;
300 Hist->Entries = memcpy(NewEntryList, Hist->Entries,
301 Hist->NumEntries * sizeof(UNICODE_STRING));
302 HeapFree(ConSrvHeap, 0, OldEntryList);
303 }
304 }
305 ConioUnlockConsole(Console);
306 }
307 return Status;
308 }
309
310 CSR_API(SrvGetConsoleHistory)
311 {
312 PCONSOLE_GETSETHISTORYINFO HistoryInfoRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.HistoryInfoRequest;
313 PCONSOLE Console;
314 NTSTATUS Status = ConioConsoleFromProcessData(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console);
315 if (NT_SUCCESS(Status))
316 {
317 HistoryInfoRequest->HistoryBufferSize = Console->HistoryBufferSize;
318 HistoryInfoRequest->NumberOfHistoryBuffers = Console->NumberOfHistoryBuffers;
319 HistoryInfoRequest->dwFlags = Console->HistoryNoDup;
320 ConioUnlockConsole(Console);
321 }
322 return Status;
323 }
324
325 CSR_API(SrvSetConsoleHistory)
326 {
327 PCONSOLE_GETSETHISTORYINFO HistoryInfoRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.HistoryInfoRequest;
328 PCONSOLE Console;
329 NTSTATUS Status = ConioConsoleFromProcessData(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console);
330 if (NT_SUCCESS(Status))
331 {
332 Console->HistoryBufferSize = HistoryInfoRequest->HistoryBufferSize;
333 Console->NumberOfHistoryBuffers = HistoryInfoRequest->NumberOfHistoryBuffers;
334 Console->HistoryNoDup = HistoryInfoRequest->dwFlags & HISTORY_NO_DUP_FLAG;
335 ConioUnlockConsole(Console);
336 }
337 return Status;
338 }
339
340 static VOID
341 LineInputSetPos(PCONSOLE Console, UINT Pos)
342 {
343 if (Pos != Console->LinePos && Console->Mode & ENABLE_ECHO_INPUT)
344 {
345 PCONSOLE_SCREEN_BUFFER Buffer = Console->ActiveBuffer;
346 UINT OldCursorX = Buffer->CurrentX;
347 UINT OldCursorY = Buffer->CurrentY;
348 INT XY = OldCursorY * Buffer->MaxX + OldCursorX;
349
350 XY += (Pos - Console->LinePos);
351 if (XY < 0)
352 XY = 0;
353 else if (XY >= Buffer->MaxY * Buffer->MaxX)
354 XY = Buffer->MaxY * Buffer->MaxX - 1;
355
356 Buffer->CurrentX = XY % Buffer->MaxX;
357 Buffer->CurrentY = XY / Buffer->MaxX;
358 ConioSetScreenInfo(Console, Buffer, OldCursorX, OldCursorY);
359 }
360
361 Console->LinePos = Pos;
362 }
363
364 static VOID
365 LineInputEdit(PCONSOLE Console, UINT NumToDelete, UINT NumToInsert, WCHAR *Insertion)
366 {
367 UINT Pos = Console->LinePos;
368 UINT NewSize = Console->LineSize - NumToDelete + NumToInsert;
369 INT i;
370
371 /* Make sure there's always enough room for ending \r\n */
372 if (NewSize + 2 > Console->LineMaxSize)
373 return;
374
375 memmove(&Console->LineBuffer[Pos + NumToInsert],
376 &Console->LineBuffer[Pos + NumToDelete],
377 (Console->LineSize - (Pos + NumToDelete)) * sizeof(WCHAR));
378 memcpy(&Console->LineBuffer[Pos], Insertion, NumToInsert * sizeof(WCHAR));
379
380 if (Console->Mode & ENABLE_ECHO_INPUT)
381 {
382 for (i = Pos; i < NewSize; i++)
383 {
384 CHAR AsciiChar;
385 WideCharToMultiByte(Console->OutputCodePage, 0,
386 &Console->LineBuffer[i], 1,
387 &AsciiChar, 1, NULL, NULL);
388 ConioWriteConsole(Console, Console->ActiveBuffer, &AsciiChar, 1, TRUE);
389 }
390 for (; i < Console->LineSize; i++)
391 {
392 ConioWriteConsole(Console, Console->ActiveBuffer, " ", 1, TRUE);
393 }
394 Console->LinePos = i;
395 }
396
397 Console->LineSize = NewSize;
398 LineInputSetPos(Console, Pos + NumToInsert);
399 }
400
401 static VOID
402 LineInputRecallHistory(PCONSOLE Console, INT Offset)
403 {
404 PHISTORY_BUFFER Hist;
405
406 if (!(Hist = HistoryCurrentBuffer(Console)) || Hist->NumEntries == 0)
407 return;
408
409 Offset += Hist->Position;
410 Offset = max(Offset, 0);
411 Offset = min(Offset, Hist->NumEntries - 1);
412 Hist->Position = Offset;
413
414 LineInputSetPos(Console, 0);
415 LineInputEdit(Console, Console->LineSize,
416 Hist->Entries[Offset].Length / sizeof(WCHAR),
417 Hist->Entries[Offset].Buffer);
418 }
419
420 VOID FASTCALL
421 LineInputKeyDown(PCONSOLE Console, KEY_EVENT_RECORD *KeyEvent)
422 {
423 UINT Pos = Console->LinePos;
424 PHISTORY_BUFFER Hist;
425 UNICODE_STRING Entry;
426 INT HistPos;
427
428 switch (KeyEvent->wVirtualKeyCode)
429 {
430 case VK_ESCAPE:
431 /* Clear entire line */
432 LineInputSetPos(Console, 0);
433 LineInputEdit(Console, Console->LineSize, 0, NULL);
434 return;
435 case VK_HOME:
436 /* Move to start of line. With ctrl, erase everything left of cursor */
437 LineInputSetPos(Console, 0);
438 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
439 LineInputEdit(Console, Pos, 0, NULL);
440 return;
441 case VK_END:
442 /* Move to end of line. With ctrl, erase everything right of cursor */
443 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
444 LineInputEdit(Console, Console->LineSize - Pos, 0, NULL);
445 else
446 LineInputSetPos(Console, Console->LineSize);
447 return;
448 case VK_LEFT:
449 /* Move left. With ctrl, move to beginning of previous word */
450 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
451 {
452 while (Pos > 0 && Console->LineBuffer[Pos - 1] == L' ') Pos--;
453 while (Pos > 0 && Console->LineBuffer[Pos - 1] != L' ') Pos--;
454 }
455 else
456 {
457 Pos -= (Pos > 0);
458 }
459 LineInputSetPos(Console, Pos);
460 return;
461 case VK_RIGHT:
462 case VK_F1:
463 /* Move right. With ctrl, move to beginning of next word */
464 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
465 {
466 while (Pos < Console->LineSize && Console->LineBuffer[Pos] != L' ') Pos++;
467 while (Pos < Console->LineSize && Console->LineBuffer[Pos] == L' ') Pos++;
468 LineInputSetPos(Console, Pos);
469 return;
470 }
471 else
472 {
473 /* Recall one character (but don't overwrite current line) */
474 HistoryGetCurrentEntry(Console, &Entry);
475 if (Pos < Console->LineSize)
476 LineInputSetPos(Console, Pos + 1);
477 else if (Pos * sizeof(WCHAR) < Entry.Length)
478 LineInputEdit(Console, 0, 1, &Entry.Buffer[Pos]);
479 }
480 return;
481 case VK_INSERT:
482 /* Toggle between insert and overstrike */
483 Console->LineInsertToggle = !Console->LineInsertToggle;
484 ConioSetCursorInfo(Console, Console->ActiveBuffer);
485 return;
486 case VK_DELETE:
487 /* Remove character to right of cursor */
488 if (Pos != Console->LineSize)
489 LineInputEdit(Console, 1, 0, NULL);
490 return;
491 case VK_PRIOR:
492 /* Recall first history entry */
493 LineInputRecallHistory(Console, -((WORD)-1));
494 return;
495 case VK_NEXT:
496 /* Recall last history entry */
497 LineInputRecallHistory(Console, +((WORD)-1));
498 return;
499 case VK_UP:
500 case VK_F5:
501 /* Recall previous history entry. On first time, actually recall the
502 * current (usually last) entry; on subsequent times go back. */
503 LineInputRecallHistory(Console, Console->LineUpPressed ? -1 : 0);
504 Console->LineUpPressed = TRUE;
505 return;
506 case VK_DOWN:
507 /* Recall next history entry */
508 LineInputRecallHistory(Console, +1);
509 return;
510 case VK_F3:
511 /* Recall remainder of current history entry */
512 HistoryGetCurrentEntry(Console, &Entry);
513 if (Pos * sizeof(WCHAR) < Entry.Length)
514 {
515 UINT InsertSize = (Entry.Length / sizeof(WCHAR) - Pos);
516 UINT DeleteSize = min(Console->LineSize - Pos, InsertSize);
517 LineInputEdit(Console, DeleteSize, InsertSize, &Entry.Buffer[Pos]);
518 }
519 return;
520 case VK_F6:
521 /* Insert a ^Z character */
522 KeyEvent->uChar.UnicodeChar = 26;
523 break;
524 case VK_F7:
525 if (KeyEvent->dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
526 HistoryDeleteBuffer(HistoryCurrentBuffer(Console));
527 return;
528 case VK_F8:
529 /* Search for history entries starting with input. */
530 if (!(Hist = HistoryCurrentBuffer(Console)) || Hist->NumEntries == 0)
531 return;
532
533 /* Like Up/F5, on first time start from current (usually last) entry,
534 * but on subsequent times start at previous entry. */
535 if (Console->LineUpPressed)
536 Hist->Position = (Hist->Position ? Hist->Position : Hist->NumEntries) - 1;
537 Console->LineUpPressed = TRUE;
538
539 Entry.Length = Console->LinePos * sizeof(WCHAR);
540 Entry.Buffer = Console->LineBuffer;
541
542 /* Keep going backwards, even wrapping around to the end,
543 * until we get back to starting point */
544 HistPos = Hist->Position;
545 do
546 {
547 if (RtlPrefixUnicodeString(&Entry, &Hist->Entries[HistPos], FALSE))
548 {
549 Hist->Position = HistPos;
550 LineInputEdit(Console, Console->LineSize - Pos,
551 Hist->Entries[HistPos].Length / sizeof(WCHAR) - Pos,
552 &Hist->Entries[HistPos].Buffer[Pos]);
553 /* Cursor stays where it was */
554 LineInputSetPos(Console, Pos);
555 return;
556 }
557 if (--HistPos < 0) HistPos += Hist->NumEntries;
558 } while (HistPos != Hist->Position);
559 return;
560 }
561
562 if (KeyEvent->uChar.UnicodeChar == L'\b' && Console->Mode & ENABLE_PROCESSED_INPUT)
563 {
564 /* backspace handling - if processed input enabled then we handle it here
565 * otherwise we treat it like a normal char. */
566 if (Pos > 0)
567 {
568 LineInputSetPos(Console, Pos - 1);
569 LineInputEdit(Console, 1, 0, NULL);
570 }
571 }
572 else if (KeyEvent->uChar.UnicodeChar == L'\r')
573 {
574 HistoryAddEntry(Console);
575
576 /* TODO: Expand aliases */
577
578 LineInputSetPos(Console, Console->LineSize);
579 Console->LineBuffer[Console->LineSize++] = L'\r';
580 if (Console->Mode & ENABLE_ECHO_INPUT)
581 ConioWriteConsole(Console, Console->ActiveBuffer, "\r", 1, TRUE);
582
583 /* Add \n if processed input. There should usually be room for it,
584 * but an exception to the rule exists: the buffer could have been
585 * pre-filled with LineMaxSize - 1 characters. */
586 if (Console->Mode & ENABLE_PROCESSED_INPUT &&
587 Console->LineSize < Console->LineMaxSize)
588 {
589 Console->LineBuffer[Console->LineSize++] = L'\n';
590 if (Console->Mode & ENABLE_ECHO_INPUT)
591 ConioWriteConsole(Console, Console->ActiveBuffer, "\n", 1, TRUE);
592 }
593 Console->LineComplete = TRUE;
594 Console->LinePos = 0;
595 }
596 else if (KeyEvent->uChar.UnicodeChar != L'\0')
597 {
598 if (KeyEvent->uChar.UnicodeChar < 0x20 &&
599 Console->LineWakeupMask & (1 << KeyEvent->uChar.UnicodeChar))
600 {
601 /* Control key client wants to handle itself (e.g. for tab completion) */
602 Console->LineBuffer[Console->LineSize++] = L' ';
603 Console->LineBuffer[Console->LinePos] = KeyEvent->uChar.UnicodeChar;
604 Console->LineComplete = TRUE;
605 Console->LinePos = 0;
606 }
607 else
608 {
609 /* Normal character */
610 BOOL Overstrike = Console->LineInsertToggle && Console->LinePos != Console->LineSize;
611 LineInputEdit(Console, Overstrike, 1, &KeyEvent->uChar.UnicodeChar);
612 }
613 }
614 }
615
616 /* EOF */