reactos/win32ss/user/winsrv/consrv/condrv/text.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Driver DLL
   4  * FILE:            win32ss/user/winsrv/consrv/condrv/text.c
   5  * PURPOSE:         Console Output Functions for text-mode screen-buffers
   6  * PROGRAMMERS:     Jeffrey Morlan
   7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #include <consrv.h>
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 /* GLOBALS ********************************************************************/
  18
  19 #define TAB_WIDTH   8
  20
  21 /* PRIVATE FUNCTIONS **********************************************************/
  22
  23 CONSOLE_IO_OBJECT_TYPE
  24 TEXTMODE_BUFFER_GetType(PCONSOLE_SCREEN_BUFFER This)
  25 {
  26     // return This->Header.Type;
  27     return TEXTMODE_BUFFER;
  28 }
  29
  30 static CONSOLE_SCREEN_BUFFER_VTBL TextVtbl =
  31 {
  32     TEXTMODE_BUFFER_GetType,
  33 };
  34
  35
  36 static VOID FASTCALL
  37 ClearLineBuffer(PTEXTMODE_SCREEN_BUFFER Buff);
  38
  39
  40 NTSTATUS
  41 CONSOLE_SCREEN_BUFFER_Initialize(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
  42                                  IN OUT PCONSOLE Console,
  43                                  IN SIZE_T Size);
  44 VOID
  45 CONSOLE_SCREEN_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer);
  46
  47
  48 NTSTATUS
  49 TEXTMODE_BUFFER_Initialize(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
  50                            IN OUT PCONSOLE Console,
  51                            IN PTEXTMODE_BUFFER_INFO TextModeInfo)
  52 {
  53     NTSTATUS Status = STATUS_SUCCESS;
  54     PTEXTMODE_SCREEN_BUFFER NewBuffer = NULL;
  55
  56     if (Console == NULL || Buffer == NULL || TextModeInfo == NULL)
  57         return STATUS_INVALID_PARAMETER;
  58
  59     *Buffer = NULL;
  60
  61     Status = CONSOLE_SCREEN_BUFFER_Initialize((PCONSOLE_SCREEN_BUFFER*)&NewBuffer,
  62                                               Console,
  63                                               sizeof(TEXTMODE_SCREEN_BUFFER));
  64     if (!NT_SUCCESS(Status)) return Status;
  65     NewBuffer->Header.Type = TEXTMODE_BUFFER;
  66     NewBuffer->Vtbl = &TextVtbl;
  67
  68     NewBuffer->Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
  69                                          TextModeInfo->ScreenBufferSize.X *
  70                                          TextModeInfo->ScreenBufferSize.Y *
  71                                             sizeof(CHAR_INFO));
  72     if (NewBuffer->Buffer == NULL)
  73     {
  74         CONSOLE_SCREEN_BUFFER_Destroy((PCONSOLE_SCREEN_BUFFER)NewBuffer);
  75         return STATUS_INSUFFICIENT_RESOURCES;
  76     }
  77
  78     NewBuffer->ScreenBufferSize = NewBuffer->OldScreenBufferSize
  79                                 = TextModeInfo->ScreenBufferSize;
  80     NewBuffer->ViewSize = NewBuffer->OldViewSize
  81                         = Console->ConsoleSize;
  82
  83     NewBuffer->ViewOrigin.X = NewBuffer->ViewOrigin.Y = 0;
  84     NewBuffer->VirtualY = 0;
  85
  86     NewBuffer->CursorBlinkOn = NewBuffer->ForceCursorOff = FALSE;
  87     NewBuffer->CursorInfo.bVisible = (TextModeInfo->IsCursorVisible && (TextModeInfo->CursorSize != 0));
  88     NewBuffer->CursorInfo.dwSize   = min(max(TextModeInfo->CursorSize, 0), 100);
  89
  90     NewBuffer->ScreenDefaultAttrib = TextModeInfo->ScreenAttrib;
  91     NewBuffer->PopupDefaultAttrib  = TextModeInfo->PopupAttrib;
  92
  93     /* Initialize buffer to be empty with default attributes */
  94     for (NewBuffer->CursorPosition.Y = 0 ; NewBuffer->CursorPosition.Y < NewBuffer->ScreenBufferSize.Y; NewBuffer->CursorPosition.Y++)
  95     {
  96         ClearLineBuffer(NewBuffer);
  97     }
  98     NewBuffer->CursorPosition.X = NewBuffer->CursorPosition.Y = 0;
  99
 100     NewBuffer->Mode = ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
 101
 102     *Buffer = (PCONSOLE_SCREEN_BUFFER)NewBuffer;
 103     return STATUS_SUCCESS;
 104 }
 105
 106 VOID
 107 TEXTMODE_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer)
 108 {
 109     PTEXTMODE_SCREEN_BUFFER Buff = (PTEXTMODE_SCREEN_BUFFER)Buffer;
 110
 111     /*
 112      * IMPORTANT !! Reinitialize the type so that we don't enter a recursive
 113      * infinite loop when calling CONSOLE_SCREEN_BUFFER_Destroy.
 114      */
 115     Buffer->Header.Type = SCREEN_BUFFER;
 116
 117     ConsoleFreeHeap(Buff->Buffer);
 118
 119     CONSOLE_SCREEN_BUFFER_Destroy(Buffer);
 120 }
 121
 122
 123 PCHAR_INFO
 124 ConioCoordToPointer(PTEXTMODE_SCREEN_BUFFER Buff, ULONG X, ULONG Y)
 125 {
 126     return &Buff->Buffer[((Y + Buff->VirtualY) % Buff->ScreenBufferSize.Y) * Buff->ScreenBufferSize.X + X];
 127 }
 128
 129 static VOID FASTCALL
 130 ClearLineBuffer(PTEXTMODE_SCREEN_BUFFER Buff)
 131 {
 132     PCHAR_INFO Ptr = ConioCoordToPointer(Buff, 0, Buff->CursorPosition.Y);
 133     SHORT Pos;
 134
 135     for (Pos = 0; Pos < Buff->ScreenBufferSize.X; Pos++, Ptr++)
 136     {
 137         /* Fill the cell */
 138         Ptr->Char.UnicodeChar = L' ';
 139         Ptr->Attributes = Buff->ScreenDefaultAttrib;
 140     }
 141 }
 142
 143 static __inline BOOLEAN
 144 ConioGetIntersection(OUT PSMALL_RECT Intersection,
 145                      IN PSMALL_RECT Rect1,
 146                      IN PSMALL_RECT Rect2)
 147 {
 148     if ( ConioIsRectEmpty(Rect1) ||
 149          ConioIsRectEmpty(Rect2) ||
 150         (Rect1->Top  > Rect2->Bottom) ||
 151         (Rect1->Left > Rect2->Right)  ||
 152         (Rect1->Bottom < Rect2->Top)  ||
 153         (Rect1->Right  < Rect2->Left) )
 154     {
 155         /* The rectangles do not intersect */
 156         ConioInitRect(Intersection, 0, -1, 0, -1);
 157         return FALSE;
 158     }
 159
 160     ConioInitRect(Intersection,
 161                   max(Rect1->Top   , Rect2->Top   ),
 162                   max(Rect1->Left  , Rect2->Left  ),
 163                   min(Rect1->Bottom, Rect2->Bottom),
 164                   min(Rect1->Right , Rect2->Right ));
 165
 166     return TRUE;
 167 }
 168
 169 static __inline BOOLEAN
 170 ConioGetUnion(OUT PSMALL_RECT Union,
 171               IN PSMALL_RECT Rect1,
 172               IN PSMALL_RECT Rect2)
 173 {
 174     if (ConioIsRectEmpty(Rect1))
 175     {
 176         if (ConioIsRectEmpty(Rect2))
 177         {
 178             ConioInitRect(Union, 0, -1, 0, -1);
 179             return FALSE;
 180         }
 181         else
 182         {
 183             *Union = *Rect2;
 184         }
 185     }
 186     else if (ConioIsRectEmpty(Rect2))
 187     {
 188         *Union = *Rect1;
 189     }
 190     else
 191     {
 192         ConioInitRect(Union,
 193                       min(Rect1->Top   , Rect2->Top   ),
 194                       min(Rect1->Left  , Rect2->Left  ),
 195                       max(Rect1->Bottom, Rect2->Bottom),
 196                       max(Rect1->Right , Rect2->Right ));
 197     }
 198
 199     return TRUE;
 200 }
 201
 202 static VOID FASTCALL
 203 ConioComputeUpdateRect(IN PTEXTMODE_SCREEN_BUFFER Buff,
 204                        IN OUT PSMALL_RECT UpdateRect,
 205                        IN PCOORD Start,
 206                        IN UINT Length)
 207 {
 208     if (Buff->ScreenBufferSize.X <= Start->X + Length)
 209     {
 210         UpdateRect->Left = 0;
 211     }
 212     else
 213     {
 214         UpdateRect->Left = Start->X;
 215     }
 216     if (Buff->ScreenBufferSize.X <= Start->X + Length)
 217     {
 218         UpdateRect->Right = Buff->ScreenBufferSize.X - 1;
 219     }
 220     else
 221     {
 222         UpdateRect->Right = Start->X + Length - 1;
 223     }
 224     UpdateRect->Top = Start->Y;
 225     UpdateRect->Bottom = Start->Y + (Start->X + Length - 1) / Buff->ScreenBufferSize.X;
 226     if (Buff->ScreenBufferSize.Y <= UpdateRect->Bottom)
 227     {
 228         UpdateRect->Bottom = Buff->ScreenBufferSize.Y - 1;
 229     }
 230 }
 231
 232 /*
 233  * Move from one rectangle to another. We must be careful about the order that
 234  * this is done, to avoid overwriting parts of the source before they are moved.
 235  */
 236 static VOID FASTCALL
 237 ConioMoveRegion(PTEXTMODE_SCREEN_BUFFER ScreenBuffer,
 238                 PSMALL_RECT SrcRegion,
 239                 PSMALL_RECT DstRegion,
 240                 PSMALL_RECT ClipRegion,
 241                 CHAR_INFO FillChar)
 242 {
 243     int Width  = ConioRectWidth(SrcRegion);
 244     int Height = ConioRectHeight(SrcRegion);
 245     int SX, SY;
 246     int DX, DY;
 247     int XDelta, YDelta;
 248     int i, j;
 249
 250     SY = SrcRegion->Top;
 251     DY = DstRegion->Top;
 252     YDelta = 1;
 253     if (SY < DY)
 254     {
 255         /* Moving down: work from bottom up */
 256         SY = SrcRegion->Bottom;
 257         DY = DstRegion->Bottom;
 258         YDelta = -1;
 259     }
 260     for (i = 0; i < Height; i++)
 261     {
 262         PCHAR_INFO SRow = ConioCoordToPointer(ScreenBuffer, 0, SY);
 263         PCHAR_INFO DRow = ConioCoordToPointer(ScreenBuffer, 0, DY);
 264
 265         SX = SrcRegion->Left;
 266         DX = DstRegion->Left;
 267         XDelta = 1;
 268         if (SX < DX)
 269         {
 270             /* Moving right: work from right to left */
 271             SX = SrcRegion->Right;
 272             DX = DstRegion->Right;
 273             XDelta = -1;
 274         }
 275         for (j = 0; j < Width; j++)
 276         {
 277             CHAR_INFO Cell = SRow[SX];
 278             if (SX >= ClipRegion->Left && SX <= ClipRegion->Right &&
 279                 SY >= ClipRegion->Top  && SY <= ClipRegion->Bottom)
 280             {
 281                 SRow[SX] = FillChar;
 282             }
 283             if (DX >= ClipRegion->Left && DX <= ClipRegion->Right &&
 284                 DY >= ClipRegion->Top  && DY <= ClipRegion->Bottom)
 285             {
 286                 DRow[DX] = Cell;
 287             }
 288             SX += XDelta;
 289             DX += XDelta;
 290         }
 291         SY += YDelta;
 292         DY += YDelta;
 293     }
 294 }
 295
 296 DWORD FASTCALL
 297 ConioEffectiveCursorSize(PCONSOLE Console, DWORD Scale)
 298 {
 299     DWORD Size = (Console->ActiveBuffer->CursorInfo.dwSize * Scale + 99) / 100;
 300     /* If line input in progress, perhaps adjust for insert toggle */
 301     if (Console->LineBuffer && !Console->LineComplete && Console->LineInsertToggle)
 302         return (Size * 2 <= Scale) ? (Size * 2) : (Size / 2);
 303     return Size;
 304 }
 305
 306 NTSTATUS
 307 ConioResizeBuffer(PCONSOLE Console,
 308                   PTEXTMODE_SCREEN_BUFFER ScreenBuffer,
 309                   COORD Size)
 310 {
 311     PCHAR_INFO Buffer;
 312     DWORD Offset = 0;
 313     PCHAR_INFO ptr;
 314     WORD CurrentAttribute;
 315     USHORT CurrentY;
 316     PCHAR_INFO OldBuffer;
 317     DWORD i;
 318     DWORD diff;
 319
 320     /* Buffer size is not allowed to be smaller than the view size */
 321     if (Size.X < ScreenBuffer->ViewSize.X || Size.Y < ScreenBuffer->ViewSize.Y)
 322         return STATUS_INVALID_PARAMETER;
 323
 324     if (Size.X == ScreenBuffer->ScreenBufferSize.X && Size.Y == ScreenBuffer->ScreenBufferSize.Y)
 325     {
 326         // FIXME: Trigger a buffer resize event ??
 327         return STATUS_SUCCESS;
 328     }
 329
 330     if (Console->FixedSize)
 331     {
 332         /*
 333          * The console is in fixed-size mode, so we cannot resize anything
 334          * at the moment. However, keep those settings somewhere so that
 335          * we can try to set them up when we will be allowed to do so.
 336          */
 337         ScreenBuffer->OldScreenBufferSize = Size;
 338         return STATUS_NOT_SUPPORTED; // STATUS_SUCCESS
 339     }
 340
 341     Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, Size.X * Size.Y * sizeof(CHAR_INFO));
 342     if (!Buffer) return STATUS_NO_MEMORY;
 343
 344     DPRINT1("Resizing (%d,%d) to (%d,%d)\n", ScreenBuffer->ScreenBufferSize.X, ScreenBuffer->ScreenBufferSize.Y, Size.X, Size.Y);
 345     OldBuffer = ScreenBuffer->Buffer;
 346
 347     for (CurrentY = 0; CurrentY < ScreenBuffer->ScreenBufferSize.Y && CurrentY < Size.Y; CurrentY++)
 348     {
 349         ptr = ConioCoordToPointer(ScreenBuffer, 0, CurrentY);
 350         if (Size.X <= ScreenBuffer->ScreenBufferSize.X)
 351         {
 352             /* Reduce size */
 353             RtlCopyMemory(Buffer + Offset, ptr, Size.X * sizeof(CHAR_INFO));
 354             Offset += Size.X;
 355         }
 356         else
 357         {
 358             /* Enlarge size */
 359             RtlCopyMemory(Buffer + Offset, ptr, ScreenBuffer->ScreenBufferSize.X * sizeof(CHAR_INFO));
 360             Offset += ScreenBuffer->ScreenBufferSize.X;
 361
 362             /* The attribute to be used is the one of the last cell of the current line */
 363             CurrentAttribute = ConioCoordToPointer(ScreenBuffer,
 364                                                    ScreenBuffer->ScreenBufferSize.X - 1,
 365                                                    CurrentY)->Attributes;
 366
 367             diff = Size.X - ScreenBuffer->ScreenBufferSize.X;
 368
 369             /* Zero-out the new part of the buffer */
 370             for (i = 0; i < diff; i++)
 371             {
 372                 ptr = Buffer + Offset;
 373                 ptr->Char.UnicodeChar = L' ';
 374                 ptr->Attributes = CurrentAttribute;
 375                 ++Offset;
 376             }
 377         }
 378     }
 379
 380     if (Size.Y > ScreenBuffer->ScreenBufferSize.Y)
 381     {
 382         diff = Size.X * (Size.Y - ScreenBuffer->ScreenBufferSize.Y);
 383
 384         /* Zero-out the new part of the buffer */
 385         for (i = 0; i < diff; i++)
 386         {
 387             ptr = Buffer + Offset;
 388             ptr->Char.UnicodeChar = L' ';
 389             ptr->Attributes = ScreenBuffer->ScreenDefaultAttrib;
 390             ++Offset;
 391         }
 392     }
 393
 394     (void)InterlockedExchangePointer((PVOID volatile*)&ScreenBuffer->Buffer, Buffer);
 395     ConsoleFreeHeap(OldBuffer);
 396     ScreenBuffer->ScreenBufferSize = ScreenBuffer->OldScreenBufferSize = Size;
 397     ScreenBuffer->VirtualY = 0;
 398
 399     /* Ensure cursor and window are within buffer */
 400     if (ScreenBuffer->CursorPosition.X >= Size.X)
 401         ScreenBuffer->CursorPosition.X = Size.X - 1;
 402     if (ScreenBuffer->CursorPosition.Y >= Size.Y)
 403         ScreenBuffer->CursorPosition.Y = Size.Y - 1;
 404     if (ScreenBuffer->ViewOrigin.X > Size.X - ScreenBuffer->ViewSize.X)
 405         ScreenBuffer->ViewOrigin.X = Size.X - ScreenBuffer->ViewSize.X;
 406     if (ScreenBuffer->ViewOrigin.Y > Size.Y - ScreenBuffer->ViewSize.Y)
 407         ScreenBuffer->ViewOrigin.Y = Size.Y - ScreenBuffer->ViewSize.Y;
 408
 409     /*
 410      * Trigger a buffer resize event
 411      */
 412     if (Console->InputBuffer.Mode & ENABLE_WINDOW_INPUT)
 413     {
 414         INPUT_RECORD er;
 415
 416         er.EventType = WINDOW_BUFFER_SIZE_EVENT;
 417         er.Event.WindowBufferSizeEvent.dwSize = ScreenBuffer->ScreenBufferSize;
 418
 419         ConioProcessInputEvent(Console, &er);
 420     }
 421
 422     return STATUS_SUCCESS;
 423 }
 424
 425 static VOID FASTCALL
 426 ConioNextLine(PTEXTMODE_SCREEN_BUFFER Buff, PSMALL_RECT UpdateRect, PUINT ScrolledLines)
 427 {
 428     /* If we hit bottom, slide the viewable screen */
 429     if (++Buff->CursorPosition.Y == Buff->ScreenBufferSize.Y)
 430     {
 431         Buff->CursorPosition.Y--;
 432         if (++Buff->VirtualY == Buff->ScreenBufferSize.Y)
 433         {
 434             Buff->VirtualY = 0;
 435         }
 436         (*ScrolledLines)++;
 437         ClearLineBuffer(Buff);
 438         if (UpdateRect->Top != 0)
 439         {
 440             UpdateRect->Top--;
 441         }
 442     }
 443     UpdateRect->Left = 0;
 444     UpdateRect->Right = Buff->ScreenBufferSize.X - 1;
 445     UpdateRect->Bottom = Buff->CursorPosition.Y;
 446 }
 447
 448 NTSTATUS
 449 ConioWriteConsole(PCONSOLE Console,
 450                   PTEXTMODE_SCREEN_BUFFER Buff,
 451                   PWCHAR Buffer,
 452                   DWORD Length,
 453                   BOOL Attrib)
 454 {
 455     UINT i;
 456     PCHAR_INFO Ptr;
 457     SMALL_RECT UpdateRect;
 458     SHORT CursorStartX, CursorStartY;
 459     UINT ScrolledLines;
 460
 461     CursorStartX = Buff->CursorPosition.X;
 462     CursorStartY = Buff->CursorPosition.Y;
 463     UpdateRect.Left = Buff->ScreenBufferSize.X;
 464     UpdateRect.Top = Buff->CursorPosition.Y;
 465     UpdateRect.Right = -1;
 466     UpdateRect.Bottom = Buff->CursorPosition.Y;
 467     ScrolledLines = 0;
 468
 469     for (i = 0; i < Length; i++)
 470     {
 471         /*
 472          * If we are in processed mode, interpret special characters and
 473          * display them correctly. Otherwise, just put them into the buffer.
 474          */
 475         if (Buff->Mode & ENABLE_PROCESSED_OUTPUT)
 476         {
 477             /* --- CR --- */
 478             if (Buffer[i] == L'\r')
 479             {
 480                 Buff->CursorPosition.X = 0;
 481                 UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
 482                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
 483                 continue;
 484             }
 485             /* --- LF --- */
 486             else if (Buffer[i] == L'\n')
 487             {
 488                 Buff->CursorPosition.X = 0;
 489                 ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
 490                 continue;
 491             }
 492             /* --- BS --- */
 493             else if (Buffer[i] == L'\b')
 494             {
 495                 /* Only handle BS if we're not on the first pos of the first line */
 496                 if (0 != Buff->CursorPosition.X || 0 != Buff->CursorPosition.Y)
 497                 {
 498                     if (0 == Buff->CursorPosition.X)
 499                     {
 500                         /* slide virtual position up */
 501                         Buff->CursorPosition.X = Buff->ScreenBufferSize.X - 1;
 502                         Buff->CursorPosition.Y--;
 503                         UpdateRect.Top = min(UpdateRect.Top, Buff->CursorPosition.Y);
 504                     }
 505                     else
 506                     {
 507                         Buff->CursorPosition.X--;
 508                     }
 509                     Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 510                     Ptr->Char.UnicodeChar = L' ';
 511                     Ptr->Attributes  = Buff->ScreenDefaultAttrib;
 512                     UpdateRect.Left  = min(UpdateRect.Left, Buff->CursorPosition.X);
 513                     UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
 514                 }
 515                 continue;
 516             }
 517             /* --- TAB --- */
 518             else if (Buffer[i] == L'\t')
 519             {
 520                 UINT EndX;
 521
 522                 UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
 523                 EndX = (Buff->CursorPosition.X + TAB_WIDTH) & ~(TAB_WIDTH - 1);
 524                 EndX = min(EndX, (UINT)Buff->ScreenBufferSize.X);
 525                 Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 526                 while (Buff->CursorPosition.X < EndX)
 527                 {
 528                     Ptr->Char.UnicodeChar = L' ';
 529                     Ptr->Attributes = Buff->ScreenDefaultAttrib;
 530                     ++Ptr;
 531                     Buff->CursorPosition.X++;
 532                 }
 533                 UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X - 1);
 534                 if (Buff->CursorPosition.X == Buff->ScreenBufferSize.X)
 535                 {
 536                     if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
 537                     {
 538                         Buff->CursorPosition.X = 0;
 539                         ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
 540                     }
 541                     else
 542                     {
 543                         Buff->CursorPosition.X--;
 544                     }
 545                 }
 546                 continue;
 547             }
 548             // /* --- BEL ---*/
 549             // else if (Buffer[i] == L'\a')
 550             // {
 551                 // // FIXME: This MUST BE moved to the terminal emulator frontend!!
 552                 // DPRINT1("Bell\n");
 553                 // // SendNotifyMessage(Console->hWindow, PM_CONSOLE_BEEP, 0, 0);
 554                 // continue;
 555             // }
 556         }
 557         UpdateRect.Left  = min(UpdateRect.Left, Buff->CursorPosition.X);
 558         UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
 559
 560         Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 561         Ptr->Char.UnicodeChar = Buffer[i];
 562         if (Attrib) Ptr->Attributes = Buff->ScreenDefaultAttrib;
 563
 564         Buff->CursorPosition.X++;
 565         if (Buff->CursorPosition.X == Buff->ScreenBufferSize.X)
 566         {
 567             if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
 568             {
 569                 Buff->CursorPosition.X = 0;
 570                 ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
 571             }
 572             else
 573             {
 574                 Buff->CursorPosition.X = CursorStartX;
 575             }
 576         }
 577     }
 578
 579     if (!ConioIsRectEmpty(&UpdateRect) && (PCONSOLE_SCREEN_BUFFER)Buff == Console->ActiveBuffer)
 580     {
 581         TermWriteStream(Console, &UpdateRect, CursorStartX, CursorStartY,
 582                         ScrolledLines, Buffer, Length);
 583     }
 584
 585     return STATUS_SUCCESS;
 586 }
 587
 588
 589 /* PUBLIC DRIVER APIS *********************************************************/
 590
 591 NTSTATUS NTAPI
 592 ConDrvReadConsoleOutput(IN PCONSOLE Console,
 593                         IN PTEXTMODE_SCREEN_BUFFER Buffer,
 594                         IN BOOLEAN Unicode,
 595                         OUT PCHAR_INFO CharInfo/*Buffer*/,
 596                         IN PCOORD BufferSize,
 597                         IN PCOORD BufferCoord,
 598                         IN OUT PSMALL_RECT ReadRegion)
 599 {
 600     PCHAR_INFO CurCharInfo;
 601     SHORT SizeX, SizeY;
 602     SMALL_RECT CapturedReadRegion;
 603     SMALL_RECT ScreenRect;
 604     DWORD i;
 605     PCHAR_INFO Ptr;
 606     LONG X, Y;
 607     UINT CodePage;
 608
 609     if (Console == NULL || Buffer == NULL || CharInfo == NULL ||
 610         BufferSize == NULL || BufferCoord == NULL || ReadRegion == NULL)
 611     {
 612         return STATUS_INVALID_PARAMETER;
 613     }
 614
 615     /* Validity check */
 616     ASSERT(Console == Buffer->Header.Console);
 617
 618     CapturedReadRegion = *ReadRegion;
 619
 620     /* FIXME: Is this correct? */
 621     CodePage = Console->OutputCodePage;
 622
 623     SizeX = min(BufferSize->X - BufferCoord->X, ConioRectWidth(&CapturedReadRegion));
 624     SizeY = min(BufferSize->Y - BufferCoord->Y, ConioRectHeight(&CapturedReadRegion));
 625     CapturedReadRegion.Right  = CapturedReadRegion.Left + SizeX;
 626     CapturedReadRegion.Bottom = CapturedReadRegion.Top  + SizeY;
 627
 628     ConioInitRect(&ScreenRect, 0, 0, Buffer->ScreenBufferSize.Y, Buffer->ScreenBufferSize.X);
 629     if (!ConioGetIntersection(&CapturedReadRegion, &ScreenRect, &CapturedReadRegion))
 630     {
 631         return STATUS_SUCCESS;
 632     }
 633
 634     for (i = 0, Y = CapturedReadRegion.Top; Y < CapturedReadRegion.Bottom; ++i, ++Y)
 635     {
 636         CurCharInfo = CharInfo + (i * BufferSize->X);
 637
 638         Ptr = ConioCoordToPointer(Buffer, CapturedReadRegion.Left, Y);
 639         for (X = CapturedReadRegion.Left; X < CapturedReadRegion.Right; ++X)
 640         {
 641             if (Unicode)
 642             {
 643                 CurCharInfo->Char.UnicodeChar = Ptr->Char.UnicodeChar;
 644             }
 645             else
 646             {
 647                 // ConsoleUnicodeCharToAnsiChar(Console, &CurCharInfo->Char.AsciiChar, &Ptr->Char.UnicodeChar);
 648                 WideCharToMultiByte(CodePage, 0, &Ptr->Char.UnicodeChar, 1,
 649                                     &CurCharInfo->Char.AsciiChar, 1, NULL, NULL);
 650             }
 651             CurCharInfo->Attributes = Ptr->Attributes;
 652             ++Ptr;
 653             ++CurCharInfo;
 654         }
 655     }
 656
 657     ReadRegion->Left   = CapturedReadRegion.Left;
 658     ReadRegion->Top    = CapturedReadRegion.Top ;
 659     ReadRegion->Right  = CapturedReadRegion.Left + SizeX - 1;
 660     ReadRegion->Bottom = CapturedReadRegion.Top  + SizeY - 1;
 661
 662     return STATUS_SUCCESS;
 663 }
 664
 665 NTSTATUS NTAPI
 666 ConDrvWriteConsoleOutput(IN PCONSOLE Console,
 667                          IN PTEXTMODE_SCREEN_BUFFER Buffer,
 668                          IN BOOLEAN Unicode,
 669                          IN PCHAR_INFO CharInfo/*Buffer*/,
 670                          IN PCOORD BufferSize,
 671                          IN PCOORD BufferCoord,
 672                          IN OUT PSMALL_RECT WriteRegion)
 673 {
 674     SHORT i, X, Y, SizeX, SizeY;
 675     SMALL_RECT ScreenBuffer;
 676     PCHAR_INFO CurCharInfo;
 677     SMALL_RECT CapturedWriteRegion;
 678     PCHAR_INFO Ptr;
 679
 680     if (Console == NULL || Buffer == NULL || CharInfo == NULL ||
 681         BufferSize == NULL || BufferCoord == NULL || WriteRegion == NULL)
 682     {
 683         return STATUS_INVALID_PARAMETER;
 684     }
 685
 686     /* Validity check */
 687     ASSERT(Console == Buffer->Header.Console);
 688
 689     CapturedWriteRegion = *WriteRegion;
 690
 691     SizeX = min(BufferSize->X - BufferCoord->X, ConioRectWidth(&CapturedWriteRegion));
 692     SizeY = min(BufferSize->Y - BufferCoord->Y, ConioRectHeight(&CapturedWriteRegion));
 693     CapturedWriteRegion.Right  = CapturedWriteRegion.Left + SizeX - 1;
 694     CapturedWriteRegion.Bottom = CapturedWriteRegion.Top  + SizeY - 1;
 695
 696     /* Make sure WriteRegion is inside the screen buffer */
 697     ConioInitRect(&ScreenBuffer, 0, 0, Buffer->ScreenBufferSize.Y - 1, Buffer->ScreenBufferSize.X - 1);
 698     if (!ConioGetIntersection(&CapturedWriteRegion, &ScreenBuffer, &CapturedWriteRegion))
 699     {
 700         /*
 701          * It is okay to have a WriteRegion completely outside
 702          * the screen buffer. No data is written then.
 703          */
 704         return STATUS_SUCCESS;
 705     }
 706
 707     for (i = 0, Y = CapturedWriteRegion.Top; Y <= CapturedWriteRegion.Bottom; i++, Y++)
 708     {
 709         CurCharInfo = CharInfo + (i + BufferCoord->Y) * BufferSize->X + BufferCoord->X;
 710
 711         Ptr = ConioCoordToPointer(Buffer, CapturedWriteRegion.Left, Y);
 712         for (X = CapturedWriteRegion.Left; X <= CapturedWriteRegion.Right; X++)
 713         {
 714             if (Unicode)
 715             {
 716                 Ptr->Char.UnicodeChar = CurCharInfo->Char.UnicodeChar;
 717             }
 718             else
 719             {
 720                 ConsoleAnsiCharToUnicodeChar(Console, &Ptr->Char.UnicodeChar, &CurCharInfo->Char.AsciiChar);
 721             }
 722             Ptr->Attributes = CurCharInfo->Attributes;
 723             ++Ptr;
 724             ++CurCharInfo;
 725         }
 726     }
 727
 728     TermDrawRegion(Console, &CapturedWriteRegion);
 729
 730     WriteRegion->Left   = CapturedWriteRegion.Left;
 731     WriteRegion->Top    = CapturedWriteRegion.Top ;
 732     WriteRegion->Right  = CapturedWriteRegion.Left + SizeX - 1;
 733     WriteRegion->Bottom = CapturedWriteRegion.Top  + SizeY - 1;
 734
 735     return STATUS_SUCCESS;
 736 }
 737
 738 NTSTATUS NTAPI
 739 ConDrvWriteConsole(IN PCONSOLE Console,
 740                    IN PTEXTMODE_SCREEN_BUFFER ScreenBuffer,
 741                    IN BOOLEAN Unicode,
 742                    IN PVOID StringBuffer,
 743                    IN ULONG NumCharsToWrite,
 744                    OUT PULONG NumCharsWritten OPTIONAL)
 745 {
 746     NTSTATUS Status = STATUS_SUCCESS;
 747     PWCHAR Buffer = NULL;
 748     ULONG Written = 0;
 749     ULONG Length;
 750
 751     if (Console == NULL || ScreenBuffer == NULL /* || StringBuffer == NULL */)
 752         return STATUS_INVALID_PARAMETER;
 753
 754     /* Validity checks */
 755     ASSERT(Console == ScreenBuffer->Header.Console);
 756     ASSERT( (StringBuffer != NULL && NumCharsToWrite >= 0) ||
 757             (StringBuffer == NULL && NumCharsToWrite == 0) );
 758
 759     // if (Console->PauseFlags & (PAUSED_FROM_KEYBOARD | PAUSED_FROM_SCROLLBAR | PAUSED_FROM_SELECTION))
 760     if (Console->PauseFlags && Console->UnpauseEvent != NULL)
 761     {
 762         return STATUS_PENDING;
 763     }
 764
 765     if (Unicode)
 766     {
 767         Buffer = StringBuffer;
 768     }
 769     else
 770     {
 771         Length = MultiByteToWideChar(Console->OutputCodePage, 0,
 772                                      (PCHAR)StringBuffer,
 773                                      NumCharsToWrite,
 774                                      NULL, 0);
 775         Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length * sizeof(WCHAR));
 776         if (Buffer)
 777         {
 778             MultiByteToWideChar(Console->OutputCodePage, 0,
 779                                 (PCHAR)StringBuffer,
 780                                 NumCharsToWrite,
 781                                 (PWCHAR)Buffer, Length);
 782         }
 783         else
 784         {
 785             Status = STATUS_NO_MEMORY;
 786         }
 787     }
 788
 789     if (Buffer)
 790     {
 791         if (NT_SUCCESS(Status))
 792         {
 793             Status = ConioWriteConsole(Console,
 794                                        ScreenBuffer,
 795                                        Buffer,
 796                                        NumCharsToWrite,
 797                                        TRUE);
 798             if (NT_SUCCESS(Status))
 799             {
 800                 Written = NumCharsToWrite;
 801             }
 802         }
 803
 804         if (!Unicode) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 805     }
 806
 807     if (NumCharsWritten) *NumCharsWritten = Written;
 808
 809     return Status;
 810 }
 811
 812 NTSTATUS NTAPI
 813 ConDrvReadConsoleOutputString(IN PCONSOLE Console,
 814                               IN PTEXTMODE_SCREEN_BUFFER Buffer,
 815                               IN CODE_TYPE CodeType,
 816                               OUT PVOID StringBuffer,
 817                               IN ULONG NumCodesToRead,
 818                               IN PCOORD ReadCoord,
 819                               OUT PCOORD EndCoord,
 820                               OUT PULONG CodesRead)
 821 {
 822     SHORT Xpos, Ypos;
 823     PVOID ReadBuffer;
 824     ULONG i;
 825     ULONG CodeSize;
 826     PCHAR_INFO Ptr;
 827
 828     if (Console == NULL || Buffer == NULL ||
 829         ReadCoord == NULL || EndCoord == NULL || CodesRead == NULL)
 830     {
 831         return STATUS_INVALID_PARAMETER;
 832     }
 833
 834     /* Validity checks */
 835     ASSERT(Console == Buffer->Header.Console);
 836     ASSERT( (StringBuffer != NULL && NumCodesToRead >= 0) ||
 837             (StringBuffer == NULL && NumCodesToRead == 0) );
 838
 839     switch (CodeType)
 840     {
 841         case CODE_ASCII:
 842             CodeSize = sizeof(CHAR);
 843             break;
 844
 845         case CODE_UNICODE:
 846             CodeSize = sizeof(WCHAR);
 847             break;
 848
 849         case CODE_ATTRIBUTE:
 850             CodeSize = sizeof(WORD);
 851             break;
 852
 853         default:
 854             return STATUS_INVALID_PARAMETER;
 855     }
 856
 857     ReadBuffer = StringBuffer;
 858     Xpos = ReadCoord->X;
 859     Ypos = (ReadCoord->Y + Buffer->VirtualY) % Buffer->ScreenBufferSize.Y;
 860
 861     /*
 862      * MSDN (ReadConsoleOutputAttribute and ReadConsoleOutputCharacter) :
 863      *
 864      * If the number of attributes (resp. characters) to be read from extends
 865      * beyond the end of the specified screen buffer row, attributes (resp.
 866      * characters) are read from the next row. If the number of attributes
 867      * (resp. characters) to be read from extends beyond the end of the console
 868      * screen buffer, attributes (resp. characters) up to the end of the console
 869      * screen buffer are read.
 870      *
 871      * TODO: Do NOT loop up to NumCodesToRead, but stop before
 872      * if we are going to overflow...
 873      */
 874     // Ptr = ConioCoordToPointer(Buffer, Xpos, Ypos); // Doesn't work
 875     for (i = 0; i < min(NumCodesToRead, Buffer->ScreenBufferSize.X * Buffer->ScreenBufferSize.Y); ++i)
 876     {
 877         // Ptr = ConioCoordToPointer(Buffer, Xpos, Ypos); // Doesn't work either
 878         Ptr = &Buffer->Buffer[Xpos + Ypos * Buffer->ScreenBufferSize.X];
 879
 880         switch (CodeType)
 881         {
 882             case CODE_ASCII:
 883                 ConsoleUnicodeCharToAnsiChar(Console, (PCHAR)ReadBuffer, &Ptr->Char.UnicodeChar);
 884                 break;
 885
 886             case CODE_UNICODE:
 887                 *(PWCHAR)ReadBuffer = Ptr->Char.UnicodeChar;
 888                 break;
 889
 890             case CODE_ATTRIBUTE:
 891                 *(PWORD)ReadBuffer = Ptr->Attributes;
 892                 break;
 893         }
 894         ReadBuffer = (PVOID)((ULONG_PTR)ReadBuffer + CodeSize);
 895         // ++Ptr;
 896
 897         Xpos++;
 898
 899         if (Xpos == Buffer->ScreenBufferSize.X)
 900         {
 901             Xpos = 0;
 902             Ypos++;
 903
 904             if (Ypos == Buffer->ScreenBufferSize.Y)
 905             {
 906                 Ypos = 0;
 907             }
 908         }
 909     }
 910
 911     // switch (CodeType)
 912     // {
 913         // case CODE_UNICODE:
 914             // *(PWCHAR)ReadBuffer = 0;
 915             // break;
 916
 917         // case CODE_ASCII:
 918             // *(PCHAR)ReadBuffer = 0;
 919             // break;
 920
 921         // case CODE_ATTRIBUTE:
 922             // *(PWORD)ReadBuffer = 0;
 923             // break;
 924     // }
 925
 926     EndCoord->X = Xpos;
 927     EndCoord->Y = (Ypos - Buffer->VirtualY + Buffer->ScreenBufferSize.Y) % Buffer->ScreenBufferSize.Y;
 928
 929     *CodesRead = (ULONG)((ULONG_PTR)ReadBuffer - (ULONG_PTR)StringBuffer) / CodeSize;
 930     // <= NumCodesToRead
 931
 932     return STATUS_SUCCESS;
 933 }
 934
 935 NTSTATUS NTAPI
 936 ConDrvWriteConsoleOutputString(IN PCONSOLE Console,
 937                                IN PTEXTMODE_SCREEN_BUFFER Buffer,
 938                                IN CODE_TYPE CodeType,
 939                                IN PVOID StringBuffer,
 940                                IN ULONG NumCodesToWrite,
 941                                IN PCOORD WriteCoord /*,
 942                                OUT PCOORD EndCoord,
 943                                OUT PULONG CodesWritten */)
 944 {
 945     NTSTATUS Status = STATUS_SUCCESS;
 946     PVOID WriteBuffer = NULL;
 947     PWCHAR tmpString = NULL;
 948     DWORD X, Y, Length; // , Written = 0;
 949     ULONG CodeSize;
 950     SMALL_RECT UpdateRect;
 951     PCHAR_INFO Ptr;
 952
 953     if (Console == NULL || Buffer == NULL ||
 954         WriteCoord == NULL /* || EndCoord == NULL || CodesWritten == NULL */)
 955     {
 956         return STATUS_INVALID_PARAMETER;
 957     }
 958
 959     /* Validity checks */
 960     ASSERT(Console == Buffer->Header.Console);
 961     ASSERT( (StringBuffer != NULL && NumCodesToWrite >= 0) ||
 962             (StringBuffer == NULL && NumCodesToWrite == 0) );
 963
 964     switch (CodeType)
 965     {
 966         case CODE_ASCII:
 967             CodeSize = sizeof(CHAR);
 968             break;
 969
 970         case CODE_UNICODE:
 971             CodeSize = sizeof(WCHAR);
 972             break;
 973
 974         case CODE_ATTRIBUTE:
 975             CodeSize = sizeof(WORD);
 976             break;
 977
 978         default:
 979             return STATUS_INVALID_PARAMETER;
 980     }
 981
 982     if (CodeType == CODE_ASCII)
 983     {
 984         /* Convert the ASCII string into Unicode before writing it to the console */
 985         Length = MultiByteToWideChar(Console->OutputCodePage, 0,
 986                                      (PCHAR)StringBuffer,
 987                                      NumCodesToWrite,
 988                                      NULL, 0);
 989         tmpString = WriteBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length * sizeof(WCHAR));
 990         if (WriteBuffer)
 991         {
 992             MultiByteToWideChar(Console->OutputCodePage, 0,
 993                                 (PCHAR)StringBuffer,
 994                                 NumCodesToWrite,
 995                                 (PWCHAR)WriteBuffer, Length);
 996         }
 997         else
 998         {
 999             Status = STATUS_NO_MEMORY;
1000         }
1001     }
1002     else
1003     {
1004         /* For CODE_UNICODE or CODE_ATTRIBUTE, we are already OK */
1005         WriteBuffer = StringBuffer;
1006     }
1007
1008     if (WriteBuffer == NULL || !NT_SUCCESS(Status)) goto Cleanup;
1009
1010     X = WriteCoord->X;
1011     Y = (WriteCoord->Y + Buffer->VirtualY) % Buffer->ScreenBufferSize.Y;
1012     Length = NumCodesToWrite;
1013     // Ptr = ConioCoordToPointer(Buffer, X, Y); // Doesn't work
1014     // Ptr = &Buffer->Buffer[X + Y * Buffer->ScreenBufferSize.X]; // May work
1015
1016     while (Length--)
1017     {
1018         // Ptr = ConioCoordToPointer(Buffer, X, Y); // Doesn't work either
1019         Ptr = &Buffer->Buffer[X + Y * Buffer->ScreenBufferSize.X];
1020
1021         switch (CodeType)
1022         {
1023             case CODE_ASCII:
1024             case CODE_UNICODE:
1025                 Ptr->Char.UnicodeChar = *(PWCHAR)WriteBuffer;
1026                 break;
1027
1028             case CODE_ATTRIBUTE:
1029                 Ptr->Attributes = *(PWORD)WriteBuffer;
1030                 break;
1031         }
1032         WriteBuffer = (PVOID)((ULONG_PTR)WriteBuffer + CodeSize);
1033         // ++Ptr;
1034
1035         // Written++;
1036         if (++X == Buffer->ScreenBufferSize.X)
1037         {
1038             X = 0;
1039
1040             if (++Y == Buffer->ScreenBufferSize.Y)
1041             {
1042                 Y = 0;
1043             }
1044         }
1045     }
1046
1047     if ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer)
1048     {
1049         ConioComputeUpdateRect(Buffer, &UpdateRect, WriteCoord, NumCodesToWrite);
1050         TermDrawRegion(Console, &UpdateRect);
1051     }
1052
1053     // EndCoord->X = X;
1054     // EndCoord->Y = (Y + Buffer->ScreenBufferSize.Y - Buffer->VirtualY) % Buffer->ScreenBufferSize.Y;
1055
1056 Cleanup:
1057     if (tmpString) RtlFreeHeap(RtlGetProcessHeap(), 0, tmpString);
1058
1059     // CodesWritten = Written;
1060     return Status;
1061 }
1062
1063 NTSTATUS NTAPI
1064 ConDrvFillConsoleOutput(IN PCONSOLE Console,
1065                         IN PTEXTMODE_SCREEN_BUFFER Buffer,
1066                         IN CODE_TYPE CodeType,
1067                         IN PVOID Code,
1068                         IN ULONG NumCodesToWrite,
1069                         IN PCOORD WriteCoord /*,
1070                         OUT PULONG CodesWritten */)
1071 {
1072     DWORD X, Y, Length; // , Written = 0;
1073     PCHAR_INFO Ptr;
1074     SMALL_RECT UpdateRect;
1075
1076     if (Console == NULL || Buffer == NULL || Code == NULL ||
1077         WriteCoord == NULL /* || CodesWritten == NULL */)
1078     {
1079         return STATUS_INVALID_PARAMETER;
1080     }
1081
1082     /* Validity check */
1083     ASSERT(Console == Buffer->Header.Console);
1084
1085 #if 0
1086     switch (CodeType)
1087     {
1088         case CODE_ASCII:
1089             /* On-place conversion from the ASCII char to the UNICODE char */
1090             ConsoleAnsiCharToUnicodeChar(Console, &Code->UnicodeChar, &Code->AsciiChar);
1091         /* Fall through */
1092         case CODE_UNICODE:
1093             Code = &Code->UnicodeChar;
1094             break;
1095
1096         case CODE_ATTRIBUTE:
1097             Code = &Code->Attribute;
1098             break;
1099     }
1100 #else
1101     if (CodeType == CODE_ASCII)
1102     {
1103         /* On-place conversion from the ASCII char to the UNICODE char */
1104         // FIXME: What if Code points to an invalid memory zone ??
1105         ConsoleAnsiCharToUnicodeChar(Console, (PWCHAR)Code, (PCHAR)Code);
1106     }
1107 #endif
1108
1109     X = WriteCoord->X;
1110     Y = (WriteCoord->Y + Buffer->VirtualY) % Buffer->ScreenBufferSize.Y;
1111     Length = NumCodesToWrite;
1112     // Ptr = ConioCoordToPointer(Buffer, X, Y); // Doesn't work
1113     // Ptr = &Buffer->Buffer[X + Y * Buffer->ScreenBufferSize.X]; // May work
1114
1115     while (Length--)
1116     {
1117         // Ptr = ConioCoordToPointer(Buffer, X, Y); // Doesn't work either
1118         Ptr = &Buffer->Buffer[X + Y * Buffer->ScreenBufferSize.X];
1119
1120         switch (CodeType)
1121         {
1122             case CODE_ASCII:
1123             case CODE_UNICODE:
1124                 Ptr->Char.UnicodeChar = *(PWCHAR)Code;
1125                 break;
1126
1127             case CODE_ATTRIBUTE:
1128                 Ptr->Attributes = *(PWORD)Code;
1129                 break;
1130         }
1131         // ++Ptr;
1132
1133         // Written++;
1134         if (++X == Buffer->ScreenBufferSize.X)
1135         {
1136             X = 0;
1137
1138             if (++Y == Buffer->ScreenBufferSize.Y)
1139             {
1140                 Y = 0;
1141             }
1142         }
1143     }
1144
1145     if ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer)
1146     {
1147         ConioComputeUpdateRect(Buffer, &UpdateRect, WriteCoord, NumCodesToWrite);
1148         TermDrawRegion(Console, &UpdateRect);
1149     }
1150
1151     // CodesWritten = Written; // NumCodesToWrite;
1152     return STATUS_SUCCESS;
1153 }
1154
1155 NTSTATUS NTAPI
1156 ConDrvGetConsoleScreenBufferInfo(IN PCONSOLE Console,
1157                                  IN PTEXTMODE_SCREEN_BUFFER Buffer,
1158                                  OUT PCONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo)
1159 {
1160     if (Console == NULL || Buffer == NULL || ScreenBufferInfo == NULL)
1161         return STATUS_INVALID_PARAMETER;
1162
1163     /* Validity check */
1164     ASSERT(Console == Buffer->Header.Console);
1165
1166     ScreenBufferInfo->dwSize              = Buffer->ScreenBufferSize;
1167     ScreenBufferInfo->dwCursorPosition    = Buffer->CursorPosition;
1168     ScreenBufferInfo->wAttributes         = Buffer->ScreenDefaultAttrib;
1169     ScreenBufferInfo->srWindow.Left       = Buffer->ViewOrigin.X;
1170     ScreenBufferInfo->srWindow.Top        = Buffer->ViewOrigin.Y;
1171     ScreenBufferInfo->srWindow.Right      = Buffer->ViewOrigin.X + Buffer->ViewSize.X - 1;
1172     ScreenBufferInfo->srWindow.Bottom     = Buffer->ViewOrigin.Y + Buffer->ViewSize.Y - 1;
1173
1174     // FIXME: Refine the computation
1175     ScreenBufferInfo->dwMaximumWindowSize = Buffer->ScreenBufferSize;
1176
1177     return STATUS_SUCCESS;
1178 }
1179
1180 NTSTATUS NTAPI
1181 ConDrvSetConsoleTextAttribute(IN PCONSOLE Console,
1182                               IN PTEXTMODE_SCREEN_BUFFER Buffer,
1183                               IN WORD Attribute)
1184 {
1185     if (Console == NULL || Buffer == NULL)
1186         return STATUS_INVALID_PARAMETER;
1187
1188     /* Validity check */
1189     ASSERT(Console == Buffer->Header.Console);
1190
1191     Buffer->ScreenDefaultAttrib = Attribute;
1192     return STATUS_SUCCESS;
1193 }
1194
1195 NTSTATUS NTAPI
1196 ConDrvSetConsoleScreenBufferSize(IN PCONSOLE Console,
1197                                  IN PTEXTMODE_SCREEN_BUFFER Buffer,
1198                                  IN PCOORD Size)
1199 {
1200     NTSTATUS Status;
1201
1202     if (Console == NULL || Buffer == NULL || Size == NULL)
1203         return STATUS_INVALID_PARAMETER;
1204
1205     /* Validity check */
1206     ASSERT(Console == Buffer->Header.Console);
1207
1208     Status = ConioResizeBuffer(Console, Buffer, *Size);
1209     if (NT_SUCCESS(Status)) TermResizeTerminal(Console);
1210
1211     return Status;
1212 }
1213
1214 NTSTATUS NTAPI
1215 ConDrvScrollConsoleScreenBuffer(IN PCONSOLE Console,
1216                                 IN PTEXTMODE_SCREEN_BUFFER Buffer,
1217                                 IN BOOLEAN Unicode,
1218                                 IN PSMALL_RECT ScrollRectangle,
1219                                 IN BOOLEAN UseClipRectangle,
1220                                 IN PSMALL_RECT ClipRectangle OPTIONAL,
1221                                 IN PCOORD DestinationOrigin,
1222                                 IN CHAR_INFO FillChar)
1223 {
1224     COORD CapturedDestinationOrigin;
1225     SMALL_RECT ScreenBuffer;
1226     SMALL_RECT SrcRegion;
1227     SMALL_RECT DstRegion;
1228     SMALL_RECT UpdateRegion;
1229     SMALL_RECT CapturedClipRectangle;
1230
1231     if (Console == NULL || Buffer == NULL || ScrollRectangle == NULL ||
1232         (UseClipRectangle ? ClipRectangle == NULL : FALSE) || DestinationOrigin == NULL)
1233     {
1234         return STATUS_INVALID_PARAMETER;
1235     }
1236
1237     /* Validity check */
1238     ASSERT(Console == Buffer->Header.Console);
1239
1240     CapturedDestinationOrigin = *DestinationOrigin;
1241
1242     /* Make sure the source rectangle is inside the screen buffer */
1243     ConioInitRect(&ScreenBuffer, 0, 0, Buffer->ScreenBufferSize.Y - 1, Buffer->ScreenBufferSize.X - 1);
1244     if (!ConioGetIntersection(&SrcRegion, &ScreenBuffer, ScrollRectangle))
1245     {
1246         return STATUS_SUCCESS;
1247     }
1248
1249     /* If the source was clipped on the left or top, adjust the destination accordingly */
1250     if (ScrollRectangle->Left < 0)
1251     {
1252         CapturedDestinationOrigin.X -= ScrollRectangle->Left;
1253     }
1254     if (ScrollRectangle->Top < 0)
1255     {
1256         CapturedDestinationOrigin.Y -= ScrollRectangle->Top;
1257     }
1258
1259     if (UseClipRectangle)
1260     {
1261         CapturedClipRectangle = *ClipRectangle;
1262         if (!ConioGetIntersection(&CapturedClipRectangle, &CapturedClipRectangle, &ScreenBuffer))
1263         {
1264             return STATUS_SUCCESS;
1265         }
1266     }
1267     else
1268     {
1269         CapturedClipRectangle = ScreenBuffer;
1270     }
1271
1272     ConioInitRect(&DstRegion,
1273                   CapturedDestinationOrigin.Y,
1274                   CapturedDestinationOrigin.X,
1275                   CapturedDestinationOrigin.Y + ConioRectHeight(&SrcRegion) - 1,
1276                   CapturedDestinationOrigin.X + ConioRectWidth(&SrcRegion ) - 1);
1277
1278     if (!Unicode)
1279         ConsoleAnsiCharToUnicodeChar(Console, &FillChar.Char.UnicodeChar, &FillChar.Char.AsciiChar);
1280
1281     ConioMoveRegion(Buffer, &SrcRegion, &DstRegion, &CapturedClipRectangle, FillChar);
1282
1283     if ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer)
1284     {
1285         ConioGetUnion(&UpdateRegion, &SrcRegion, &DstRegion);
1286         if (ConioGetIntersection(&UpdateRegion, &UpdateRegion, &CapturedClipRectangle))
1287         {
1288             /* Draw update region */
1289             TermDrawRegion(Console, &UpdateRegion);
1290         }
1291     }
1292
1293     return STATUS_SUCCESS;
1294 }
1295
1296 NTSTATUS NTAPI
1297 ConDrvSetConsoleWindowInfo(IN PCONSOLE Console,
1298                            IN PTEXTMODE_SCREEN_BUFFER Buffer,
1299                            IN BOOLEAN Absolute,
1300                            IN PSMALL_RECT WindowRect)
1301 {
1302     SMALL_RECT CapturedWindowRect;
1303
1304     if (Console == NULL || Buffer == NULL || WindowRect == NULL)
1305         return STATUS_INVALID_PARAMETER;
1306
1307     /* Validity check */
1308     ASSERT(Console == Buffer->Header.Console);
1309
1310     CapturedWindowRect = *WindowRect;
1311
1312     if (Absolute == FALSE)
1313     {
1314         /* Relative positions given. Transform them to absolute ones */
1315         CapturedWindowRect.Left   += Buffer->ViewOrigin.X;
1316         CapturedWindowRect.Top    += Buffer->ViewOrigin.Y;
1317         CapturedWindowRect.Right  += Buffer->ViewOrigin.X + Buffer->ViewSize.X - 1;
1318         CapturedWindowRect.Bottom += Buffer->ViewOrigin.Y + Buffer->ViewSize.Y - 1;
1319     }
1320
1321     /* See MSDN documentation on SetConsoleWindowInfo about the performed checks */
1322     if ( (CapturedWindowRect.Left < 0) || (CapturedWindowRect.Top < 0)  ||
1323          (CapturedWindowRect.Right  >= Buffer->ScreenBufferSize.X)      ||
1324          (CapturedWindowRect.Bottom >= Buffer->ScreenBufferSize.Y)      ||
1325          (CapturedWindowRect.Right  <= CapturedWindowRect.Left)         ||
1326          (CapturedWindowRect.Bottom <= CapturedWindowRect.Top) )
1327     {
1328         return STATUS_INVALID_PARAMETER;
1329     }
1330
1331     Buffer->ViewOrigin.X = CapturedWindowRect.Left;
1332     Buffer->ViewOrigin.Y = CapturedWindowRect.Top;
1333
1334     Buffer->ViewSize.X = CapturedWindowRect.Right - CapturedWindowRect.Left + 1;
1335     Buffer->ViewSize.Y = CapturedWindowRect.Bottom - CapturedWindowRect.Top + 1;
1336
1337     // TermResizeTerminal(Console);
1338
1339     return STATUS_SUCCESS;
1340 }
1341
1342 /* EOF */