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