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