reactos/win32ss/user/winsrv/consrv/frontends/gui/guiterm.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Server DLL
   4  * FILE:            consrv/frontends/gui/guiterm.c
   5  * PURPOSE:         GUI Terminal Front-End
   6  * PROGRAMMERS:     Gé van Geldorp
   7  *                  Johannes Anderwald
   8  *                  Jeffrey Morlan
   9  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
  10  */
  11
  12 /* INCLUDES *******************************************************************/
  13
  14 #include <consrv.h>
  15
  16 #define NDEBUG
  17 #include <debug.h>
  18
  19 #include "guiterm.h"
  20 #include "resource.h"
  21
  22 // HACK!! Remove it when the hack in GuiWriteStream is fixed
  23 #define CONGUI_UPDATE_TIME    0
  24 #define CONGUI_UPDATE_TIMER   1
  25
  26 #define PM_CREATE_CONSOLE       (WM_APP + 1)
  27 #define PM_DESTROY_CONSOLE      (WM_APP + 2)
  28
  29
  30 /* GLOBALS ********************************************************************/
  31
  32 typedef struct _GUI_INIT_INFO
  33 {
  34     PCONSOLE_INFO ConsoleInfo;
  35     PCONSOLE_START_INFO ConsoleStartInfo;
  36     ULONG ProcessId;
  37     BOOLEAN IsWindowVisible;
  38 } GUI_INIT_INFO, *PGUI_INIT_INFO;
  39
  40 static BOOL    ConsInitialized = FALSE;
  41 static HANDLE  hInputThread = NULL;
  42 static DWORD   dwInputThreadId = 0;
  43
  44 extern HICON   ghDefaultIcon;
  45 extern HICON   ghDefaultIconSm;
  46 extern HCURSOR ghDefaultCursor;
  47
  48 VOID
  49 SetConWndConsoleLeaderCID(IN PGUI_CONSOLE_DATA GuiData);
  50 BOOLEAN
  51 RegisterConWndClass(IN HINSTANCE hInstance);
  52 BOOLEAN
  53 UnRegisterConWndClass(HINSTANCE hInstance);
  54
  55 /* FUNCTIONS ******************************************************************/
  56
  57 static VOID
  58 GetScreenBufferSizeUnits(IN PCONSOLE_SCREEN_BUFFER Buffer,
  59                          IN PGUI_CONSOLE_DATA GuiData,
  60                          OUT PUINT WidthUnit,
  61                          OUT PUINT HeightUnit)
  62 {
  63     if (Buffer == NULL || GuiData == NULL ||
  64         WidthUnit == NULL || HeightUnit == NULL)
  65     {
  66         return;
  67     }
  68
  69     if (GetType(Buffer) == TEXTMODE_BUFFER)
  70     {
  71         *WidthUnit  = GuiData->CharWidth ;
  72         *HeightUnit = GuiData->CharHeight;
  73     }
  74     else /* if (GetType(Buffer) == GRAPHICS_BUFFER) */
  75     {
  76         *WidthUnit  = 1;
  77         *HeightUnit = 1;
  78     }
  79 }
  80
  81 VOID
  82 GuiConsoleMoveWindow(PGUI_CONSOLE_DATA GuiData)
  83 {
  84     /* Move the window if needed (not positioned by the system) */
  85     if (!GuiData->GuiInfo.AutoPosition)
  86     {
  87         SetWindowPos(GuiData->hWindow,
  88                      NULL,
  89                      GuiData->GuiInfo.WindowOrigin.x,
  90                      GuiData->GuiInfo.WindowOrigin.y,
  91                      0, 0,
  92                      SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
  93     }
  94 }
  95
  96 static VOID
  97 SmallRectToRect(PGUI_CONSOLE_DATA GuiData, PRECT Rect, PSMALL_RECT SmallRect)
  98 {
  99     PCONSOLE_SCREEN_BUFFER Buffer = GuiData->ActiveBuffer;
 100     UINT WidthUnit, HeightUnit;
 101
 102     GetScreenBufferSizeUnits(Buffer, GuiData, &WidthUnit, &HeightUnit);
 103
 104     Rect->left   = (SmallRect->Left       - Buffer->ViewOrigin.X) * WidthUnit ;
 105     Rect->top    = (SmallRect->Top        - Buffer->ViewOrigin.Y) * HeightUnit;
 106     Rect->right  = (SmallRect->Right  + 1 - Buffer->ViewOrigin.X) * WidthUnit ;
 107     Rect->bottom = (SmallRect->Bottom + 1 - Buffer->ViewOrigin.Y) * HeightUnit;
 108 }
 109
 110 static VOID
 111 DrawRegion(PGUI_CONSOLE_DATA GuiData,
 112            SMALL_RECT* Region)
 113 {
 114     RECT RegionRect;
 115
 116     SmallRectToRect(GuiData, &RegionRect, Region);
 117     /* Do not erase the background: it speeds up redrawing and reduce flickering */
 118     InvalidateRect(GuiData->hWindow, &RegionRect, FALSE);
 119     /**UpdateWindow(GuiData->hWindow);**/
 120 }
 121
 122 VOID
 123 InvalidateCell(PGUI_CONSOLE_DATA GuiData,
 124                SHORT x, SHORT y)
 125 {
 126     SMALL_RECT CellRect = { x, y, x, y };
 127     DrawRegion(GuiData, &CellRect);
 128 }
 129
 130
 131 /******************************************************************************
 132  *                        GUI Terminal Initialization                         *
 133  ******************************************************************************/
 134
 135 VOID
 136 SwitchFullScreen(PGUI_CONSOLE_DATA GuiData, BOOL FullScreen);
 137 VOID
 138 CreateSysMenu(HWND hWnd);
 139
 140 static DWORD NTAPI
 141 GuiConsoleInputThread(PVOID Param)
 142 {
 143     PHANDLE GraphicsStartupEvent = (PHANDLE)Param;
 144     LONG WindowCount = 0;
 145     MSG msg;
 146
 147     /*
 148      * This thread dispatches all the console notifications to the
 149      * notification window. It is common for all the console windows.
 150      */
 151
 152     /* The thread has been initialized, set the event */
 153     NtSetEvent(*GraphicsStartupEvent, NULL);
 154
 155     while (GetMessageW(&msg, NULL, 0, 0))
 156     {
 157         switch (msg.message)
 158         {
 159             case PM_CREATE_CONSOLE:
 160             {
 161                 PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam;
 162                 PCONSRV_CONSOLE Console = GuiData->Console;
 163                 HWND NewWindow;
 164                 RECT rcWnd;
 165
 166                 DPRINT("PM_CREATE_CONSOLE -- creating window\n");
 167
 168                 NewWindow = CreateWindowExW(WS_EX_CLIENTEDGE,
 169                                             GUI_CONWND_CLASS,
 170                                             Console->Title.Buffer,
 171                                             WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
 172                                             CW_USEDEFAULT,
 173                                             CW_USEDEFAULT,
 174                                             CW_USEDEFAULT,
 175                                             CW_USEDEFAULT,
 176                                             GuiData->IsWindowVisible ? HWND_DESKTOP : HWND_MESSAGE,
 177                                             NULL,
 178                                             ConSrvDllInstance,
 179                                             (PVOID)GuiData);
 180                 if (NewWindow == NULL)
 181                 {
 182                     DPRINT1("Failed to create a new console window\n");
 183                     continue;
 184                 }
 185
 186                 ASSERT(NewWindow == GuiData->hWindow);
 187
 188                 InterlockedIncrement(&WindowCount);
 189
 190                 //
 191                 // FIXME: TODO: Move everything there into conwnd.c!OnNcCreate()
 192                 //
 193
 194                 /* Retrieve our real position */
 195                 // See conwnd.c!OnMove()
 196                 GetWindowRect(GuiData->hWindow, &rcWnd);
 197                 GuiData->GuiInfo.WindowOrigin.x = rcWnd.left;
 198                 GuiData->GuiInfo.WindowOrigin.y = rcWnd.top;
 199
 200                 if (GuiData->IsWindowVisible)
 201                 {
 202                     /* Move and resize the window to the user's values */
 203                     /* CAN WE DEADLOCK ?? */
 204                     GuiConsoleMoveWindow(GuiData); // FIXME: This MUST be done via the CreateWindowExW call.
 205                     SendMessageW(GuiData->hWindow, PM_RESIZE_TERMINAL, 0, 0);
 206                 }
 207
 208                 // FIXME: HACK: Potential HACK for CORE-8129; see revision 63595.
 209                 CreateSysMenu(GuiData->hWindow);
 210
 211                 if (GuiData->IsWindowVisible)
 212                 {
 213                     /* Switch to full-screen mode if necessary */
 214                     // FIXME: Move elsewhere, it cause misdrawings of the window.
 215                     if (GuiData->GuiInfo.FullScreen) SwitchFullScreen(GuiData, TRUE);
 216
 217                     DPRINT("PM_CREATE_CONSOLE -- showing window\n");
 218                     // ShowWindow(NewWindow, (int)GuiData->GuiInfo.ShowWindow);
 219                     ShowWindowAsync(NewWindow, (int)GuiData->GuiInfo.ShowWindow);
 220                     DPRINT("Window showed\n");
 221                 }
 222                 else
 223                 {
 224                     DPRINT("PM_CREATE_CONSOLE -- hidden window\n");
 225                     ShowWindowAsync(NewWindow, SW_HIDE);
 226                 }
 227
 228                 continue;
 229             }
 230
 231             case PM_DESTROY_CONSOLE:
 232             {
 233                 PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam;
 234                 MSG TempMsg;
 235
 236                 /* Exit the full screen mode if it was already set */
 237                 // LeaveFullScreen(GuiData);
 238
 239                 /*
 240                  * Window creation is done using a PostMessage(), so it's possible
 241                  * that the window that we want to destroy doesn't exist yet.
 242                  * So first empty the message queue.
 243                  */
 244                 /*
 245                 while (PeekMessageW(&TempMsg, NULL, 0, 0, PM_REMOVE))
 246                 {
 247                     TranslateMessage(&TempMsg);
 248                     DispatchMessageW(&TempMsg);
 249                 }*/
 250                 while (PeekMessageW(&TempMsg, NULL, 0, 0, PM_REMOVE)) ;
 251
 252                 if (GuiData->hWindow == NULL) continue;
 253
 254                 DestroyWindow(GuiData->hWindow);
 255
 256                 NtSetEvent(GuiData->hGuiTermEvent, NULL);
 257
 258                 if (InterlockedDecrement(&WindowCount) == 0)
 259                 {
 260                     DPRINT("CONSRV: Going to quit the Input Thread!!\n");
 261                     goto Quit;
 262                 }
 263
 264                 continue;
 265             }
 266         }
 267
 268         TranslateMessage(&msg);
 269         DispatchMessageW(&msg);
 270     }
 271
 272 Quit:
 273     DPRINT("CONSRV: Quit the Input Thread!!\n");
 274
 275     hInputThread = NULL;
 276     dwInputThreadId = 0;
 277
 278     return 1;
 279 }
 280
 281 static BOOL
 282 GuiInit(VOID)
 283 {
 284     /* Exit if we were already initialized */
 285     // if (ConsInitialized) return TRUE;
 286
 287     /*
 288      * Initialize and register the console window class, if needed.
 289      */
 290     if (!ConsInitialized)
 291     {
 292         if (!RegisterConWndClass(ConSrvDllInstance)) return FALSE;
 293         ConsInitialized = TRUE;
 294     }
 295
 296     /*
 297      * Set-up the console input thread
 298      */
 299     if (hInputThread == NULL)
 300     {
 301         HANDLE GraphicsStartupEvent;
 302         NTSTATUS Status;
 303
 304         Status = NtCreateEvent(&GraphicsStartupEvent, EVENT_ALL_ACCESS,
 305                                NULL, SynchronizationEvent, FALSE);
 306         if (!NT_SUCCESS(Status)) return FALSE;
 307
 308         hInputThread = CreateThread(NULL,
 309                                     0,
 310                                     GuiConsoleInputThread,
 311                                     (PVOID)&GraphicsStartupEvent,
 312                                     0,
 313                                     &dwInputThreadId);
 314         if (hInputThread == NULL)
 315         {
 316             NtClose(GraphicsStartupEvent);
 317             DPRINT1("CONSRV: Failed to create graphics console thread.\n");
 318             return FALSE;
 319         }
 320         SetThreadPriority(hInputThread, THREAD_PRIORITY_HIGHEST);
 321         CloseHandle(hInputThread);
 322
 323         WaitForSingleObject(GraphicsStartupEvent, INFINITE);
 324         NtClose(GraphicsStartupEvent);
 325     }
 326
 327     // ConsInitialized = TRUE;
 328
 329     return TRUE;
 330 }
 331
 332
 333 /******************************************************************************
 334  *                             GUI Console Driver                             *
 335  ******************************************************************************/
 336
 337 static VOID NTAPI
 338 GuiDeinitFrontEnd(IN OUT PFRONTEND This);
 339
 340 static NTSTATUS NTAPI
 341 GuiInitFrontEnd(IN OUT PFRONTEND This,
 342                 IN PCONSRV_CONSOLE Console)
 343 {
 344     PGUI_INIT_INFO GuiInitInfo;
 345     PCONSOLE_INFO  ConsoleInfo;
 346     PCONSOLE_START_INFO ConsoleStartInfo;
 347
 348     PGUI_CONSOLE_DATA GuiData;
 349     GUI_CONSOLE_INFO  TermInfo;
 350
 351     if (This == NULL || Console == NULL || This->Context2 == NULL)
 352         return STATUS_INVALID_PARAMETER;
 353
 354     ASSERT(This->Console == Console);
 355
 356     GuiInitInfo = This->Context2;
 357
 358     if (GuiInitInfo->ConsoleInfo == NULL || GuiInitInfo->ConsoleStartInfo == NULL)
 359         return STATUS_INVALID_PARAMETER;
 360
 361     ConsoleInfo      = GuiInitInfo->ConsoleInfo;
 362     ConsoleStartInfo = GuiInitInfo->ConsoleStartInfo;
 363
 364     /* Terminal data allocation */
 365     GuiData = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(GUI_CONSOLE_DATA));
 366     if (!GuiData)
 367     {
 368         DPRINT1("CONSRV: Failed to create GUI_CONSOLE_DATA\n");
 369         return STATUS_UNSUCCESSFUL;
 370     }
 371     ///// /* HACK */ Console->FrontEndIFace.Context = (PVOID)GuiData; /* HACK */
 372     GuiData->Console      = Console;
 373     GuiData->ActiveBuffer = Console->ActiveBuffer;
 374     GuiData->hWindow = NULL;
 375     GuiData->IsWindowVisible = GuiInitInfo->IsWindowVisible;
 376
 377     /* The console can be resized */
 378     Console->FixedSize = FALSE;
 379
 380     InitializeCriticalSection(&GuiData->Lock);
 381
 382
 383     /*
 384      * Load terminal settings
 385      */
 386
 387     /* 1. Load the default settings */
 388     GuiConsoleGetDefaultSettings(&TermInfo, GuiInitInfo->ProcessId);
 389
 390     if (GuiData->IsWindowVisible)
 391     {
 392         /* 2. Load the remaining console settings via the registry */
 393         if ((ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
 394         {
 395             /* Load the terminal infos from the registry */
 396             GuiConsoleReadUserSettings(&TermInfo,
 397                                        ConsoleInfo->ConsoleTitle,
 398                                        GuiInitInfo->ProcessId);
 399
 400             /*
 401              * Now, update them with the properties the user might gave to us
 402              * via the STARTUPINFO structure before calling CreateProcess
 403              * (and which was transmitted via the ConsoleStartInfo structure).
 404              * We therefore overwrite the values read in the registry.
 405              */
 406             if (ConsoleStartInfo->dwStartupFlags & STARTF_USESHOWWINDOW)
 407             {
 408                 TermInfo.ShowWindow = ConsoleStartInfo->wShowWindow;
 409             }
 410             if (ConsoleStartInfo->dwStartupFlags & STARTF_USEPOSITION)
 411             {
 412                 TermInfo.AutoPosition = FALSE;
 413                 TermInfo.WindowOrigin.x = ConsoleStartInfo->dwWindowOrigin.X;
 414                 TermInfo.WindowOrigin.y = ConsoleStartInfo->dwWindowOrigin.Y;
 415             }
 416             if (ConsoleStartInfo->dwStartupFlags & STARTF_RUNFULLSCREEN)
 417             {
 418                 TermInfo.FullScreen = TRUE;
 419             }
 420         }
 421     }
 422
 423
 424     /*
 425      * Set up GUI data
 426      */
 427
 428     // Font data
 429     wcsncpy(GuiData->GuiInfo.FaceName, TermInfo.FaceName, LF_FACESIZE);
 430     GuiData->GuiInfo.FaceName[LF_FACESIZE - 1] = UNICODE_NULL;
 431     GuiData->GuiInfo.FontFamily     = TermInfo.FontFamily;
 432     GuiData->GuiInfo.FontSize       = TermInfo.FontSize;
 433     GuiData->GuiInfo.FontWeight     = TermInfo.FontWeight;
 434
 435     // Display
 436     GuiData->GuiInfo.FullScreen     = TermInfo.FullScreen;
 437     GuiData->GuiInfo.ShowWindow     = TermInfo.ShowWindow;
 438     GuiData->GuiInfo.AutoPosition   = TermInfo.AutoPosition;
 439     GuiData->GuiInfo.WindowOrigin   = TermInfo.WindowOrigin;
 440
 441     /* Initialize the icon handles */
 442     if (ConsoleStartInfo->hIcon != NULL)
 443         GuiData->hIcon = ConsoleStartInfo->hIcon;
 444     else
 445         GuiData->hIcon = ghDefaultIcon;
 446
 447     if (ConsoleStartInfo->hIconSm != NULL)
 448         GuiData->hIconSm = ConsoleStartInfo->hIconSm;
 449     else
 450         GuiData->hIconSm = ghDefaultIconSm;
 451
 452     ASSERT(GuiData->hIcon && GuiData->hIconSm);
 453
 454     /* Mouse is shown by default with its default cursor shape */
 455     GuiData->hCursor = ghDefaultCursor;
 456     GuiData->MouseCursorRefCount = 0;
 457
 458     /* A priori don't ignore mouse signals */
 459     GuiData->IgnoreNextMouseSignal = FALSE;
 460
 461     /* Close button and the corresponding system menu item are enabled by default */
 462     GuiData->IsCloseButtonEnabled = TRUE;
 463
 464     /* There is no user-reserved menu id range by default */
 465     GuiData->CmdIdLow = GuiData->CmdIdHigh = 0;
 466
 467     /* Initialize the selection */
 468     RtlZeroMemory(&GuiData->Selection, sizeof(GuiData->Selection));
 469     GuiData->Selection.dwFlags = CONSOLE_NO_SELECTION;
 470     RtlZeroMemory(&GuiData->dwSelectionCursor, sizeof(GuiData->dwSelectionCursor));
 471     GuiData->LineSelection = FALSE; // Default to block selection
 472     // TODO: Retrieve the selection mode via the registry.
 473
 474     /* Finally, finish to initialize the frontend structure */
 475     This->Context  = GuiData;
 476     if (This->Context2) ConsoleFreeHeap(This->Context2);
 477     This->Context2 = NULL;
 478
 479     /*
 480      * We need to wait until the GUI has been fully initialized
 481      * to retrieve custom settings i.e. WindowSize etc...
 482      * Ideally we could use SendNotifyMessage for this but its not
 483      * yet implemented.
 484      */
 485     NtCreateEvent(&GuiData->hGuiInitEvent, EVENT_ALL_ACCESS,
 486                   NULL, SynchronizationEvent, FALSE);
 487     NtCreateEvent(&GuiData->hGuiTermEvent, EVENT_ALL_ACCESS,
 488                   NULL, SynchronizationEvent, FALSE);
 489
 490     DPRINT("GUI - Checkpoint\n");
 491
 492     /* Create the terminal window */
 493     PostThreadMessageW(dwInputThreadId, PM_CREATE_CONSOLE, 0, (LPARAM)GuiData);
 494
 495     /* Wait until initialization has finished */
 496     WaitForSingleObject(GuiData->hGuiInitEvent, INFINITE);
 497     DPRINT("OK we created the console window\n");
 498     NtClose(GuiData->hGuiInitEvent);
 499     GuiData->hGuiInitEvent = NULL;
 500
 501     /* Check whether we really succeeded in initializing the terminal window */
 502     if (GuiData->hWindow == NULL)
 503     {
 504         DPRINT("GuiInitConsole - We failed at creating a new terminal window\n");
 505         GuiDeinitFrontEnd(This);
 506         return STATUS_UNSUCCESSFUL;
 507     }
 508
 509     return STATUS_SUCCESS;
 510 }
 511
 512 static VOID NTAPI
 513 GuiDeinitFrontEnd(IN OUT PFRONTEND This)
 514 {
 515     PGUI_CONSOLE_DATA GuiData = This->Context;
 516
 517     DPRINT("Send PM_DESTROY_CONSOLE message and wait on hGuiTermEvent...\n");
 518     PostThreadMessageW(dwInputThreadId, PM_DESTROY_CONSOLE, 0, (LPARAM)GuiData);
 519     WaitForSingleObject(GuiData->hGuiTermEvent, INFINITE);
 520     DPRINT("hGuiTermEvent set\n");
 521     NtClose(GuiData->hGuiTermEvent);
 522     GuiData->hGuiTermEvent = NULL;
 523
 524     DPRINT("Destroying icons !! - GuiData->hIcon = 0x%p ; ghDefaultIcon = 0x%p ; GuiData->hIconSm = 0x%p ; ghDefaultIconSm = 0x%p\n",
 525             GuiData->hIcon, ghDefaultIcon, GuiData->hIconSm, ghDefaultIconSm);
 526     if (GuiData->hIcon != NULL && GuiData->hIcon != ghDefaultIcon)
 527     {
 528         DPRINT("Destroy hIcon\n");
 529         DestroyIcon(GuiData->hIcon);
 530     }
 531     if (GuiData->hIconSm != NULL && GuiData->hIconSm != ghDefaultIconSm)
 532     {
 533         DPRINT("Destroy hIconSm\n");
 534         DestroyIcon(GuiData->hIconSm);
 535     }
 536
 537     This->Context = NULL;
 538     DeleteCriticalSection(&GuiData->Lock);
 539     ConsoleFreeHeap(GuiData);
 540
 541     DPRINT("Quit GuiDeinitFrontEnd\n");
 542 }
 543
 544 static VOID NTAPI
 545 GuiDrawRegion(IN OUT PFRONTEND This,
 546               SMALL_RECT* Region)
 547 {
 548     PGUI_CONSOLE_DATA GuiData = This->Context;
 549
 550     /* Do nothing if the window is hidden */
 551     if (!GuiData->IsWindowVisible) return;
 552
 553     DrawRegion(GuiData, Region);
 554 }
 555
 556 static VOID NTAPI
 557 GuiWriteStream(IN OUT PFRONTEND This,
 558                SMALL_RECT* Region,
 559                SHORT CursorStartX,
 560                SHORT CursorStartY,
 561                UINT ScrolledLines,
 562                PWCHAR Buffer,
 563                UINT Length)
 564 {
 565     PGUI_CONSOLE_DATA GuiData = This->Context;
 566     PCONSOLE_SCREEN_BUFFER Buff;
 567     SHORT CursorEndX, CursorEndY;
 568     RECT ScrollRect;
 569
 570     if (NULL == GuiData || NULL == GuiData->hWindow) return;
 571
 572     /* Do nothing if the window is hidden */
 573     if (!GuiData->IsWindowVisible) return;
 574
 575     Buff = GuiData->ActiveBuffer;
 576     if (GetType(Buff) != TEXTMODE_BUFFER) return;
 577
 578     if (0 != ScrolledLines)
 579     {
 580         ScrollRect.left = 0;
 581         ScrollRect.top = 0;
 582         ScrollRect.right = Buff->ViewSize.X * GuiData->CharWidth;
 583         ScrollRect.bottom = Region->Top * GuiData->CharHeight;
 584
 585         ScrollWindowEx(GuiData->hWindow,
 586                        0,
 587                        -(int)(ScrolledLines * GuiData->CharHeight),
 588                        &ScrollRect,
 589                        NULL,
 590                        NULL,
 591                        NULL,
 592                        SW_INVALIDATE);
 593     }
 594
 595     DrawRegion(GuiData, Region);
 596
 597     if (CursorStartX < Region->Left || Region->Right < CursorStartX
 598             || CursorStartY < Region->Top || Region->Bottom < CursorStartY)
 599     {
 600         InvalidateCell(GuiData, CursorStartX, CursorStartY);
 601     }
 602
 603     CursorEndX = Buff->CursorPosition.X;
 604     CursorEndY = Buff->CursorPosition.Y;
 605     if ((CursorEndX < Region->Left || Region->Right < CursorEndX
 606             || CursorEndY < Region->Top || Region->Bottom < CursorEndY)
 607             && (CursorEndX != CursorStartX || CursorEndY != CursorStartY))
 608     {
 609         InvalidateCell(GuiData, CursorEndX, CursorEndY);
 610     }
 611
 612     // HACK!!
 613     // Set up the update timer (very short interval) - this is a "hack" for getting the OS to
 614     // repaint the window without having it just freeze up and stay on the screen permanently.
 615     Buff->CursorBlinkOn = TRUE;
 616     SetTimer(GuiData->hWindow, CONGUI_UPDATE_TIMER, CONGUI_UPDATE_TIME, NULL);
 617 }
 618
 619 /* static */ VOID NTAPI
 620 GuiRingBell(IN OUT PFRONTEND This)
 621 {
 622     PGUI_CONSOLE_DATA GuiData = This->Context;
 623
 624     /* Emit an error beep sound */
 625     SendNotifyMessage(GuiData->hWindow, PM_CONSOLE_BEEP, 0, 0);
 626 }
 627
 628 static BOOL NTAPI
 629 GuiSetCursorInfo(IN OUT PFRONTEND This,
 630                  PCONSOLE_SCREEN_BUFFER Buff)
 631 {
 632     PGUI_CONSOLE_DATA GuiData = This->Context;
 633
 634     /* Do nothing if the window is hidden */
 635     if (!GuiData->IsWindowVisible) return TRUE;
 636
 637     if (GuiData->ActiveBuffer == Buff)
 638     {
 639         InvalidateCell(GuiData, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 640     }
 641
 642     return TRUE;
 643 }
 644
 645 static BOOL NTAPI
 646 GuiSetScreenInfo(IN OUT PFRONTEND This,
 647                  PCONSOLE_SCREEN_BUFFER Buff,
 648                  SHORT OldCursorX,
 649                  SHORT OldCursorY)
 650 {
 651     PGUI_CONSOLE_DATA GuiData = This->Context;
 652
 653     /* Do nothing if the window is hidden */
 654     if (!GuiData->IsWindowVisible) return TRUE;
 655
 656     if (GuiData->ActiveBuffer == Buff)
 657     {
 658         /* Redraw char at old position (remove cursor) */
 659         InvalidateCell(GuiData, OldCursorX, OldCursorY);
 660         /* Redraw char at new position (show cursor) */
 661         InvalidateCell(GuiData, Buff->CursorPosition.X, Buff->CursorPosition.Y);
 662     }
 663
 664     return TRUE;
 665 }
 666
 667 static VOID NTAPI
 668 GuiResizeTerminal(IN OUT PFRONTEND This)
 669 {
 670     PGUI_CONSOLE_DATA GuiData = This->Context;
 671
 672     /* Resize the window to the user's values */
 673     PostMessageW(GuiData->hWindow, PM_RESIZE_TERMINAL, 0, 0);
 674 }
 675
 676 static VOID NTAPI
 677 GuiSetActiveScreenBuffer(IN OUT PFRONTEND This)
 678 {
 679     PGUI_CONSOLE_DATA GuiData = This->Context;
 680     PCONSOLE_SCREEN_BUFFER ActiveBuffer;
 681     HPALETTE hPalette;
 682
 683     EnterCriticalSection(&GuiData->Lock);
 684     GuiData->WindowSizeLock = TRUE;
 685
 686     InterlockedExchangePointer(&GuiData->ActiveBuffer,
 687                                ConDrvGetActiveScreenBuffer(GuiData->Console));
 688
 689     GuiData->WindowSizeLock = FALSE;
 690     LeaveCriticalSection(&GuiData->Lock);
 691
 692     ActiveBuffer = GuiData->ActiveBuffer;
 693
 694     /* Change the current palette */
 695     if (ActiveBuffer->PaletteHandle == NULL)
 696     {
 697         hPalette = GuiData->hSysPalette;
 698     }
 699     else
 700     {
 701         hPalette = ActiveBuffer->PaletteHandle;
 702     }
 703
 704     DPRINT("GuiSetActiveScreenBuffer using palette 0x%p\n", hPalette);
 705
 706     /* Set the new palette for the framebuffer */
 707     SelectPalette(GuiData->hMemDC, hPalette, FALSE);
 708
 709     /* Specify the use of the system palette for the framebuffer */
 710     SetSystemPaletteUse(GuiData->hMemDC, ActiveBuffer->PaletteUsage);
 711
 712     /* Realize the (logical) palette */
 713     RealizePalette(GuiData->hMemDC);
 714
 715     GuiResizeTerminal(This);
 716     // ConioDrawConsole(Console);
 717 }
 718
 719 static VOID NTAPI
 720 GuiReleaseScreenBuffer(IN OUT PFRONTEND This,
 721                        IN PCONSOLE_SCREEN_BUFFER ScreenBuffer)
 722 {
 723     PGUI_CONSOLE_DATA GuiData = This->Context;
 724
 725     /*
 726      * If we were notified to release a screen buffer that is not actually
 727      * ours, then just ignore the notification...
 728      */
 729     if (ScreenBuffer != GuiData->ActiveBuffer) return;
 730
 731     /*
 732      * ... else, we must release our active buffer. Two cases are present:
 733      * - If ScreenBuffer (== GuiData->ActiveBuffer) IS NOT the console
 734      *   active screen buffer, then we can safely switch to it.
 735      * - If ScreenBuffer IS the console active screen buffer, we must release
 736      *   it ONLY.
 737      */
 738
 739     /* Release the old active palette and set the default one */
 740     if (GetCurrentObject(GuiData->hMemDC, OBJ_PAL) == ScreenBuffer->PaletteHandle)
 741     {
 742         /* Set the new palette */
 743         SelectPalette(GuiData->hMemDC, GuiData->hSysPalette, FALSE);
 744     }
 745
 746     /* Set the adequate active screen buffer */
 747     if (ScreenBuffer != GuiData->Console->ActiveBuffer)
 748     {
 749         GuiSetActiveScreenBuffer(This);
 750     }
 751     else
 752     {
 753         EnterCriticalSection(&GuiData->Lock);
 754         GuiData->WindowSizeLock = TRUE;
 755
 756         InterlockedExchangePointer(&GuiData->ActiveBuffer, NULL);
 757
 758         GuiData->WindowSizeLock = FALSE;
 759         LeaveCriticalSection(&GuiData->Lock);
 760     }
 761 }
 762
 763 static BOOL NTAPI
 764 GuiSetMouseCursor(IN OUT PFRONTEND This,
 765                   HCURSOR CursorHandle);
 766
 767 static VOID NTAPI
 768 GuiRefreshInternalInfo(IN OUT PFRONTEND This)
 769 {
 770     PGUI_CONSOLE_DATA GuiData = This->Context;
 771
 772     /* Update the console leader information held by the window */
 773     SetConWndConsoleLeaderCID(GuiData);
 774
 775     /*
 776      * HACK:
 777      * We reset the cursor here so that, when a console app quits, we reset
 778      * the cursor to the default one. It's quite a hack since it doesn't proceed
 779      * per - console process... This must be fixed.
 780      *
 781      * See GuiInitConsole(...) for more information.
 782      */
 783
 784     /* Mouse is shown by default with its default cursor shape */
 785     GuiData->MouseCursorRefCount = 0; // Reinitialize the reference counter
 786     GuiSetMouseCursor(This, NULL);
 787 }
 788
 789 static VOID NTAPI
 790 GuiChangeTitle(IN OUT PFRONTEND This)
 791 {
 792     PGUI_CONSOLE_DATA GuiData = This->Context;
 793     // PostMessageW(GuiData->hWindow, PM_CONSOLE_SET_TITLE, 0, 0);
 794     SetWindowText(GuiData->hWindow, GuiData->Console->Title.Buffer);
 795 }
 796
 797 static BOOL NTAPI
 798 GuiChangeIcon(IN OUT PFRONTEND This,
 799               HICON IconHandle)
 800 {
 801     PGUI_CONSOLE_DATA GuiData = This->Context;
 802     HICON hIcon, hIconSm;
 803
 804     if (IconHandle == NULL)
 805     {
 806         hIcon   = ghDefaultIcon;
 807         hIconSm = ghDefaultIconSm;
 808     }
 809     else
 810     {
 811         hIcon   = CopyIcon(IconHandle);
 812         hIconSm = CopyIcon(IconHandle);
 813     }
 814
 815     if (hIcon == NULL)
 816     {
 817         return FALSE;
 818     }
 819
 820     if (hIcon != GuiData->hIcon)
 821     {
 822         if (GuiData->hIcon != NULL && GuiData->hIcon != ghDefaultIcon)
 823         {
 824             DestroyIcon(GuiData->hIcon);
 825         }
 826         if (GuiData->hIconSm != NULL && GuiData->hIconSm != ghDefaultIconSm)
 827         {
 828             DestroyIcon(GuiData->hIconSm);
 829         }
 830
 831         GuiData->hIcon   = hIcon;
 832         GuiData->hIconSm = hIconSm;
 833
 834         DPRINT("Set icons in GuiChangeIcon\n");
 835         PostMessageW(GuiData->hWindow, WM_SETICON, ICON_BIG  , (LPARAM)GuiData->hIcon  );
 836         PostMessageW(GuiData->hWindow, WM_SETICON, ICON_SMALL, (LPARAM)GuiData->hIconSm);
 837     }
 838
 839     return TRUE;
 840 }
 841
 842 static HWND NTAPI
 843 GuiGetConsoleWindowHandle(IN OUT PFRONTEND This)
 844 {
 845     PGUI_CONSOLE_DATA GuiData = This->Context;
 846     return GuiData->hWindow;
 847 }
 848
 849 static VOID NTAPI
 850 GuiGetLargestConsoleWindowSize(IN OUT PFRONTEND This,
 851                                PCOORD pSize)
 852 {
 853     PGUI_CONSOLE_DATA GuiData = This->Context;
 854     PCONSOLE_SCREEN_BUFFER ActiveBuffer;
 855     RECT WorkArea;
 856     LONG width, height;
 857     UINT WidthUnit, HeightUnit;
 858
 859     if (!pSize) return;
 860
 861     if (!SystemParametersInfoW(SPI_GETWORKAREA, 0, &WorkArea, 0))
 862     {
 863         DPRINT1("SystemParametersInfoW failed - What to do ??\n");
 864         return;
 865     }
 866
 867     ActiveBuffer = GuiData->ActiveBuffer;
 868     if (ActiveBuffer)
 869     {
 870         GetScreenBufferSizeUnits(ActiveBuffer, GuiData, &WidthUnit, &HeightUnit);
 871     }
 872     else
 873     {
 874         /* Default: text mode */
 875         WidthUnit  = GuiData->CharWidth ;
 876         HeightUnit = GuiData->CharHeight;
 877     }
 878
 879     width  = WorkArea.right;
 880     height = WorkArea.bottom;
 881
 882     width  -= (2 * (GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXEDGE)));
 883     height -= (2 * (GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYEDGE)) + GetSystemMetrics(SM_CYCAPTION));
 884
 885     if (width  < 0) width  = 0;
 886     if (height < 0) height = 0;
 887
 888     pSize->X = (SHORT)(width  / (int)WidthUnit ) /* HACK */ + 2;
 889     pSize->Y = (SHORT)(height / (int)HeightUnit) /* HACK */ + 1;
 890 }
 891
 892 static BOOL NTAPI
 893 GuiGetSelectionInfo(IN OUT PFRONTEND This,
 894                     PCONSOLE_SELECTION_INFO pSelectionInfo)
 895 {
 896     PGUI_CONSOLE_DATA GuiData = This->Context;
 897
 898     if (pSelectionInfo == NULL) return FALSE;
 899
 900     ZeroMemory(pSelectionInfo, sizeof(CONSOLE_SELECTION_INFO));
 901     if (GuiData->Selection.dwFlags != CONSOLE_NO_SELECTION)
 902         RtlCopyMemory(pSelectionInfo, &GuiData->Selection, sizeof(CONSOLE_SELECTION_INFO));
 903
 904     return TRUE;
 905 }
 906
 907 static BOOL NTAPI
 908 GuiSetPalette(IN OUT PFRONTEND This,
 909               HPALETTE PaletteHandle,
 910               UINT PaletteUsage)
 911 {
 912     PGUI_CONSOLE_DATA GuiData = This->Context;
 913     HPALETTE OldPalette;
 914
 915     // if (GetType(GuiData->ActiveBuffer) != GRAPHICS_BUFFER) return FALSE;
 916     if (PaletteHandle == NULL) return FALSE;
 917
 918     /* Set the new palette for the framebuffer */
 919     OldPalette = SelectPalette(GuiData->hMemDC, PaletteHandle, FALSE);
 920     if (OldPalette == NULL) return FALSE;
 921
 922     /* Specify the use of the system palette for the framebuffer */
 923     SetSystemPaletteUse(GuiData->hMemDC, PaletteUsage);
 924
 925     /* Realize the (logical) palette */
 926     RealizePalette(GuiData->hMemDC);
 927
 928     /* Save the original system palette handle */
 929     if (GuiData->hSysPalette == NULL) GuiData->hSysPalette = OldPalette;
 930
 931     return TRUE;
 932 }
 933
 934 static ULONG NTAPI
 935 GuiGetDisplayMode(IN OUT PFRONTEND This)
 936 {
 937     PGUI_CONSOLE_DATA GuiData = This->Context;
 938     ULONG DisplayMode = 0;
 939
 940     if (GuiData->GuiInfo.FullScreen)
 941         DisplayMode |= CONSOLE_FULLSCREEN_HARDWARE; // CONSOLE_FULLSCREEN
 942     else
 943         DisplayMode |= CONSOLE_WINDOWED;
 944
 945     return DisplayMode;
 946 }
 947
 948 static BOOL NTAPI
 949 GuiSetDisplayMode(IN OUT PFRONTEND This,
 950                   ULONG NewMode)
 951 {
 952     PGUI_CONSOLE_DATA GuiData = This->Context;
 953     BOOL FullScreen;
 954
 955     if (NewMode & ~(CONSOLE_FULLSCREEN_MODE | CONSOLE_WINDOWED_MODE))
 956         return FALSE;
 957
 958     /* Do nothing if the window is hidden */
 959     if (!GuiData->IsWindowVisible) return TRUE;
 960
 961     FullScreen = ((NewMode & CONSOLE_FULLSCREEN_MODE) != 0);
 962
 963     if (FullScreen != GuiData->GuiInfo.FullScreen)
 964     {
 965         SwitchFullScreen(GuiData, FullScreen);
 966     }
 967
 968     return TRUE;
 969 }
 970
 971 static INT NTAPI
 972 GuiShowMouseCursor(IN OUT PFRONTEND This,
 973                    BOOL Show)
 974 {
 975     PGUI_CONSOLE_DATA GuiData = This->Context;
 976
 977     if (GuiData->IsWindowVisible)
 978     {
 979         /* Set the reference count */
 980         if (Show) ++GuiData->MouseCursorRefCount;
 981         else      --GuiData->MouseCursorRefCount;
 982
 983         /* Effectively show (or hide) the cursor (use special values for (w|l)Param) */
 984         PostMessageW(GuiData->hWindow, WM_SETCURSOR, -1, -1);
 985     }
 986
 987     return GuiData->MouseCursorRefCount;
 988 }
 989
 990 static BOOL NTAPI
 991 GuiSetMouseCursor(IN OUT PFRONTEND This,
 992                   HCURSOR CursorHandle)
 993 {
 994     PGUI_CONSOLE_DATA GuiData = This->Context;
 995
 996     /* Do nothing if the window is hidden */
 997     if (!GuiData->IsWindowVisible) return TRUE;
 998
 999     /*
1000      * Set the cursor's handle. If the given handle is NULL,
1001      * then restore the default cursor.
1002      */
1003     GuiData->hCursor = (CursorHandle ? CursorHandle : ghDefaultCursor);
1004
1005     /* Effectively modify the shape of the cursor (use special values for (w|l)Param) */
1006     PostMessageW(GuiData->hWindow, WM_SETCURSOR, -1, -1);
1007
1008     return TRUE;
1009 }
1010
1011 static HMENU NTAPI
1012 GuiMenuControl(IN OUT PFRONTEND This,
1013                UINT CmdIdLow,
1014                UINT CmdIdHigh)
1015 {
1016     PGUI_CONSOLE_DATA GuiData = This->Context;
1017
1018     GuiData->CmdIdLow  = CmdIdLow ;
1019     GuiData->CmdIdHigh = CmdIdHigh;
1020
1021     return GetSystemMenu(GuiData->hWindow, FALSE);
1022 }
1023
1024 static BOOL NTAPI
1025 GuiSetMenuClose(IN OUT PFRONTEND This,
1026                 BOOL Enable)
1027 {
1028     /*
1029      * NOTE: See http://www.mail-archive.com/harbour@harbour-project.org/msg27509.html
1030      * or http://harbour-devel.1590103.n2.nabble.com/Question-about-hb-gt-win-CtrlHandler-usage-td4670862i20.html
1031      * for more information.
1032      */
1033
1034     PGUI_CONSOLE_DATA GuiData = This->Context;
1035     HMENU hSysMenu = GetSystemMenu(GuiData->hWindow, FALSE);
1036
1037     if (hSysMenu == NULL) return FALSE;
1038
1039     GuiData->IsCloseButtonEnabled = Enable;
1040     EnableMenuItem(hSysMenu, SC_CLOSE, MF_BYCOMMAND | (Enable ? MF_ENABLED : MF_GRAYED));
1041
1042     return TRUE;
1043 }
1044
1045 static FRONTEND_VTBL GuiVtbl =
1046 {
1047     GuiInitFrontEnd,
1048     GuiDeinitFrontEnd,
1049     GuiDrawRegion,
1050     GuiWriteStream,
1051     GuiRingBell,
1052     GuiSetCursorInfo,
1053     GuiSetScreenInfo,
1054     GuiResizeTerminal,
1055     GuiSetActiveScreenBuffer,
1056     GuiReleaseScreenBuffer,
1057     GuiRefreshInternalInfo,
1058     GuiChangeTitle,
1059     GuiChangeIcon,
1060     GuiGetConsoleWindowHandle,
1061     GuiGetLargestConsoleWindowSize,
1062     GuiGetSelectionInfo,
1063     GuiSetPalette,
1064     GuiGetDisplayMode,
1065     GuiSetDisplayMode,
1066     GuiShowMouseCursor,
1067     GuiSetMouseCursor,
1068     GuiMenuControl,
1069     GuiSetMenuClose,
1070 };
1071
1072
1073 NTSTATUS NTAPI
1074 GuiLoadFrontEnd(IN OUT PFRONTEND FrontEnd,
1075                 IN OUT PCONSOLE_INFO ConsoleInfo,
1076                 IN OUT PVOID ExtraConsoleInfo,
1077                 IN ULONG ProcessId)
1078 {
1079     PCONSOLE_INIT_INFO ConsoleInitInfo = ExtraConsoleInfo;
1080     PGUI_INIT_INFO GuiInitInfo;
1081
1082     if (FrontEnd == NULL || ConsoleInfo == NULL || ConsoleInitInfo == NULL)
1083         return STATUS_INVALID_PARAMETER;
1084
1085     /* Initialize GUI terminal emulator common functionalities */
1086     if (!GuiInit()) return STATUS_UNSUCCESSFUL;
1087
1088     /*
1089      * Initialize a private initialization info structure for later use.
1090      * It must be freed by a call to GuiUnloadFrontEnd or GuiInitFrontEnd.
1091      */
1092     GuiInitInfo = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(GUI_INIT_INFO));
1093     if (GuiInitInfo == NULL) return STATUS_NO_MEMORY;
1094
1095     // HACK: We suppose that the pointers will be valid in GuiInitFrontEnd...
1096     // If not, then copy exactly what we need in GuiInitInfo.
1097     GuiInitInfo->ConsoleInfo      = ConsoleInfo;
1098     GuiInitInfo->ConsoleStartInfo = ConsoleInitInfo->ConsoleStartInfo;
1099     GuiInitInfo->ProcessId        = ProcessId;
1100     GuiInitInfo->IsWindowVisible  = ConsoleInitInfo->IsWindowVisible;
1101
1102     /* Finally, initialize the frontend structure */
1103     FrontEnd->Vtbl     = &GuiVtbl;
1104     FrontEnd->Context  = NULL;
1105     FrontEnd->Context2 = GuiInitInfo;
1106
1107     return STATUS_SUCCESS;
1108 }
1109
1110 NTSTATUS NTAPI
1111 GuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd)
1112 {
1113     if (FrontEnd == NULL) return STATUS_INVALID_PARAMETER;
1114
1115     if (FrontEnd->Context ) GuiDeinitFrontEnd(FrontEnd);
1116     if (FrontEnd->Context2) ConsoleFreeHeap(FrontEnd->Context2);
1117
1118     return STATUS_SUCCESS;
1119 }
1120
1121 /* EOF */