1 /*
2  * COPYRIGHT:       See COPYING in the top level directory
3  * PROJECT:         ReactOS Console Server DLL
4  * FILE:            win32ss/user/winsrv/consrv/frontends/terminal.c
5  * PURPOSE:         ConSrv terminal.
6  * PROGRAMMERS:     Hermes Belusca-Maito (hermes.belusca@sfr.fr)
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include <consrv.h>
12 #include "concfg/font.h"
13 
14 // #include "frontends/gui/guiterm.h"
15 #ifdef TUITERM_COMPILE
16 #include "frontends/tui/tuiterm.h"
17 #endif
18 
19 #define NDEBUG
20 #include <debug.h>
21 
22 
23 
24 
25 
26 /********** HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK ************/
27 
28 /* GLOBALS ********************************************************************/
29 
30 /*
31  * From MSDN:
32  * "The lpMultiByteStr and lpWideCharStr pointers must not be the same.
33  *  If they are the same, the function fails, and GetLastError returns
34  *  ERROR_INVALID_PARAMETER."
35  */
36 #define ConsoleInputUnicodeCharToAnsiChar(Console, dChar, sWChar) \
37 do { \
38     ASSERT((ULONG_PTR)(dChar) != (ULONG_PTR)(sWChar)); \
39     WideCharToMultiByte((Console)->InputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL); \
40 } while (0)
41 
42 #define ConsoleInputAnsiCharToUnicodeChar(Console, dWChar, sChar) \
43 do { \
44     ASSERT((ULONG_PTR)(dWChar) != (ULONG_PTR)(sChar)); \
45     MultiByteToWideChar((Console)->InputCodePage, 0, (sChar), 1, (dWChar), 1); \
46 } while (0)
47 
48 /* PRIVATE FUNCTIONS **********************************************************/
49 
50 #if 0
51 
52 static VOID
53 ConioInputEventToAnsi(PCONSOLE Console, PINPUT_RECORD InputEvent)
54 {
55     if (InputEvent->EventType == KEY_EVENT)
56     {
57         WCHAR UnicodeChar = InputEvent->Event.KeyEvent.uChar.UnicodeChar;
58         InputEvent->Event.KeyEvent.uChar.UnicodeChar = 0;
59         ConsoleInputUnicodeCharToAnsiChar(Console,
60                                           &InputEvent->Event.KeyEvent.uChar.AsciiChar,
61                                           &UnicodeChar);
62     }
63 }
64 
65 static VOID
66 ConioInputEventToUnicode(PCONSOLE Console, PINPUT_RECORD InputEvent)
67 {
68     if (InputEvent->EventType == KEY_EVENT)
69     {
70         CHAR AsciiChar = InputEvent->Event.KeyEvent.uChar.AsciiChar;
71         InputEvent->Event.KeyEvent.uChar.AsciiChar = 0;
72         ConsoleInputAnsiCharToUnicodeChar(Console,
73                                           &InputEvent->Event.KeyEvent.uChar.UnicodeChar,
74                                           &AsciiChar);
75     }
76 }
77 
78 #endif
79 
80 /********** HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK ************/
81 
82 
83 
84 
85 
86 
87 
88 
89 /* CONSRV TERMINAL FRONTENDS INTERFACE ****************************************/
90 
91 /***************/
92 #ifdef TUITERM_COMPILE
93 NTSTATUS NTAPI
94 TuiLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
95                 IN OUT PCONSOLE_STATE_INFO ConsoleInfo,
96                 IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
97                 IN HANDLE ConsoleLeaderProcessHandle);
98 NTSTATUS NTAPI
99 TuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd);
100 #endif
101 
102 NTSTATUS NTAPI
103 GuiLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
104                 IN OUT PCONSOLE_STATE_INFO ConsoleInfo,
105                 IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
106                 IN HANDLE ConsoleLeaderProcessHandle);
107 NTSTATUS NTAPI
108 GuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd);
109 /***************/
110 
111 typedef
112 NTSTATUS (NTAPI *FRONTEND_LOAD)(IN OUT PFRONTEND FrontEnd,
113                                 IN OUT PCONSOLE_STATE_INFO ConsoleInfo,
114                                 IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
115                                 IN HANDLE ConsoleLeaderProcessHandle);
116 
117 typedef
118 NTSTATUS (NTAPI *FRONTEND_UNLOAD)(IN OUT PFRONTEND FrontEnd);
119 
120 /*
121  * If we are not in GUI-mode, start the text-mode terminal emulator.
122  * If we fail, try to start the GUI-mode terminal emulator.
123  *
124  * Try to open the GUI-mode terminal emulator. Two cases are possible:
125  * - We are in GUI-mode, therefore GuiMode == TRUE, the previous test-case
126  *   failed and we start GUI-mode terminal emulator.
127  * - We are in text-mode, therefore GuiMode == FALSE, the previous test-case
128  *   succeeded BUT we failed at starting text-mode terminal emulator.
129  *   Then GuiMode was switched to TRUE in order to try to open the GUI-mode
130  *   terminal emulator (Win32k will automatically switch to graphical mode,
131  *   therefore no additional code is needed).
132  */
133 
134 /*
135  * NOTE: Each entry of the table should be retrieved when loading a front-end
136  *       (examples of the CSR servers which register some data for CSRSS).
137  */
138 static struct
139 {
140     CHAR            FrontEndName[80];
141     FRONTEND_LOAD   FrontEndLoad;
142     FRONTEND_UNLOAD FrontEndUnload;
143 } FrontEndLoadingMethods[] =
144 {
145 #ifdef TUITERM_COMPILE
146     {"TUI", TuiLoadFrontEnd,    TuiUnloadFrontEnd},
147 #endif
148     {"GUI", GuiLoadFrontEnd,    GuiUnloadFrontEnd},
149 
150 //  {"Not found", 0, NULL}
151 };
152 
153 static NTSTATUS
154 ConSrvLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
155                    IN OUT PCONSOLE_STATE_INFO ConsoleInfo,
156                    IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
157                    IN HANDLE ConsoleLeaderProcessHandle)
158 {
159     NTSTATUS Status = STATUS_SUCCESS;
160     ULONG i;
161 
162     /*
163      * Choose an adequate terminal front-end to load, and load it
164      */
165     for (i = 0; i < ARRAYSIZE(FrontEndLoadingMethods); ++i)
166     {
167         DPRINT("CONSRV: Trying to load %s frontend...\n",
168                FrontEndLoadingMethods[i].FrontEndName);
169         Status = FrontEndLoadingMethods[i].FrontEndLoad(FrontEnd,
170                                                         ConsoleInfo,
171                                                         ConsoleInitInfo,
172                                                         ConsoleLeaderProcessHandle);
173         if (NT_SUCCESS(Status))
174         {
175             /* Save the unload callback */
176             FrontEnd->UnloadFrontEnd = FrontEndLoadingMethods[i].FrontEndUnload;
177 
178             DPRINT("CONSRV: %s frontend loaded successfully\n",
179                    FrontEndLoadingMethods[i].FrontEndName);
180             break;
181         }
182         else
183         {
184             DPRINT1("CONSRV: Loading %s frontend failed, Status = 0x%08lx , continuing...\n",
185                     FrontEndLoadingMethods[i].FrontEndName, Status);
186         }
187     }
188 
189     return Status;
190 }
191 
192 static NTSTATUS
193 ConSrvUnloadFrontEnd(IN PFRONTEND FrontEnd)
194 {
195     if (FrontEnd == NULL) return STATUS_INVALID_PARAMETER;
196     // return FrontEnd->Vtbl->UnloadFrontEnd(FrontEnd);
197     return FrontEnd->UnloadFrontEnd(FrontEnd);
198 }
199 
200 // See after...
201 static TERMINAL_VTBL ConSrvTermVtbl;
202 
203 NTSTATUS NTAPI
204 ConSrvInitTerminal(IN OUT PTERMINAL Terminal,
205                    IN OUT PCONSOLE_STATE_INFO ConsoleInfo,
206                    IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
207                    IN HANDLE ConsoleLeaderProcessHandle)
208 {
209     NTSTATUS Status;
210     PFRONTEND FrontEnd;
211 
212     /* Load a suitable frontend for the ConSrv terminal */
213     FrontEnd = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*FrontEnd));
214     if (!FrontEnd) return STATUS_NO_MEMORY;
215 
216     Status = ConSrvLoadFrontEnd(FrontEnd,
217                                 ConsoleInfo,
218                                 ConsoleInitInfo,
219                                 ConsoleLeaderProcessHandle);
220     if (!NT_SUCCESS(Status))
221     {
222         DPRINT1("CONSRV: Failed to initialize a frontend, Status = 0x%08lx\n", Status);
223         ConsoleFreeHeap(FrontEnd);
224         return Status;
225     }
226     DPRINT("CONSRV: Frontend initialized\n");
227 
228     /* Initialize the ConSrv terminal */
229     Terminal->Vtbl = &ConSrvTermVtbl;
230     // Terminal->Console will be initialized by ConDrvAttachTerminal
231     Terminal->Context = FrontEnd; /* We store the frontend pointer in the terminal private context */
232 
233     return STATUS_SUCCESS;
234 }
235 
236 NTSTATUS NTAPI
237 ConSrvDeinitTerminal(IN OUT PTERMINAL Terminal)
238 {
239     NTSTATUS Status = STATUS_SUCCESS;
240     PFRONTEND FrontEnd = Terminal->Context;
241 
242     /* Reset the ConSrv terminal */
243     Terminal->Context = NULL;
244     Terminal->Vtbl = NULL;
245 
246     /* Unload the frontend */
247     if (FrontEnd != NULL)
248     {
249         Status = ConSrvUnloadFrontEnd(FrontEnd);
250         ConsoleFreeHeap(FrontEnd);
251     }
252 
253     return Status;
254 }
255 
256 
257 /* CONSRV TERMINAL INTERFACE **************************************************/
258 
259 static NTSTATUS NTAPI
260 ConSrvTermInitTerminal(IN OUT PTERMINAL This,
261                        IN PCONSOLE Console)
262 {
263     NTSTATUS Status;
264     PFRONTEND FrontEnd = This->Context;
265     PCONSRV_CONSOLE ConSrvConsole = (PCONSRV_CONSOLE)Console;
266 
267     /* Initialize the console pointer for our frontend */
268     FrontEnd->Console = ConSrvConsole;
269 
270     /** HACK HACK!! Copy FrontEnd into the console!! **/
271     DPRINT("Using FrontEndIFace HACK(1), should be removed after proper implementation!\n");
272     ConSrvConsole->FrontEndIFace = *FrontEnd;
273 
274     Status = FrontEnd->Vtbl->InitFrontEnd(FrontEnd, ConSrvConsole);
275     if (!NT_SUCCESS(Status))
276         DPRINT1("InitFrontEnd failed, Status = 0x%08lx\n", Status);
277 
278     /** HACK HACK!! Be sure FrontEndIFace is correctly updated in the console!! **/
279     DPRINT("Using FrontEndIFace HACK(2), should be removed after proper implementation!\n");
280     ConSrvConsole->FrontEndIFace = *FrontEnd;
281 
282     return Status;
283 }
284 
285 static VOID NTAPI
286 ConSrvTermDeinitTerminal(IN OUT PTERMINAL This)
287 {
288     PFRONTEND FrontEnd = This->Context;
289     FrontEnd->Vtbl->DeinitFrontEnd(FrontEnd);
290 }
291 
292 
293 
294 /************ Line discipline ***************/
295 
296 static NTSTATUS NTAPI
297 ConSrvTermReadStream(IN OUT PTERMINAL This,
298                      IN BOOLEAN Unicode,
299                      /**PWCHAR Buffer,**/
300                      OUT PVOID Buffer,
301                      IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
302                      IN PVOID Parameter OPTIONAL,
303                      IN ULONG NumCharsToRead,
304                      OUT PULONG NumCharsRead OPTIONAL)
305 {
306     PFRONTEND FrontEnd = This->Context;
307     PCONSRV_CONSOLE Console = FrontEnd->Console;
308     PCONSOLE_INPUT_BUFFER InputBuffer = &Console->InputBuffer;
309     PUNICODE_STRING ExeName = Parameter;
310 
311     // STATUS_PENDING : Wait if more to read ; STATUS_SUCCESS : Don't wait.
312     NTSTATUS Status = STATUS_PENDING;
313 
314     PLIST_ENTRY CurrentEntry;
315     ConsoleInput *Input;
316     ULONG i = 0;
317 
318     /* Validity checks */
319     // ASSERT(Console == InputBuffer->Header.Console);
320     ASSERT((Buffer != NULL) || (Buffer == NULL && NumCharsToRead == 0));
321 
322     /* We haven't read anything (yet) */
323 
324     if (InputBuffer->Mode & ENABLE_LINE_INPUT)
325     {
326         /* COOKED mode, call the line discipline */
327 
328         if (Console->LineBuffer == NULL)
329         {
330             /* Start a new line */
331             Console->LineMaxSize = max(256, NumCharsToRead);
332 
333             /*
334              * Fixup ReadControl->nInitialChars in case the number of initial
335              * characters is bigger than the number of characters to be read.
336              * It will always be, lesser than or equal to Console->LineMaxSize.
337              */
338             ReadControl->nInitialChars = min(ReadControl->nInitialChars, NumCharsToRead);
339 
340             Console->LineBuffer = ConsoleAllocHeap(0, Console->LineMaxSize * sizeof(WCHAR));
341             if (Console->LineBuffer == NULL) return STATUS_NO_MEMORY;
342 
343             Console->LinePos = Console->LineSize = ReadControl->nInitialChars;
344             Console->LineComplete = Console->LineUpPressed = FALSE;
345             Console->LineInsertToggle = Console->InsertMode;
346             Console->LineWakeupMask = ReadControl->dwCtrlWakeupMask;
347 
348             /*
349              * Pre-fill the buffer with the nInitialChars from the user buffer.
350              * Since pre-filling is only allowed in Unicode, we don't need to
351              * worry about ANSI <-> Unicode conversion.
352              */
353             memcpy(Console->LineBuffer, Buffer, Console->LineSize * sizeof(WCHAR));
354             if (Console->LineSize >= Console->LineMaxSize)
355             {
356                 Console->LineComplete = TRUE;
357                 Console->LinePos = 0;
358             }
359         }
360 
361         /* If we don't have a complete line yet, process the pending input */
362         while (!Console->LineComplete && !IsListEmpty(&InputBuffer->InputEvents))
363         {
364             /* Remove an input event from the queue */
365             _InterlockedDecrement((PLONG)&InputBuffer->NumberOfEvents);
366             CurrentEntry = RemoveHeadList(&InputBuffer->InputEvents);
367             if (IsListEmpty(&InputBuffer->InputEvents))
368             {
369                 NtClearEvent(InputBuffer->ActiveEvent);
370             }
371             Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
372 
373             /* Only pay attention to key down */
374             if (Input->InputEvent.EventType == KEY_EVENT &&
375                 Input->InputEvent.Event.KeyEvent.bKeyDown)
376             {
377                 LineInputKeyDown(Console, ExeName,
378                                  &Input->InputEvent.Event.KeyEvent);
379                 ReadControl->dwControlKeyState = Input->InputEvent.Event.KeyEvent.dwControlKeyState;
380             }
381             ConsoleFreeHeap(Input);
382         }
383 
384         /* Check if we have a complete line to read from */
385         if (Console->LineComplete)
386         {
387             /*
388              * Console->LinePos keeps the next position of the character to read
389              * in the line buffer across the different calls of the function,
390              * so that the line buffer can be read by chunks after all the input
391              * has been buffered.
392              */
393 
394             while (i < NumCharsToRead && Console->LinePos < Console->LineSize)
395             {
396                 WCHAR Char = Console->LineBuffer[Console->LinePos++];
397 
398                 if (Unicode)
399                 {
400                     ((PWCHAR)Buffer)[i] = Char;
401                 }
402                 else
403                 {
404                     ConsoleInputUnicodeCharToAnsiChar(Console, &((PCHAR)Buffer)[i], &Char);
405                 }
406                 ++i;
407             }
408 
409             if (Console->LinePos >= Console->LineSize)
410             {
411                 /* The entire line has been read */
412                 ConsoleFreeHeap(Console->LineBuffer);
413                 Console->LineBuffer = NULL;
414                 Console->LinePos = Console->LineMaxSize = Console->LineSize = 0;
415                 // Console->LineComplete = Console->LineUpPressed = FALSE;
416                 Console->LineComplete = FALSE;
417             }
418 
419             Status = STATUS_SUCCESS;
420         }
421     }
422     else
423     {
424         /* RAW mode */
425 
426         /* Character input */
427         while (i < NumCharsToRead && !IsListEmpty(&InputBuffer->InputEvents))
428         {
429             /* Remove an input event from the queue */
430             _InterlockedDecrement((PLONG)&InputBuffer->NumberOfEvents);
431             CurrentEntry = RemoveHeadList(&InputBuffer->InputEvents);
432             if (IsListEmpty(&InputBuffer->InputEvents))
433             {
434                 NtClearEvent(InputBuffer->ActiveEvent);
435             }
436             Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
437 
438             /* Only pay attention to valid characters, on key down */
439             if (Input->InputEvent.EventType == KEY_EVENT  &&
440                 Input->InputEvent.Event.KeyEvent.bKeyDown &&
441                 Input->InputEvent.Event.KeyEvent.uChar.UnicodeChar != L'\0')
442             {
443                 WCHAR Char = Input->InputEvent.Event.KeyEvent.uChar.UnicodeChar;
444 
445                 if (Unicode)
446                 {
447                     ((PWCHAR)Buffer)[i] = Char;
448                 }
449                 else
450                 {
451                     ConsoleInputUnicodeCharToAnsiChar(Console, &((PCHAR)Buffer)[i], &Char);
452                 }
453                 ++i;
454 
455                 /* Did read something */
456                 Status = STATUS_SUCCESS;
457             }
458             ConsoleFreeHeap(Input);
459         }
460     }
461 
462     // FIXME: Only set if Status == STATUS_SUCCESS ???
463     if (NumCharsRead) *NumCharsRead = i;
464 
465     return Status;
466 }
467 
468 
469 
470 
471 /* GLOBALS ********************************************************************/
472 
473 #define TAB_WIDTH   8
474 
475 // See condrv/text.c
476 /*static*/ VOID
477 ClearLineBuffer(PTEXTMODE_SCREEN_BUFFER Buff);
478 
479 static VOID
480 ConioNextLine(PTEXTMODE_SCREEN_BUFFER Buff, PSMALL_RECT UpdateRect, PUINT ScrolledLines)
481 {
482     /* If we hit bottom, slide the viewable screen */
483     if (++Buff->CursorPosition.Y == Buff->ScreenBufferSize.Y)
484     {
485         Buff->CursorPosition.Y--;
486         if (++Buff->VirtualY == Buff->ScreenBufferSize.Y)
487         {
488             Buff->VirtualY = 0;
489         }
490         (*ScrolledLines)++;
491         ClearLineBuffer(Buff);
492         if (UpdateRect->Top != 0)
493         {
494             UpdateRect->Top--;
495         }
496     }
497     UpdateRect->Left = 0;
498     UpdateRect->Right = Buff->ScreenBufferSize.X - 1;
499     UpdateRect->Bottom = Buff->CursorPosition.Y;
500 }
501 
502 static NTSTATUS
503 ConioWriteConsole(PFRONTEND FrontEnd,
504                   PTEXTMODE_SCREEN_BUFFER Buff,
505                   PWCHAR Buffer,
506                   DWORD Length,
507                   BOOL Attrib)
508 {
509     PCONSRV_CONSOLE Console = FrontEnd->Console;
510 
511     UINT i;
512     PCHAR_INFO Ptr;
513     SMALL_RECT UpdateRect;
514     SHORT CursorStartX, CursorStartY;
515     UINT ScrolledLines;
516     BOOLEAN bFullwidth;
517     BOOLEAN bCJK = Console->IsCJK;
518 
519     /* If nothing to write, bail out now */
520     if (Length == 0)
521         return STATUS_SUCCESS;
522 
523     CursorStartX = Buff->CursorPosition.X;
524     CursorStartY = Buff->CursorPosition.Y;
525     UpdateRect.Left = Buff->ScreenBufferSize.X;
526     UpdateRect.Top  = Buff->CursorPosition.Y;
527     UpdateRect.Right  = -1;
528     UpdateRect.Bottom = Buff->CursorPosition.Y;
529     ScrolledLines = 0;
530 
531     for (i = 0; i < Length; i++)
532     {
533         /*
534          * If we are in processed mode, interpret special characters and
535          * display them correctly. Otherwise, just put them into the buffer.
536          */
537         if (Buff->Mode & ENABLE_PROCESSED_OUTPUT)
538         {
539             /* --- CR --- */
540             if (Buffer[i] == L'\r')
541             {
542                 Buff->CursorPosition.X = 0;
543                 CursorStartX = Buff->CursorPosition.X;
544                 UpdateRect.Left  = min(UpdateRect.Left , Buff->CursorPosition.X);
545                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
546                 continue;
547             }
548             /* --- LF --- */
549             else if (Buffer[i] == L'\n')
550             {
551                 Buff->CursorPosition.X = 0; // TODO: Make this behaviour optional!
552                 CursorStartX = Buff->CursorPosition.X;
553                 ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
554                 continue;
555             }
556             /* --- BS --- */
557             else if (Buffer[i] == L'\b')
558             {
559                 /* Only handle BS if we are not on the first position of the first line */
560                 if (Buff->CursorPosition.X == 0 && Buff->CursorPosition.Y == 0)
561                     continue;
562 
563                 if (Buff->CursorPosition.X == 0)
564                 {
565                     /* Slide virtual position up */
566                     Buff->CursorPosition.X = Buff->ScreenBufferSize.X - 1;
567                     Buff->CursorPosition.Y--;
568                     // TODO? : Update CursorStartY = Buff->CursorPosition.Y;
569                     UpdateRect.Top = min(UpdateRect.Top, Buff->CursorPosition.Y);
570                 }
571                 else
572                 {
573                     Buff->CursorPosition.X--;
574                 }
575                 Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
576 
577                 if (Ptr->Attributes & COMMON_LVB_LEADING_BYTE)
578                 {
579                     /*
580                      * The cursor just moved on the leading byte of the same
581                      * current character. We should go one position before to
582                      * go to the actual previous character to erase.
583                      */
584 
585                     /* Only handle BS if we are not on the first position of the first line */
586                     if (Buff->CursorPosition.X == 0 && Buff->CursorPosition.Y == 0)
587                         continue;
588 
589                     if (Buff->CursorPosition.X == 0)
590                     {
591                         /* Slide virtual position up */
592                         Buff->CursorPosition.X = Buff->ScreenBufferSize.X - 1;
593                         Buff->CursorPosition.Y--;
594                         // TODO? : Update CursorStartY = Buff->CursorPosition.Y;
595                         UpdateRect.Top = min(UpdateRect.Top, Buff->CursorPosition.Y);
596                     }
597                     else
598                     {
599                         Buff->CursorPosition.X--;
600                     }
601                     Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
602                 }
603 
604                 if (Ptr->Attributes & COMMON_LVB_TRAILING_BYTE)
605                 {
606                     /* The cursor is on the trailing byte of a full-width character */
607 
608                     /* Delete its trailing byte... */
609                     Ptr->Char.UnicodeChar = L' ';
610                     if (Attrib)
611                         Ptr->Attributes = Buff->ScreenDefaultAttrib;
612                     Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
613 
614                     if (Buff->CursorPosition.X > 0)
615                         Buff->CursorPosition.X--;
616                     /* ... and now its leading byte */
617                     Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
618                 }
619 
620                 Ptr->Char.UnicodeChar = L' ';
621                 if (Attrib)
622                     Ptr->Attributes = Buff->ScreenDefaultAttrib;
623                 Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
624 
625                 UpdateRect.Left  = min(UpdateRect.Left , Buff->CursorPosition.X);
626                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
627                 continue;
628             }
629             /* --- TAB --- */
630             else if (Buffer[i] == L'\t')
631             {
632                 UINT EndX;
633 
634                 Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
635 
636                 if (Ptr->Attributes & COMMON_LVB_TRAILING_BYTE)
637                 {
638                     /*
639                      * The cursor is on the trailing byte of a full-width character.
640                      * Go back one position to be on its leading byte.
641                      */
642                     if (Buff->CursorPosition.X > 0)
643                         Buff->CursorPosition.X--;
644                     Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
645                 }
646 
647                 UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
648 
649                 EndX = (Buff->CursorPosition.X + TAB_WIDTH) & ~(TAB_WIDTH - 1);
650                 EndX = min(EndX, (UINT)Buff->ScreenBufferSize.X);
651 
652                 while ((UINT)Buff->CursorPosition.X < EndX)
653                 {
654                     Ptr->Char.UnicodeChar = L' ';
655                     if (Attrib)
656                         Ptr->Attributes = Buff->ScreenDefaultAttrib;
657                     Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
658 
659                     ++Ptr;
660                     Buff->CursorPosition.X++;
661                 }
662                 if (Buff->CursorPosition.X < Buff->ScreenBufferSize.X)
663                 {
664                     /* If the following cell is the trailing byte of a full-width character, reset it */
665                     if (Ptr->Attributes & COMMON_LVB_TRAILING_BYTE)
666                     {
667                         Ptr->Char.UnicodeChar = L' ';
668                         if (Attrib)
669                             Ptr->Attributes = Buff->ScreenDefaultAttrib;
670                         Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
671                     }
672                 }
673                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
674 
675                 if (Buff->CursorPosition.X >= Buff->ScreenBufferSize.X)
676                 {
677                     if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
678                     {
679                         /* Wrapping mode: Go to next line */
680                         Buff->CursorPosition.X = 0;
681                         CursorStartX = Buff->CursorPosition.X;
682                         ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
683                     }
684                     else
685                     {
686                         /* The cursor wraps back to its starting position on the same line */
687                         Buff->CursorPosition.X = CursorStartX;
688                     }
689                 }
690                 continue;
691             }
692             /* --- BEL ---*/
693             else if (Buffer[i] == L'\a')
694             {
695                 FrontEnd->Vtbl->RingBell(FrontEnd);
696                 continue;
697             }
698         }
699         UpdateRect.Left  = min(UpdateRect.Left , Buff->CursorPosition.X);
700         UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
701 
702         /* For Chinese, Japanese and Korean */
703         bFullwidth = (bCJK && IS_FULL_WIDTH(Buffer[i]));
704 
705         /* Check whether we can insert the full-width character */
706         if (bFullwidth)
707         {
708             /* It spans two cells and should all fit on the current line */
709             if (Buff->CursorPosition.X >= Buff->ScreenBufferSize.X - 1)
710             {
711                 if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
712                 {
713                     /* Wrapping mode: Go to next line */
714                     Buff->CursorPosition.X = 0;
715                     CursorStartX = Buff->CursorPosition.X;
716                     ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
717                 }
718                 else
719                 {
720                     /* The cursor wraps back to its starting position on the same line */
721                     Buff->CursorPosition.X = CursorStartX;
722                 }
723             }
724 
725             /*
726              * Now be sure we can fit the full-width character.
727              * If the screenbuffer is one cell wide we cannot display
728              * the full-width character, so just skip it.
729              */
730             if (Buff->CursorPosition.X >= Buff->ScreenBufferSize.X - 1)
731             {
732                 DPRINT1("Cannot display full-width character! CursorPosition.X = %d, ScreenBufferSize.X = %d\n",
733                         Buff->CursorPosition.X, Buff->ScreenBufferSize.X);
734                 continue;
735             }
736         }
737 
738         Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
739 
740         /*
741          * Check whether we are overwriting part of a full-width character,
742          * in which case we need to invalidate it.
743          */
744         if (Ptr->Attributes & COMMON_LVB_TRAILING_BYTE)
745         {
746             /*
747              * The cursor is on the trailing byte of a full-width character.
748              * Go back one position to kill the previous leading byte.
749              */
750             if (Buff->CursorPosition.X > 0)
751             {
752                 Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X - 1, Buff->CursorPosition.Y);
753                 Ptr->Char.UnicodeChar = L' ';
754                 if (Attrib)
755                     Ptr->Attributes = Buff->ScreenDefaultAttrib;
756                 Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
757             }
758             Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
759         }
760 
761         /* Insert the character */
762         if (bFullwidth)
763         {
764             ASSERT(Buff->CursorPosition.X < Buff->ScreenBufferSize.X - 1);
765 
766             /* Set the leading byte */
767             Ptr->Char.UnicodeChar = Buffer[i];
768             if (Attrib)
769                 Ptr->Attributes = Buff->ScreenDefaultAttrib;
770             Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
771             Ptr->Attributes |= COMMON_LVB_LEADING_BYTE;
772 
773             /* Set the trailing byte */
774             Buff->CursorPosition.X++;
775             Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
776             // Ptr->Char.UnicodeChar = Buffer[i]; // L' ';
777             if (Attrib)
778                 Ptr->Attributes = Buff->ScreenDefaultAttrib;
779             Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
780             Ptr->Attributes |= COMMON_LVB_TRAILING_BYTE;
781         }
782         else
783         {
784             Ptr->Char.UnicodeChar = Buffer[i];
785             if (Attrib)
786                 Ptr->Attributes = Buff->ScreenDefaultAttrib;
787             Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
788         }
789 
790         ++Ptr;
791         Buff->CursorPosition.X++;
792 
793         if (Buff->CursorPosition.X < Buff->ScreenBufferSize.X)
794         {
795             /* If the following cell is the trailing byte of a full-width character, reset it */
796             if (Ptr->Attributes & COMMON_LVB_TRAILING_BYTE)
797             {
798                 Ptr->Char.UnicodeChar = L' ';
799                 if (Attrib)
800                     Ptr->Attributes = Buff->ScreenDefaultAttrib;
801                 Ptr->Attributes &= ~COMMON_LVB_SBCSDBCS;
802             }
803         }
804 
805         if (Buff->CursorPosition.X >= Buff->ScreenBufferSize.X)
806         {
807             if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
808             {
809                 /* Wrapping mode: Go to next line */
810                 Buff->CursorPosition.X = 0;
811                 CursorStartX = Buff->CursorPosition.X;
812                 ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
813             }
814             else
815             {
816                 /* The cursor wraps back to its starting position on the same line */
817                 Buff->CursorPosition.X = CursorStartX;
818             }
819         }
820     }
821 
822     if (!ConioIsRectEmpty(&UpdateRect) && (PCONSOLE_SCREEN_BUFFER)Buff == Console->ActiveBuffer)
823     {
824         // TermWriteStream(Console, &UpdateRect, CursorStartX, CursorStartY,
825                         // ScrolledLines, Buffer, Length);
826         FrontEnd->Vtbl->WriteStream(FrontEnd,
827                                     &UpdateRect,
828                                     CursorStartX,
829                                     CursorStartY,
830                                     ScrolledLines,
831                                     Buffer,
832                                     Length);
833     }
834 
835     return STATUS_SUCCESS;
836 }
837 
838 
839 
840 static NTSTATUS NTAPI
841 ConSrvTermWriteStream(IN OUT PTERMINAL This,
842                       PTEXTMODE_SCREEN_BUFFER Buff,
843                       PWCHAR Buffer,
844                       DWORD Length,
845                       BOOL Attrib)
846 {
847     PFRONTEND FrontEnd = This->Context;
848     return ConioWriteConsole(FrontEnd,
849                              Buff,
850                              Buffer,
851                              Length,
852                              Attrib);
853 }
854 
855 /************ Line discipline ***************/
856 
857 
858 
859 VOID
860 ConioDrawConsole(PCONSRV_CONSOLE Console)
861 {
862     SMALL_RECT Region;
863     PCONSOLE_SCREEN_BUFFER ActiveBuffer = Console->ActiveBuffer;
864 
865     if (!ActiveBuffer) return;
866 
867     ConioInitRect(&Region, 0, 0,
868                   ActiveBuffer->ViewSize.Y - 1,
869                   ActiveBuffer->ViewSize.X - 1);
870     TermDrawRegion(Console, &Region);
871     // Console->FrontEndIFace.Vtbl->DrawRegion(&Console->FrontEndIFace, &Region);
872 }
873 
874 static VOID NTAPI
875 ConSrvTermDrawRegion(IN OUT PTERMINAL This,
876                 SMALL_RECT* Region)
877 {
878     PFRONTEND FrontEnd = This->Context;
879     FrontEnd->Vtbl->DrawRegion(FrontEnd, Region);
880 }
881 
882 static BOOL NTAPI
883 ConSrvTermSetCursorInfo(IN OUT PTERMINAL This,
884                    PCONSOLE_SCREEN_BUFFER ScreenBuffer)
885 {
886     PFRONTEND FrontEnd = This->Context;
887     return FrontEnd->Vtbl->SetCursorInfo(FrontEnd, ScreenBuffer);
888 }
889 
890 static BOOL NTAPI
891 ConSrvTermSetScreenInfo(IN OUT PTERMINAL This,
892                    PCONSOLE_SCREEN_BUFFER ScreenBuffer,
893                    SHORT OldCursorX,
894                    SHORT OldCursorY)
895 {
896     PFRONTEND FrontEnd = This->Context;
897     return FrontEnd->Vtbl->SetScreenInfo(FrontEnd,
898                                          ScreenBuffer,
899                                          OldCursorX,
900                                          OldCursorY);
901 }
902 
903 static VOID NTAPI
904 ConSrvTermResizeTerminal(IN OUT PTERMINAL This)
905 {
906     PFRONTEND FrontEnd = This->Context;
907     FrontEnd->Vtbl->ResizeTerminal(FrontEnd);
908 }
909 
910 static VOID NTAPI
911 ConSrvTermSetActiveScreenBuffer(IN OUT PTERMINAL This)
912 {
913     PFRONTEND FrontEnd = This->Context;
914     FrontEnd->Vtbl->SetActiveScreenBuffer(FrontEnd);
915 }
916 
917 static VOID NTAPI
918 ConSrvTermReleaseScreenBuffer(IN OUT PTERMINAL This,
919                          IN PCONSOLE_SCREEN_BUFFER ScreenBuffer)
920 {
921     PFRONTEND FrontEnd = This->Context;
922     FrontEnd->Vtbl->ReleaseScreenBuffer(FrontEnd, ScreenBuffer);
923 }
924 
925 static VOID NTAPI
926 ConSrvTermGetLargestConsoleWindowSize(IN OUT PTERMINAL This,
927                                  PCOORD pSize)
928 {
929     PFRONTEND FrontEnd = This->Context;
930     FrontEnd->Vtbl->GetLargestConsoleWindowSize(FrontEnd, pSize);
931 }
932 
933 static BOOL NTAPI
934 ConSrvTermSetPalette(IN OUT PTERMINAL This,
935                 HPALETTE PaletteHandle,
936                 UINT PaletteUsage)
937 {
938     PFRONTEND FrontEnd = This->Context;
939     return FrontEnd->Vtbl->SetPalette(FrontEnd, PaletteHandle, PaletteUsage);
940 }
941 
942 static BOOL NTAPI
943 ConSrvTermSetCodePage(IN OUT PTERMINAL This,
944                       UINT CodePage)
945 {
946     PFRONTEND FrontEnd = This->Context;
947     return FrontEnd->Vtbl->SetCodePage(FrontEnd, CodePage);
948 }
949 
950 static INT NTAPI
951 ConSrvTermShowMouseCursor(IN OUT PTERMINAL This,
952                      BOOL Show)
953 {
954     PFRONTEND FrontEnd = This->Context;
955     return FrontEnd->Vtbl->ShowMouseCursor(FrontEnd, Show);
956 }
957 
958 static TERMINAL_VTBL ConSrvTermVtbl =
959 {
960     ConSrvTermInitTerminal,
961     ConSrvTermDeinitTerminal,
962 
963     ConSrvTermReadStream,
964     ConSrvTermWriteStream,
965 
966     ConSrvTermDrawRegion,
967     ConSrvTermSetCursorInfo,
968     ConSrvTermSetScreenInfo,
969     ConSrvTermResizeTerminal,
970     ConSrvTermSetActiveScreenBuffer,
971     ConSrvTermReleaseScreenBuffer,
972     ConSrvTermGetLargestConsoleWindowSize,
973     ConSrvTermSetPalette,
974     ConSrvTermSetCodePage,
975     ConSrvTermShowMouseCursor,
976 };
977 
978 #if 0
979 VOID
980 ResetFrontEnd(IN PCONSOLE Console)
981 {
982     PCONSRV_CONSOLE ConSrvConsole = (PCONSRV_CONSOLE)Console;
983     if (!Console) return;
984 
985     /* Reinitialize the frontend interface */
986     RtlZeroMemory(&ConSrvConsole->FrontEndIFace, sizeof(ConSrvConsole->FrontEndIFace));
987     ConSrvConsole->FrontEndIFace.Vtbl = &ConSrvTermVtbl;
988 }
989 #endif
990 
991 /* EOF */
992