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