reactos/win32ss/user/winsrv/consrv/frontends/terminal.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Server DLL
   4  * FILE:            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
  13 // #include "frontends/gui/guiterm.h"
  14 #ifdef TUITERM_COMPILE
  15 #include "frontends/tui/tuiterm.h"
  16 #endif
  17
  18 #define NDEBUG
  19 #include <debug.h>
  20
  21
  22
  23
  24
  25 /********** HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK ************/
  26
  27 /* GLOBALS ********************************************************************/
  28
  29 /*
  30  * From MSDN:
  31  * "The lpMultiByteStr and lpWideCharStr pointers must not be the same.
  32  *  If they are the same, the function fails, and GetLastError returns
  33  *  ERROR_INVALID_PARAMETER."
  34  */
  35 #define ConsoleInputUnicodeCharToAnsiChar(Console, dChar, sWChar) \
  36     ASSERT((ULONG_PTR)dChar != (ULONG_PTR)sWChar); \
  37     WideCharToMultiByte((Console)->InputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
  38
  39 #define ConsoleInputAnsiCharToUnicodeChar(Console, dWChar, sChar) \
  40     ASSERT((ULONG_PTR)dWChar != (ULONG_PTR)sChar); \
  41     MultiByteToWideChar((Console)->InputCodePage, 0, (sChar), 1, (dWChar), 1)
  42
  43 typedef struct ConsoleInput_t
  44 {
  45     LIST_ENTRY ListEntry;
  46     INPUT_RECORD InputEvent;
  47 } ConsoleInput;
  48
  49
  50 /* PRIVATE FUNCTIONS **********************************************************/
  51
  52 #if 0
  53
  54 static VOID
  55 ConioInputEventToAnsi(PCONSOLE Console, PINPUT_RECORD InputEvent)
  56 {
  57     if (InputEvent->EventType == KEY_EVENT)
  58     {
  59         WCHAR UnicodeChar = InputEvent->Event.KeyEvent.uChar.UnicodeChar;
  60         InputEvent->Event.KeyEvent.uChar.UnicodeChar = 0;
  61         ConsoleInputUnicodeCharToAnsiChar(Console,
  62                                           &InputEvent->Event.KeyEvent.uChar.AsciiChar,
  63                                           &UnicodeChar);
  64     }
  65 }
  66
  67 static VOID
  68 ConioInputEventToUnicode(PCONSOLE Console, PINPUT_RECORD InputEvent)
  69 {
  70     if (InputEvent->EventType == KEY_EVENT)
  71     {
  72         CHAR AsciiChar = InputEvent->Event.KeyEvent.uChar.AsciiChar;
  73         InputEvent->Event.KeyEvent.uChar.AsciiChar = 0;
  74         ConsoleInputAnsiCharToUnicodeChar(Console,
  75                                           &InputEvent->Event.KeyEvent.uChar.UnicodeChar,
  76                                           &AsciiChar);
  77     }
  78 }
  79
  80 #endif
  81
  82 /********** HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK ************/
  83
  84
  85
  86
  87
  88
  89
  90
  91 /* CONSRV TERMINAL FRONTENDS INTERFACE ****************************************/
  92
  93 /***************/
  94 #ifdef TUITERM_COMPILE
  95 NTSTATUS NTAPI
  96 TuiLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
  97                 IN OUT PCONSOLE_INFO ConsoleInfo,
  98                 IN OUT PVOID ExtraConsoleInfo,
  99                 IN ULONG ProcessId);
 100 NTSTATUS NTAPI
 101 TuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd);
 102 #endif
 103
 104 NTSTATUS NTAPI
 105 GuiLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
 106                 IN OUT PCONSOLE_INFO ConsoleInfo,
 107                 IN OUT PVOID ExtraConsoleInfo,
 108                 IN ULONG ProcessId);
 109 NTSTATUS NTAPI
 110 GuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd);
 111 /***************/
 112
 113 typedef
 114 NTSTATUS (NTAPI *FRONTEND_LOAD)(IN OUT PFRONTEND FrontEnd,
 115                                 IN OUT PCONSOLE_INFO ConsoleInfo,
 116                                 IN OUT PVOID ExtraConsoleInfo,
 117                                 IN ULONG ProcessId);
 118
 119 typedef
 120 NTSTATUS (NTAPI *FRONTEND_UNLOAD)(IN OUT PFRONTEND FrontEnd);
 121
 122 /*
 123  * If we are not in GUI-mode, start the text-mode terminal emulator.
 124  * If we fail, try to start the GUI-mode terminal emulator.
 125  *
 126  * Try to open the GUI-mode terminal emulator. Two cases are possible:
 127  * - We are in GUI-mode, therefore GuiMode == TRUE, the previous test-case
 128  *   failed and we start GUI-mode terminal emulator.
 129  * - We are in text-mode, therefore GuiMode == FALSE, the previous test-case
 130  *   succeeded BUT we failed at starting text-mode terminal emulator.
 131  *   Then GuiMode was switched to TRUE in order to try to open the GUI-mode
 132  *   terminal emulator (Win32k will automatically switch to graphical mode,
 133  *   therefore no additional code is needed).
 134  */
 135
 136 /*
 137  * NOTE: Each entry of the table should be retrieved when loading a front-end
 138  *       (examples of the CSR servers which register some data for CSRSS).
 139  */
 140 static struct
 141 {
 142     CHAR            FrontEndName[80];
 143     FRONTEND_LOAD   FrontEndLoad;
 144     FRONTEND_UNLOAD FrontEndUnload;
 145 } FrontEndLoadingMethods[] =
 146 {
 147 #ifdef TUITERM_COMPILE
 148     {"TUI", TuiLoadFrontEnd,    TuiUnloadFrontEnd},
 149 #endif
 150     {"GUI", GuiLoadFrontEnd,    GuiUnloadFrontEnd},
 151
 152 //  {"Not found", 0, NULL}
 153 };
 154
 155 static NTSTATUS
 156 ConSrvLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
 157                    IN OUT PCONSOLE_INFO ConsoleInfo,
 158                    IN OUT PVOID ExtraConsoleInfo,
 159                    IN ULONG ProcessId)
 160 {
 161     NTSTATUS Status = STATUS_SUCCESS;
 162     ULONG i;
 163
 164     /*
 165      * Choose an adequate terminal front-end to load, and load it
 166      */
 167     for (i = 0; i < sizeof(FrontEndLoadingMethods) / sizeof(FrontEndLoadingMethods[0]); ++i)
 168     {
 169         DPRINT("CONSRV: Trying to load %s frontend...\n",
 170                FrontEndLoadingMethods[i].FrontEndName);
 171         Status = FrontEndLoadingMethods[i].FrontEndLoad(FrontEnd,
 172                                                         ConsoleInfo,
 173                                                         ExtraConsoleInfo,
 174                                                         ProcessId);
 175         if (NT_SUCCESS(Status))
 176         {
 177             /* Save the unload callback */
 178             FrontEnd->UnloadFrontEnd = FrontEndLoadingMethods[i].FrontEndUnload;
 179
 180             DPRINT("CONSRV: %s frontend loaded successfully\n",
 181                    FrontEndLoadingMethods[i].FrontEndName);
 182             break;
 183         }
 184         else
 185         {
 186             DPRINT1("CONSRV: Loading %s frontend failed, Status = 0x%08lx , continuing...\n",
 187                     FrontEndLoadingMethods[i].FrontEndName, Status);
 188         }
 189     }
 190
 191     return Status;
 192 }
 193
 194 static NTSTATUS
 195 ConSrvUnloadFrontEnd(IN PFRONTEND FrontEnd)
 196 {
 197     if (FrontEnd == NULL) return STATUS_INVALID_PARAMETER;
 198     // return FrontEnd->Vtbl->UnloadFrontEnd(FrontEnd);
 199     return FrontEnd->UnloadFrontEnd(FrontEnd);
 200 }
 201
 202 // See after...
 203 static TERMINAL_VTBL ConSrvTermVtbl;
 204
 205 NTSTATUS NTAPI
 206 ConSrvInitTerminal(IN OUT PTERMINAL Terminal,
 207                    IN OUT PCONSOLE_INFO ConsoleInfo,
 208                    IN OUT PVOID ExtraConsoleInfo,
 209                    IN ULONG ProcessId)
 210 {
 211     NTSTATUS Status;
 212     PFRONTEND FrontEnd;
 213
 214     /* Load a suitable frontend for the ConSrv terminal */
 215     FrontEnd = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*FrontEnd));
 216     if (!FrontEnd) return STATUS_NO_MEMORY;
 217
 218     Status = ConSrvLoadFrontEnd(FrontEnd,
 219                                 ConsoleInfo,
 220                                 ExtraConsoleInfo,
 221                                 ProcessId);
 222     if (!NT_SUCCESS(Status))
 223     {
 224         DPRINT1("CONSRV: Failed to initialize a frontend, Status = 0x%08lx\n", Status);
 225         ConsoleFreeHeap(FrontEnd);
 226         return Status;
 227     }
 228     DPRINT("CONSRV: Frontend initialized\n");
 229
 230     /* Initialize the ConSrv terminal */
 231     Terminal->Vtbl = &ConSrvTermVtbl;
 232     // Terminal->Console will be initialized by ConDrvRegisterTerminal
 233     Terminal->Context = FrontEnd; /* We store the frontend pointer in the terminal private context */
 234
 235     return STATUS_SUCCESS;
 236 }
 237
 238 NTSTATUS NTAPI
 239 ConSrvDeinitTerminal(IN OUT PTERMINAL Terminal)
 240 {
 241     NTSTATUS Status = STATUS_SUCCESS;
 242     PFRONTEND FrontEnd = Terminal->Context;
 243
 244     /* Reset the ConSrv terminal */
 245     Terminal->Context = NULL;
 246     Terminal->Vtbl = NULL;
 247
 248     /* Unload the frontend */
 249     if (FrontEnd != NULL)
 250     {
 251         Status = ConSrvUnloadFrontEnd(FrontEnd);
 252         ConsoleFreeHeap(FrontEnd);
 253     }
 254
 255     return Status;
 256 }
 257
 258
 259 /* CONSRV TERMINAL INTERFACE **************************************************/
 260
 261 static NTSTATUS NTAPI
 262 ConSrvTermInitTerminal(IN OUT PTERMINAL This,
 263                        IN PCONSOLE Console)
 264 {
 265     NTSTATUS Status;
 266     PFRONTEND FrontEnd = This->Context;
 267
 268     /* Initialize the console pointer for our frontend */
 269     FrontEnd->Console = Console;
 270
 271     /** HACK HACK!! Copy FrontEnd into the console!! **/
 272     DPRINT1("Using FrontEndIFace HACK(1), should be removed after proper implementation!\n");
 273     Console->FrontEndIFace = *FrontEnd;
 274
 275     Status = FrontEnd->Vtbl->InitFrontEnd(FrontEnd, FrontEnd->Console);
 276     if (!NT_SUCCESS(Status))
 277         DPRINT1("InitFrontEnd failed, Status = 0x%08lx\n", Status);
 278
 279     /** HACK HACK!! Be sure FrontEndIFace is correctly updated in the console!! **/
 280     DPRINT("Using FrontEndIFace HACK(2), should be removed after proper implementation!\n");
 281     Console->FrontEndIFace = *FrontEnd;
 282
 283     return Status;
 284 }
 285
 286 static VOID NTAPI
 287 ConSrvTermDeinitTerminal(IN OUT PTERMINAL This)
 288 {
 289     PFRONTEND FrontEnd = This->Context;
 290     FrontEnd->Vtbl->DeinitFrontEnd(FrontEnd);
 291 }
 292
 293
 294
 295 /************ Line discipline ***************/
 296
 297 static NTSTATUS NTAPI
 298 ConSrvTermReadStream(IN OUT PTERMINAL This,
 299                      IN BOOLEAN Unicode,
 300                      /**PWCHAR Buffer,**/
 301                      OUT PVOID Buffer,
 302                      IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
 303                      IN PVOID Parameter OPTIONAL,
 304                      IN ULONG NumCharsToRead,
 305                      OUT PULONG NumCharsRead OPTIONAL)
 306 {
 307     PFRONTEND FrontEnd = This->Context;
 308     PCONSRV_CONSOLE Console = FrontEnd->Console;
 309     PCONSOLE_INPUT_BUFFER InputBuffer = &Console->InputBuffer;
 310     PUNICODE_STRING ExeName = Parameter;
 311
 312     // STATUS_PENDING : Wait if more to read ; STATUS_SUCCESS : Don't wait.
 313     NTSTATUS Status = STATUS_PENDING;
 314
 315     PLIST_ENTRY CurrentEntry;
 316     ConsoleInput *Input;
 317     ULONG i;
 318
 319     /* Validity checks */
 320     // ASSERT(Console == InputBuffer->Header.Console);
 321     ASSERT((Buffer != NULL) || (Buffer == NULL && NumCharsToRead == 0));
 322
 323     /* We haven't read anything (yet) */
 324     i = ReadControl->nInitialChars;
 325
 326     if (InputBuffer->Mode & ENABLE_LINE_INPUT)
 327     {
 328         /* COOKED mode, call the line discipline */
 329
 330         if (Console->LineBuffer == NULL)
 331         {
 332             /* Starting a new line */
 333             Console->LineMaxSize = max(256, NumCharsToRead);
 334
 335             Console->LineBuffer = ConsoleAllocHeap(0, Console->LineMaxSize * sizeof(WCHAR));
 336             if (Console->LineBuffer == NULL) return STATUS_NO_MEMORY;
 337
 338             Console->LinePos = Console->LineSize = ReadControl->nInitialChars;
 339             Console->LineComplete = Console->LineUpPressed = FALSE;
 340             Console->LineInsertToggle = Console->InsertMode;
 341             Console->LineWakeupMask = ReadControl->dwCtrlWakeupMask;
 342
 343             /*
 344              * Pre-filling the buffer is only allowed in the Unicode API,
 345              * so we don't need to worry about ANSI <-> Unicode conversion.
 346              */
 347             memcpy(Console->LineBuffer, Buffer, Console->LineSize * sizeof(WCHAR));
 348             if (Console->LineSize == Console->LineMaxSize)
 349             {
 350                 Console->LineComplete = TRUE;
 351                 Console->LinePos = 0;
 352             }
 353         }
 354
 355         /* If we don't have a complete line yet, process the pending input */
 356         while (!Console->LineComplete && !IsListEmpty(&InputBuffer->InputEvents))
 357         {
 358             /* Remove input event from queue */
 359             CurrentEntry = RemoveHeadList(&InputBuffer->InputEvents);
 360             if (IsListEmpty(&InputBuffer->InputEvents))
 361             {
 362                 ResetEvent(InputBuffer->ActiveEvent);
 363             }
 364             Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
 365
 366             /* Only pay attention to key down */
 367             if (Input->InputEvent.EventType == KEY_EVENT &&
 368                 Input->InputEvent.Event.KeyEvent.bKeyDown)
 369             {
 370                 LineInputKeyDown(Console, ExeName,
 371                                  &Input->InputEvent.Event.KeyEvent);
 372                 ReadControl->dwControlKeyState = Input->InputEvent.Event.KeyEvent.dwControlKeyState;
 373             }
 374             ConsoleFreeHeap(Input);
 375         }
 376
 377         /* Check if we have a complete line to read from */
 378         if (Console->LineComplete)
 379         {
 380             while (i < NumCharsToRead && Console->LinePos != Console->LineSize)
 381             {
 382                 WCHAR Char = Console->LineBuffer[Console->LinePos++];
 383
 384                 if (Unicode)
 385                 {
 386                     ((PWCHAR)Buffer)[i] = Char;
 387                 }
 388                 else
 389                 {
 390                     ConsoleInputUnicodeCharToAnsiChar(Console, &((PCHAR)Buffer)[i], &Char);
 391                 }
 392                 ++i;
 393             }
 394
 395             if (Console->LinePos == Console->LineSize)
 396             {
 397                 /* Entire line has been read */
 398                 ConsoleFreeHeap(Console->LineBuffer);
 399                 Console->LineBuffer = NULL;
 400             }
 401
 402             Status = STATUS_SUCCESS;
 403         }
 404     }
 405     else
 406     {
 407         /* RAW mode */
 408
 409         /* Character input */
 410         while (i < NumCharsToRead && !IsListEmpty(&InputBuffer->InputEvents))
 411         {
 412             /* Remove input event from queue */
 413             CurrentEntry = RemoveHeadList(&InputBuffer->InputEvents);
 414             if (IsListEmpty(&InputBuffer->InputEvents))
 415             {
 416                 ResetEvent(InputBuffer->ActiveEvent);
 417             }
 418             Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
 419
 420             /* Only pay attention to valid characters, on key down */
 421             if (Input->InputEvent.EventType == KEY_EVENT  &&
 422                 Input->InputEvent.Event.KeyEvent.bKeyDown &&
 423                 Input->InputEvent.Event.KeyEvent.uChar.UnicodeChar != L'\0')
 424             {
 425                 WCHAR Char = Input->InputEvent.Event.KeyEvent.uChar.UnicodeChar;
 426
 427                 if (Unicode)
 428                 {
 429                     ((PWCHAR)Buffer)[i] = Char;
 430                 }
 431                 else
 432                 {
 433                     ConsoleInputUnicodeCharToAnsiChar(Console, &((PCHAR)Buffer)[i], &Char);
 434                 }
 435                 ++i;
 436
 437                 /* Did read something */
 438                 Status = STATUS_SUCCESS;
 439             }
 440             ConsoleFreeHeap(Input);
 441         }
 442     }
 443
 444     // FIXME: Only set if Status == STATUS_SUCCESS ???
 445     if (NumCharsRead) *NumCharsRead = i;
 446
 447     return Status;
 448 }
 449
 450
 451
 452
 453 /* GLOBALS ********************************************************************/
 454
 455 #define TAB_WIDTH   8
 456
 457 // See condrv/text.c
 458 /*static*/ VOID
 459 ClearLineBuffer(PTEXTMODE_SCREEN_BUFFER Buff);
 460
 461 static VOID
 462 ConioNextLine(PTEXTMODE_SCREEN_BUFFER Buff, PSMALL_RECT UpdateRect, PUINT ScrolledLines)
 463 {
 464     /* If we hit bottom, slide the viewable screen */
 465     if (++Buff->CursorPosition.Y == Buff->ScreenBufferSize.Y)
 466     {
 467         Buff->CursorPosition.Y--;
 468         if (++Buff->VirtualY == Buff->ScreenBufferSize.Y)
 469         {
 470             Buff->VirtualY = 0;
 471         }
 472         (*ScrolledLines)++;
 473         ClearLineBuffer(Buff);
 474         if (UpdateRect->Top != 0)
 475         {
 476             UpdateRect->Top--;
 477         }
 478     }
 479     UpdateRect->Left = 0;
 480     UpdateRect->Right = Buff->ScreenBufferSize.X - 1;
 481     UpdateRect->Bottom = Buff->CursorPosition.Y;
 482 }
 483
 484 static NTSTATUS
 485 ConioWriteConsole(PFRONTEND FrontEnd,
 486                   PTEXTMODE_SCREEN_BUFFER Buff,
 487                   PWCHAR Buffer,
 488                   DWORD Length,
 489                   BOOL Attrib)
 490 {
 491     PCONSRV_CONSOLE Console = FrontEnd->Console;
 492
 493     UINT i;
 494     PCHAR_INFO Ptr;
 495     SMALL_RECT UpdateRect;
 496     SHORT CursorStartX, CursorStartY;
 497     UINT ScrolledLines;
 498
 499     CursorStartX = Buff->CursorPosition.X;
 500     CursorStartY = Buff->CursorPosition.Y;
 501     UpdateRect.Left = Buff->ScreenBufferSize.X;
 502     UpdateRect.Top = Buff->CursorPosition.Y;
 503     UpdateRect.Right = -1;
 504     UpdateRect.Bottom = Buff->CursorPosition.Y;
 505     ScrolledLines = 0;
 506
 507     for (i = 0; i < Length; i++)
 508     {
 509         /*
 510          * If we are in processed mode, interpret special characters and
 511          * display them correctly. Otherwise, just put them into the buffer.
 512          */
 513         if (Buff->Mode & ENABLE_PROCESSED_OUTPUT)
 514         {
 515             /* --- CR --- */
 516             if (Buffer[i] == L'\r')
 517             {
 518                 Buff->CursorPosition.X = 0;
 519                 UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
 520                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
 521                 continue;
 522             }
 523             /* --- LF --- */
 524             else if (Buffer[i] == L'\n')
 525             {
 526                 Buff->CursorPosition.X = 0;
 527                 ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
 528                 continue;
 529             }
 530             /* --- BS --- */
 531             else if (Buffer[i] == L'\b')
 532             {
 533                 /* Only handle BS if we're not on the first pos of the first line */
 534                 if (0 != Buff->CursorPosition.X || 0 != Buff->CursorPosition.Y)
 535                 {
 536                     if (0 == Buff->CursorPosition.X)
 537                     {
 538                         /* slide virtual position up */
 539                         Buff->CursorPosition.X = Buff->ScreenBufferSize.X - 1;
 540                         Buff->CursorPosition.Y--;
 541                         UpdateRect.Top = min(UpdateRect.Top, Buff->CursorPosition.Y);
 542                     }
 543                     else
 544                     {
 545                         Buff->CursorPosition.X--;
 546                     }
 547                     Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 548                     Ptr->Char.UnicodeChar = L' ';
 549                     Ptr->Attributes  = Buff->ScreenDefaultAttrib;
 550                     UpdateRect.Left  = min(UpdateRect.Left, Buff->CursorPosition.X);
 551                     UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
 552                 }
 553                 continue;
 554             }
 555             /* --- TAB --- */
 556             else if (Buffer[i] == L'\t')
 557             {
 558                 UINT EndX;
 559
 560                 UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
 561                 EndX = (Buff->CursorPosition.X + TAB_WIDTH) & ~(TAB_WIDTH - 1);
 562                 EndX = min(EndX, (UINT)Buff->ScreenBufferSize.X);
 563                 Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 564                 while (Buff->CursorPosition.X < EndX)
 565                 {
 566                     Ptr->Char.UnicodeChar = L' ';
 567                     Ptr->Attributes = Buff->ScreenDefaultAttrib;
 568                     ++Ptr;
 569                     Buff->CursorPosition.X++;
 570                 }
 571                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X - 1);
 572                 if (Buff->CursorPosition.X == Buff->ScreenBufferSize.X)
 573                 {
 574                     if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
 575                     {
 576                         Buff->CursorPosition.X = 0;
 577                         ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
 578                     }
 579                     else
 580                     {
 581                         Buff->CursorPosition.X--;
 582                     }
 583                 }
 584                 continue;
 585             }
 586             /* --- BEL ---*/
 587             else if (Buffer[i] == L'\a')
 588             {
 589                 FrontEnd->Vtbl->RingBell(FrontEnd);
 590                 continue;
 591             }
 592         }
 593         UpdateRect.Left  = min(UpdateRect.Left, Buff->CursorPosition.X);
 594         UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
 595
 596         Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 597         Ptr->Char.UnicodeChar = Buffer[i];
 598         if (Attrib) Ptr->Attributes = Buff->ScreenDefaultAttrib;
 599
 600         Buff->CursorPosition.X++;
 601         if (Buff->CursorPosition.X == Buff->ScreenBufferSize.X)
 602         {
 603             if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
 604             {
 605                 Buff->CursorPosition.X = 0;
 606                 ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
 607             }
 608             else
 609             {
 610                 Buff->CursorPosition.X = CursorStartX;
 611             }
 612         }
 613     }
 614
 615     if (!ConioIsRectEmpty(&UpdateRect) && (PCONSOLE_SCREEN_BUFFER)Buff == Console->ActiveBuffer)
 616     {
 617         // TermWriteStream(Console, &UpdateRect, CursorStartX, CursorStartY,
 618                         // ScrolledLines, Buffer, Length);
 619         FrontEnd->Vtbl->WriteStream(FrontEnd,
 620                                     &UpdateRect,
 621                                     CursorStartX,
 622                                     CursorStartY,
 623                                     ScrolledLines,
 624                                     Buffer,
 625                                     Length);
 626     }
 627
 628     return STATUS_SUCCESS;
 629 }
 630
 631
 632
 633 static NTSTATUS NTAPI
 634 ConSrvTermWriteStream(IN OUT PTERMINAL This,
 635                       PTEXTMODE_SCREEN_BUFFER Buff,
 636                       PWCHAR Buffer,
 637                       DWORD Length,
 638                       BOOL Attrib)
 639 {
 640     PFRONTEND FrontEnd = This->Context;
 641     return ConioWriteConsole(FrontEnd,
 642                              Buff,
 643                              Buffer,
 644                              Length,
 645                              Attrib);
 646 }
 647
 648 /************ Line discipline ***************/
 649
 650
 651
 652 VOID
 653 ConioDrawConsole(PCONSRV_CONSOLE Console)
 654 {
 655     SMALL_RECT Region;
 656     PCONSOLE_SCREEN_BUFFER ActiveBuffer = Console->ActiveBuffer;
 657
 658     if (!ActiveBuffer) return;
 659
 660     ConioInitRect(&Region, 0, 0,
 661                   ActiveBuffer->ViewSize.Y - 1,
 662                   ActiveBuffer->ViewSize.X - 1);
 663     TermDrawRegion(Console, &Region);
 664     // Console->FrontEndIFace.Vtbl->DrawRegion(&Console->FrontEndIFace, &Region);
 665 }
 666
 667 static VOID NTAPI
 668 ConSrvTermDrawRegion(IN OUT PTERMINAL This,
 669                 SMALL_RECT* Region)
 670 {
 671     PFRONTEND FrontEnd = This->Context;
 672     FrontEnd->Vtbl->DrawRegion(FrontEnd, Region);
 673 }
 674
 675 static BOOL NTAPI
 676 ConSrvTermSetCursorInfo(IN OUT PTERMINAL This,
 677                    PCONSOLE_SCREEN_BUFFER ScreenBuffer)
 678 {
 679     PFRONTEND FrontEnd = This->Context;
 680     return FrontEnd->Vtbl->SetCursorInfo(FrontEnd, ScreenBuffer);
 681 }
 682
 683 static BOOL NTAPI
 684 ConSrvTermSetScreenInfo(IN OUT PTERMINAL This,
 685                    PCONSOLE_SCREEN_BUFFER ScreenBuffer,
 686                    SHORT OldCursorX,
 687                    SHORT OldCursorY)
 688 {
 689     PFRONTEND FrontEnd = This->Context;
 690     return FrontEnd->Vtbl->SetScreenInfo(FrontEnd,
 691                                          ScreenBuffer,
 692                                          OldCursorX,
 693                                          OldCursorY);
 694 }
 695
 696 static VOID NTAPI
 697 ConSrvTermResizeTerminal(IN OUT PTERMINAL This)
 698 {
 699     PFRONTEND FrontEnd = This->Context;
 700     FrontEnd->Vtbl->ResizeTerminal(FrontEnd);
 701 }
 702
 703 static VOID NTAPI
 704 ConSrvTermSetActiveScreenBuffer(IN OUT PTERMINAL This)
 705 {
 706     PFRONTEND FrontEnd = This->Context;
 707     FrontEnd->Vtbl->SetActiveScreenBuffer(FrontEnd);
 708 }
 709
 710 static VOID NTAPI
 711 ConSrvTermReleaseScreenBuffer(IN OUT PTERMINAL This,
 712                          IN PCONSOLE_SCREEN_BUFFER ScreenBuffer)
 713 {
 714     PFRONTEND FrontEnd = This->Context;
 715     FrontEnd->Vtbl->ReleaseScreenBuffer(FrontEnd, ScreenBuffer);
 716 }
 717
 718 static VOID NTAPI
 719 ConSrvTermGetLargestConsoleWindowSize(IN OUT PTERMINAL This,
 720                                  PCOORD pSize)
 721 {
 722     PFRONTEND FrontEnd = This->Context;
 723     FrontEnd->Vtbl->GetLargestConsoleWindowSize(FrontEnd, pSize);
 724 }
 725
 726 static BOOL NTAPI
 727 ConSrvTermSetPalette(IN OUT PTERMINAL This,
 728                 HPALETTE PaletteHandle,
 729                 UINT PaletteUsage)
 730 {
 731     PFRONTEND FrontEnd = This->Context;
 732     return FrontEnd->Vtbl->SetPalette(FrontEnd, PaletteHandle, PaletteUsage);
 733 }
 734
 735 static INT NTAPI
 736 ConSrvTermShowMouseCursor(IN OUT PTERMINAL This,
 737                      BOOL Show)
 738 {
 739     PFRONTEND FrontEnd = This->Context;
 740     return FrontEnd->Vtbl->ShowMouseCursor(FrontEnd, Show);
 741 }
 742
 743 static TERMINAL_VTBL ConSrvTermVtbl =
 744 {
 745     ConSrvTermInitTerminal,
 746     ConSrvTermDeinitTerminal,
 747
 748     ConSrvTermReadStream,
 749     ConSrvTermWriteStream,
 750
 751     ConSrvTermDrawRegion,
 752     ConSrvTermSetCursorInfo,
 753     ConSrvTermSetScreenInfo,
 754     ConSrvTermResizeTerminal,
 755     ConSrvTermSetActiveScreenBuffer,
 756     ConSrvTermReleaseScreenBuffer,
 757     ConSrvTermGetLargestConsoleWindowSize,
 758     ConSrvTermSetPalette,
 759     ConSrvTermShowMouseCursor,
 760 };
 761
 762 #if 0
 763 VOID
 764 ResetFrontEnd(IN PCONSOLE Console)
 765 {
 766     if (!Console) return;
 767
 768     /* Reinitialize the frontend interface */
 769     RtlZeroMemory(&Console->FrontEndIFace, sizeof(Console->FrontEndIFace));
 770     Console->FrontEndIFace.Vtbl = &ConSrvTermVtbl;
 771 }
 772 #endif
 773
 774 /* EOF */