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