win32ss/user/winsrv/consrv/condrv/conoutput.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Driver DLL
   4  * FILE:            win32ss/user/winsrv/consrv/condrv/conoutput.c
   5  * PURPOSE:         General Console Output Functions
   6  * PROGRAMMERS:     Jeffrey Morlan
   7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #include "consrv.h"
  13 #include "console.h"
  14 #include "include/conio.h"
  15 #include "include/term.h"
  16 #include "conoutput.h"
  17 #include "handle.h"
  18
  19 #define NDEBUG
  20 #include <debug.h>
  21
  22
  23 /* PRIVATE FUNCTIONS **********************************************************/
  24
  25 NTSTATUS
  26 TEXTMODE_BUFFER_Initialize(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
  27                            IN OUT PCONSOLE Console,
  28                            IN PTEXTMODE_BUFFER_INFO TextModeInfo);
  29 NTSTATUS
  30 GRAPHICS_BUFFER_Initialize(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
  31                            IN OUT PCONSOLE Console,
  32                            IN PGRAPHICS_BUFFER_INFO GraphicsInfo);
  33
  34 VOID
  35 TEXTMODE_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer);
  36 VOID
  37 GRAPHICS_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer);
  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 {
  45     if (Buffer == NULL || Console == NULL)
  46         return STATUS_INVALID_PARAMETER;
  47
  48     *Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, max(sizeof(CONSOLE_SCREEN_BUFFER), Size));
  49     if (*Buffer == NULL) return STATUS_INSUFFICIENT_RESOURCES;
  50
  51     /* Initialize the header with the default type */
  52     ConSrvInitObject(&(*Buffer)->Header, SCREEN_BUFFER, Console);
  53     (*Buffer)->Vtbl = NULL;
  54     return STATUS_SUCCESS;
  55 }
  56
  57 VOID
  58 CONSOLE_SCREEN_BUFFER_Destroy(IN OUT PCONSOLE_SCREEN_BUFFER Buffer)
  59 {
  60     if (Buffer->Header.Type == TEXTMODE_BUFFER)
  61     {
  62         TEXTMODE_BUFFER_Destroy(Buffer);
  63     }
  64     else if (Buffer->Header.Type == GRAPHICS_BUFFER)
  65     {
  66         GRAPHICS_BUFFER_Destroy(Buffer);
  67     }
  68     else if (Buffer->Header.Type == SCREEN_BUFFER)
  69     {
  70         // TODO: Free Buffer->Data
  71
  72         /* Free the palette handle */
  73         if (Buffer->PaletteHandle != NULL) DeleteObject(Buffer->PaletteHandle);
  74
  75         /* Free the screen buffer memory */
  76         ConsoleFreeHeap(Buffer);
  77     }
  78     // else
  79     //     do_nothing;
  80 }
  81
  82 // ConDrvCreateConsoleScreenBuffer
  83 NTSTATUS FASTCALL
  84 ConDrvCreateScreenBuffer(OUT PCONSOLE_SCREEN_BUFFER* Buffer,
  85                          IN OUT PCONSOLE Console,
  86                          IN ULONG BufferType,
  87                          IN PVOID ScreenBufferInfo)
  88 {
  89     NTSTATUS Status = STATUS_SUCCESS;
  90
  91     if ( Console == NULL || Buffer == NULL ||
  92         (BufferType != CONSOLE_TEXTMODE_BUFFER && BufferType != CONSOLE_GRAPHICS_BUFFER) )
  93     {
  94         return STATUS_INVALID_PARAMETER;
  95     }
  96
  97     if (BufferType == CONSOLE_TEXTMODE_BUFFER)
  98     {
  99         Status = TEXTMODE_BUFFER_Initialize(Buffer, Console,
 100                                             (PTEXTMODE_BUFFER_INFO)ScreenBufferInfo);
 101     }
 102     else if (BufferType == CONSOLE_GRAPHICS_BUFFER)
 103     {
 104         Status = GRAPHICS_BUFFER_Initialize(Buffer, Console,
 105                                             (PGRAPHICS_BUFFER_INFO)ScreenBufferInfo);
 106     }
 107     else
 108     {
 109         /* Never ever go there!! */
 110         ASSERT(FALSE);
 111     }
 112
 113     /* Insert the newly created screen buffer into the list, if succeeded */
 114     if (NT_SUCCESS(Status)) InsertHeadList(&Console->BufferList, &(*Buffer)->ListEntry);
 115
 116     return Status;
 117 }
 118
 119 static VOID
 120 ConioSetActiveScreenBuffer(PCONSOLE_SCREEN_BUFFER Buffer);
 121
 122 VOID NTAPI
 123 ConioDeleteScreenBuffer(PCONSOLE_SCREEN_BUFFER Buffer)
 124 {
 125     PCONSOLE Console = Buffer->Header.Console;
 126     PCONSOLE_SCREEN_BUFFER NewBuffer;
 127
 128     /*
 129      * We should notify temporarily the frontend because we are susceptible
 130      * to delete the screen buffer it is using (which may be different from
 131      * the active screen buffer in some cases), and because, if it actually
 132      * uses the active screen buffer, we are going to nullify its pointer to
 133      * change it.
 134      */
 135     TermReleaseScreenBuffer(Console, Buffer);
 136
 137     RemoveEntryList(&Buffer->ListEntry);
 138     if (Buffer == Console->ActiveBuffer)
 139     {
 140         /* Delete active buffer; switch to most recently created */
 141         if (!IsListEmpty(&Console->BufferList))
 142         {
 143             NewBuffer = CONTAINING_RECORD(Console->BufferList.Flink,
 144                                           CONSOLE_SCREEN_BUFFER,
 145                                           ListEntry);
 146
 147             /* Tie console to new buffer and signal the change to the frontend */
 148             ConioSetActiveScreenBuffer(NewBuffer);
 149         }
 150         else
 151         {
 152             Console->ActiveBuffer = NULL;
 153             // InterlockedExchangePointer(&Console->ActiveBuffer, NULL);
 154         }
 155     }
 156
 157     CONSOLE_SCREEN_BUFFER_Destroy(Buffer);
 158 }
 159
 160 VOID FASTCALL
 161 ConioDrawConsole(PCONSOLE Console)
 162 {
 163     SMALL_RECT Region;
 164     PCONSOLE_SCREEN_BUFFER ActiveBuffer = Console->ActiveBuffer;
 165
 166     if (ActiveBuffer)
 167     {
 168         ConioInitRect(&Region, 0, 0, ActiveBuffer->ViewSize.Y - 1, ActiveBuffer->ViewSize.X - 1);
 169         TermDrawRegion(Console, &Region);
 170     }
 171 }
 172
 173 static VOID
 174 ConioSetActiveScreenBuffer(PCONSOLE_SCREEN_BUFFER Buffer)
 175 {
 176     PCONSOLE Console = Buffer->Header.Console;
 177     Console->ActiveBuffer = Buffer;
 178     // InterlockedExchangePointer(&Console->ActiveBuffer, Buffer);
 179     TermSetActiveScreenBuffer(Console);
 180 }
 181
 182 NTSTATUS NTAPI
 183 ConDrvSetConsoleActiveScreenBuffer(IN PCONSOLE Console,
 184                                    IN PCONSOLE_SCREEN_BUFFER Buffer)
 185 {
 186     if (Console == NULL || Buffer == NULL)
 187         return STATUS_INVALID_PARAMETER;
 188
 189     /* Validity check */
 190     ASSERT(Console == Buffer->Header.Console);
 191
 192     if (Buffer == Console->ActiveBuffer) return STATUS_SUCCESS;
 193
 194     /* If old buffer has no handles, it's now unreferenced */
 195     if (Console->ActiveBuffer->Header.HandleCount == 0)
 196     {
 197         ConioDeleteScreenBuffer(Console->ActiveBuffer);
 198     }
 199
 200     /* Tie console to new buffer and signal the change to the frontend */
 201     ConioSetActiveScreenBuffer(Buffer);
 202
 203     return STATUS_SUCCESS;
 204 }
 205
 206 PCONSOLE_SCREEN_BUFFER
 207 ConDrvGetActiveScreenBuffer(IN PCONSOLE Console)
 208 {
 209     return (Console ? Console->ActiveBuffer : NULL);
 210 }
 211
 212 /* PUBLIC DRIVER APIS *********************************************************/
 213
 214 NTSTATUS NTAPI
 215 ConDrvInvalidateBitMapRect(IN PCONSOLE Console,
 216                            IN PCONSOLE_SCREEN_BUFFER Buffer,
 217                            IN PSMALL_RECT Region)
 218 {
 219     if (Console == NULL || Buffer == NULL || Region == NULL)
 220         return STATUS_INVALID_PARAMETER;
 221
 222     /* Validity check */
 223     ASSERT(Console == Buffer->Header.Console);
 224
 225     /* If the output buffer is the current one, redraw the correct portion of the screen */
 226     if (Buffer == Console->ActiveBuffer) TermDrawRegion(Console, Region);
 227
 228     return STATUS_SUCCESS;
 229 }
 230
 231 NTSTATUS NTAPI
 232 ConDrvSetConsolePalette(IN PCONSOLE Console,
 233                         // IN PGRAPHICS_SCREEN_BUFFER Buffer,
 234                         IN PCONSOLE_SCREEN_BUFFER Buffer,
 235                         IN HPALETTE PaletteHandle,
 236                         IN UINT PaletteUsage)
 237 {
 238     BOOL Success;
 239
 240     /*
 241      * Parameters validation
 242      */
 243     if (Console == NULL || Buffer == NULL)
 244         return STATUS_INVALID_PARAMETER;
 245
 246     if ( PaletteUsage != SYSPAL_STATIC   &&
 247          PaletteUsage != SYSPAL_NOSTATIC &&
 248          PaletteUsage != SYSPAL_NOSTATIC256 )
 249     {
 250         return STATUS_INVALID_PARAMETER;
 251     }
 252
 253     /* Validity check */
 254     ASSERT(Console == Buffer->Header.Console);
 255
 256     /* Change the palette */
 257     Success = TermSetPalette(Console, PaletteHandle, PaletteUsage);
 258     if (Success)
 259     {
 260         /* Free the old palette handle if there was already one set */
 261         if ( Buffer->PaletteHandle != NULL &&
 262              Buffer->PaletteHandle != PaletteHandle )
 263         {
 264             DeleteObject(Buffer->PaletteHandle);
 265         }
 266
 267         /* Save the new palette in the screen buffer */
 268         Buffer->PaletteHandle = PaletteHandle;
 269         Buffer->PaletteUsage  = PaletteUsage;
 270     }
 271
 272     return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
 273 }
 274
 275 NTSTATUS NTAPI
 276 ConDrvGetConsoleCursorInfo(IN PCONSOLE Console,
 277                            IN PTEXTMODE_SCREEN_BUFFER Buffer,
 278                            OUT PCONSOLE_CURSOR_INFO CursorInfo)
 279 {
 280     if (Console == NULL || Buffer == NULL || CursorInfo == NULL)
 281         return STATUS_INVALID_PARAMETER;
 282
 283     /* Validity check */
 284     ASSERT(Console == Buffer->Header.Console);
 285
 286     *CursorInfo = Buffer->CursorInfo;
 287     // CursorInfo->bVisible = Buffer->CursorInfo.bVisible;
 288     // CursorInfo->dwSize   = Buffer->CursorInfo.dwSize;
 289
 290     return STATUS_SUCCESS;
 291 }
 292
 293 NTSTATUS NTAPI
 294 ConDrvSetConsoleCursorInfo(IN PCONSOLE Console,
 295                            IN PTEXTMODE_SCREEN_BUFFER Buffer,
 296                            IN PCONSOLE_CURSOR_INFO CursorInfo)
 297 {
 298     ULONG Size;
 299     BOOLEAN Visible, Success = TRUE;
 300
 301     if (Console == NULL || Buffer == NULL || CursorInfo == NULL)
 302         return STATUS_INVALID_PARAMETER;
 303
 304     /* Validity check */
 305     ASSERT(Console == Buffer->Header.Console);
 306
 307     Size    = min(max(CursorInfo->dwSize, 1), 100);
 308     Visible = CursorInfo->bVisible;
 309
 310     if ( (Size != Buffer->CursorInfo.dwSize)         ||
 311          (Visible && !Buffer->CursorInfo.bVisible)   ||
 312          (!Visible && Buffer->CursorInfo.bVisible) )
 313     {
 314         Buffer->CursorInfo.dwSize   = Size;
 315         Buffer->CursorInfo.bVisible = Visible;
 316
 317         Success = TermSetCursorInfo(Console, (PCONSOLE_SCREEN_BUFFER)Buffer);
 318     }
 319
 320     return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
 321 }
 322
 323 NTSTATUS NTAPI
 324 ConDrvSetConsoleCursorPosition(IN PCONSOLE Console,
 325                                IN PTEXTMODE_SCREEN_BUFFER Buffer,
 326                                IN PCOORD Position)
 327 {
 328     SHORT OldCursorX, OldCursorY;
 329
 330     if (Console == NULL || Buffer == NULL || Position == NULL)
 331         return STATUS_INVALID_PARAMETER;
 332
 333     /* Validity check */
 334     ASSERT(Console == Buffer->Header.Console);
 335
 336     if ( Position->X < 0 || Position->X >= Buffer->ScreenBufferSize.X ||
 337          Position->Y < 0 || Position->Y >= Buffer->ScreenBufferSize.Y )
 338     {
 339         return STATUS_INVALID_PARAMETER;
 340     }
 341
 342     OldCursorX = Buffer->CursorPosition.X;
 343     OldCursorY = Buffer->CursorPosition.Y;
 344     Buffer->CursorPosition = *Position;
 345     // Buffer->CursorPosition.X = Position->X;
 346     // Buffer->CursorPosition.Y = Position->Y;
 347     if ( ((PCONSOLE_SCREEN_BUFFER)Buffer == Console->ActiveBuffer) &&
 348          (!TermSetScreenInfo(Console, (PCONSOLE_SCREEN_BUFFER)Buffer, OldCursorX, OldCursorY)) )
 349     {
 350         return STATUS_UNSUCCESSFUL;
 351     }
 352
 353     return STATUS_SUCCESS;
 354 }
 355
 356 /* EOF */