ReactOS 0.4.15-dev-7704-gc07eb9f
guiterm.c
Go to the documentation of this file.
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 "concfg/font.h"
20#include "guiterm.h"
21#include "resource.h"
22
23// HACK!! Remove it when the hack in GuiWriteStream is fixed
24#define CONGUI_UPDATE_TIME 0
25#define CONGUI_UPDATE_TIMER 1
26
27#define PM_CREATE_CONSOLE (WM_APP + 1)
28#define PM_DESTROY_CONSOLE (WM_APP + 2)
29
30
31/* GLOBALS ********************************************************************/
32
33typedef struct _GUI_INIT_INFO
34{
37 HWINSTA WinSta;
38 HDESK Desktop;
44
46
47extern HICON ghDefaultIcon;
50
51VOID
57
58/* FUNCTIONS ******************************************************************/
59
60VOID
62{
63 /* Move the window if needed (not positioned by the system) */
64 if (!GuiData->GuiInfo.AutoPosition)
65 {
66 SetWindowPos(GuiData->hWindow,
67 NULL,
68 GuiData->GuiInfo.WindowOrigin.x,
69 GuiData->GuiInfo.WindowOrigin.y,
70 0, 0,
72 }
73}
74
75static VOID
78{
79 RECT RegionRect;
80
81 SmallRectToRect(GuiData, &RegionRect, Region);
82 /* Do not erase the background: it speeds up redrawing and reduce flickering */
83 InvalidateRect(GuiData->hWindow, &RegionRect, FALSE);
85}
86
87VOID
89 SHORT x, SHORT y)
90{
91 SMALL_RECT CellRect = { x, y, x, y };
92 DrawRegion(GuiData, &CellRect);
93}
94
95
96/******************************************************************************
97 * GUI Terminal Initialization *
98 ******************************************************************************/
99
100// FIXME: HACK: Potential HACK for CORE-8129; see revision 63595.
101VOID
103
104static ULONG NTAPI
106{
108 PCSR_THREAD pcsrt = NULL;
109 PGUI_INIT_INFO GuiInitInfo = (PGUI_INIT_INFO)Param;
110 DESKTOP_CONSOLE_THREAD DesktopConsoleThreadInfo;
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;
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 */
142
143 while (GetMessageW(&msg, NULL, 0, 0))
144 {
145 switch (msg.message)
146 {
148 {
149 PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam;
151 HWND NewWindow;
152 RECT rcWnd;
153
154 DPRINT("PM_CREATE_CONSOLE -- creating window\n");
155
158 Console->Title.Buffer,
165 NULL,
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
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 ShowWindowAsync(NewWindow, (int)GuiData->GuiInfo.ShowWindow);
207 }
208 else
209 {
210 DPRINT("PM_CREATE_CONSOLE -- hidden window\n");
211 ShowWindowAsync(NewWindow, SW_HIDE);
212 }
213
214 continue;
215 }
216
218 {
219 PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam;
220 MSG TempMsg;
221
222 /* Exit the full screen mode if it was already set */
223 // LeaveFullScreen(GuiData);
224
225 /*
226 * Window creation is done using a PostMessage(), so it's possible
227 * that the window that we want to destroy doesn't exist yet.
228 * So first empty the message queue.
229 */
230 while (PeekMessageW(&TempMsg, NULL, 0, 0, PM_REMOVE))
231 {
232 DispatchMessageW(&TempMsg);
233 }
234
235 if (GuiData->hWindow == NULL) continue;
236
237 DestroyWindow(GuiData->hWindow);
238
239 NtSetEvent(GuiData->hGuiTermEvent, NULL);
240
242 {
243 DPRINT("CONSRV: Going to quit the Input Thread 0x%p\n", InputThreadId);
244 goto Quit;
245 }
246
247 continue;
248 }
249 }
250
253 }
254
255Quit:
256 DPRINT("CONSRV: Quit the Input Thread 0x%p, Status = 0x%08lx\n", InputThreadId, Status);
257
258 /* Remove this console input thread from this desktop */
259 // DesktopConsoleThreadInfo.DesktopHandle;
260 DesktopConsoleThreadInfo.ThreadId = 0;
262 &DesktopConsoleThreadInfo,
263 sizeof(DesktopConsoleThreadInfo));
264
265 /* Close the duplicated desktop handle */
266 CloseDesktop(DesktopConsoleThreadInfo.DesktopHandle); // NtUserCloseDesktop
267
268 /* Cleanup CSR thread */
269 if (pcsrt)
270 {
271 if (hThread != pcsrt->ThreadHandle)
272 DPRINT1("WARNING!! hThread (0x%p) != pcsrt->ThreadHandle (0x%p), you may expect crashes soon!!\n", hThread, pcsrt->ThreadHandle);
273
275 }
276
277 /* Exit the thread */
279 return 0;
280}
281
282// FIXME: Maybe return a NTSTATUS
283static BOOL
285 IN HANDLE ConsoleLeaderProcessHandle,
286 IN OUT PGUI_INIT_INFO GuiInitInfo)
287{
288 BOOL Success = TRUE;
289 UNICODE_STRING DesktopPath;
290 DESKTOP_CONSOLE_THREAD DesktopConsoleThreadInfo;
291 HWINSTA hWinSta;
292 HDESK hDesk;
293
295 HANDLE hInputThread;
297
298 /* Perform one-time initialization */
299 if (!ConsInitialized)
300 {
301 /* Initialize and register the console window class */
303
304 /* Initialize the font support -- additional TrueType font cache */
306
308 }
309
310 /*
311 * Set-up the console input thread. We have
312 * one console input thread per desktop.
313 */
314
316 // return STATUS_BAD_IMPERSONATION_LEVEL;
317 return FALSE;
318
319 if (ConsoleInitInfo->DesktopLength)
320 {
321 DesktopPath.MaximumLength = ConsoleInitInfo->DesktopLength;
322 DesktopPath.Length = DesktopPath.MaximumLength - sizeof(UNICODE_NULL);
323 DesktopPath.Buffer = ConsoleInitInfo->Desktop;
324 }
325 else
326 {
327 RtlInitUnicodeString(&DesktopPath, L"Default");
328 }
329
330 hDesk = NtUserResolveDesktop(ConsoleLeaderProcessHandle,
331 &DesktopPath,
332 FALSE,
333 &hWinSta);
334 DPRINT("NtUserResolveDesktop(DesktopPath = '%wZ') returned hDesk = 0x%p; hWinSta = 0x%p\n",
335 &DesktopPath, hDesk, hWinSta);
336
338
339 if (hDesk == NULL) return FALSE;
340
341 /*
342 * We need to see whether we need to create a
343 * new console input thread for this desktop.
344 */
345 DesktopConsoleThreadInfo.DesktopHandle = hDesk;
346 DesktopConsoleThreadInfo.ThreadId = (ULONG_PTR)INVALID_HANDLE_VALUE; // Special value to say we just want to retrieve the thread ID.
348 &DesktopConsoleThreadInfo,
349 sizeof(DesktopConsoleThreadInfo));
350 DPRINT("NtUserConsoleControl returned ThreadId = 0x%p\n", DesktopConsoleThreadInfo.ThreadId);
351
352 /*
353 * Save the opened window station and desktop handles in the initialization
354 * structure. They will be used later on, and released, by the GUI frontend.
355 */
356 GuiInitInfo->WinSta = hWinSta;
357 GuiInitInfo->Desktop = hDesk;
358
359 /* Here GuiInitInfo contains original handles */
360
361 /* If we already have a console input thread on this desktop... */
362 if (DesktopConsoleThreadInfo.ThreadId != 0)
363 {
364 /* ... just use it... */
365 DPRINT("Using input thread InputThreadId = 0x%p\n", DesktopConsoleThreadInfo.ThreadId);
366 GuiInitInfo->InputThreadId = DesktopConsoleThreadInfo.ThreadId;
367 goto Quit;
368 }
369
370 /* ... otherwise create a new one. */
371
372 /* Initialize a startup event for the thread to signal it */
373 Status = NtCreateEvent(&GuiInitInfo->GuiThreadStartupEvent, EVENT_ALL_ACCESS,
375 if (!NT_SUCCESS(Status))
376 {
377 Success = FALSE;
378 goto Quit;
379 }
380
381 /*
382 * Duplicate the desktop handle for the console input thread internal needs.
383 * If it happens to need also a window station handle in the future, then
384 * it is there that you also need to duplicate the window station handle!
385 *
386 * Note also that we are going to temporarily overwrite the stored handles
387 * in GuiInitInfo because it happens that we use also this structure to give
388 * the duplicated handles to the input thread that is going to initialize.
389 * After the input thread finishes its initialization, we restore the handles
390 * in GuiInitInfo to their old values.
391 */
393 hDesk,
395 (PHANDLE)&GuiInitInfo->Desktop,
397 if (!NT_SUCCESS(Status))
398 {
399 Success = FALSE;
400 goto Quit;
401 }
402
403 /* Here GuiInitInfo contains duplicated handles */
404
406 NULL,
407 TRUE, // Start the thread in suspended state
408 0,
409 0,
410 0,
412 (PVOID)GuiInitInfo,
413 &hInputThread,
414 &ClientId);
415 if (NT_SUCCESS(Status))
416 {
417 /* Add it as a static server thread and resume it */
418 CsrAddStaticServerThread(hInputThread, &ClientId, 0);
419 Status = NtResumeThread(hInputThread, NULL);
420 }
421 DPRINT("Thread creation hInputThread = 0x%p, InputThreadId = 0x%p, Status = 0x%08lx\n",
422 hInputThread, ClientId.UniqueThread, Status);
423
424 if (!NT_SUCCESS(Status) || hInputThread == NULL)
425 {
426 /* Close the thread's handle */
427 if (hInputThread) NtClose(hInputThread);
428
429 /* We need to close here the duplicated desktop handle */
430 CloseDesktop(GuiInitInfo->Desktop); // NtUserCloseDesktop
431
432 /* Close the startup event and bail out */
433 NtClose(GuiInitInfo->GuiThreadStartupEvent);
434
435 DPRINT1("CONSRV: Failed to create graphics console thread.\n");
436 Success = FALSE;
437 goto Quit;
438 }
439
440 /* No need to close hInputThread, this is done by CSR automatically */
441
442 /* Wait for the thread to finish its initialization, and close the startup event */
443 NtWaitForSingleObject(GuiInitInfo->GuiThreadStartupEvent, FALSE, NULL);
444 NtClose(GuiInitInfo->GuiThreadStartupEvent);
445
446 /*
447 * Save the input thread ID for later use, and restore the original handles.
448 * The copies are held by the console input thread.
449 */
450 GuiInitInfo->InputThreadId = (ULONG_PTR)ClientId.UniqueThread;
451 GuiInitInfo->WinSta = hWinSta;
452 GuiInitInfo->Desktop = hDesk;
453
454 /* Here GuiInitInfo contains again original handles */
455
456Quit:
457 if (!Success)
458 {
459 /*
460 * Close the original handles. Do not use the copies in GuiInitInfo
461 * because we may have failed in the middle of the duplicate operation
462 * and the handles stored in GuiInitInfo may have changed.
463 */
464 CloseDesktop(hDesk); // NtUserCloseDesktop
465 CloseWindowStation(hWinSta); // NtUserCloseWindowStation
466 }
467
468 return Success;
469}
470
471
472/******************************************************************************
473 * GUI Console Driver *
474 ******************************************************************************/
475
476static VOID NTAPI
478
479static NTSTATUS NTAPI
482{
483 PGUI_INIT_INFO GuiInitInfo;
484 PGUI_CONSOLE_DATA GuiData;
485
486 if (This == NULL || Console == NULL || This->Context2 == NULL)
488
489 ASSERT(This->Console == Console);
490
491 GuiInitInfo = This->Context2;
492
493 /* Terminal data allocation */
494 GuiData = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*GuiData));
495 if (!GuiData)
496 {
497 DPRINT1("CONSRV: Failed to create GUI_CONSOLE_DATA\n");
498 return STATUS_UNSUCCESSFUL;
499 }
501 GuiData->Console = Console;
502 GuiData->ActiveBuffer = Console->ActiveBuffer;
503 GuiData->hWindow = NULL;
504 GuiData->IsWindowVisible = GuiInitInfo->IsWindowVisible;
505
506 /* The console can be resized */
507 Console->FixedSize = FALSE;
508
510
511 /*
512 * Set up GUI data
513 */
514 RtlCopyMemory(&GuiData->GuiInfo, &GuiInitInfo->TermInfo, sizeof(GuiInitInfo->TermInfo));
515
516 /* Initialize the icon handles */
517 if (GuiInitInfo->hIcon != NULL)
518 GuiData->hIcon = GuiInitInfo->hIcon;
519 else
520 GuiData->hIcon = ghDefaultIcon;
521
522 if (GuiInitInfo->hIconSm != NULL)
523 GuiData->hIconSm = GuiInitInfo->hIconSm;
524 else
525 GuiData->hIconSm = ghDefaultIconSm;
526
527 ASSERT(GuiData->hIcon && GuiData->hIconSm);
528
529 /* Mouse is shown by default with its default cursor shape */
530 GuiData->hCursor = ghDefaultCursor;
531 GuiData->MouseCursorRefCount = 0;
532
533 /* A priori don't ignore mouse events */
534 GuiData->IgnoreNextMouseEvent = FALSE;
535 /* Initialize HACK FOR CORE-8394. See conwnd.c!OnMouse for more details. */
537
538 /* Close button and the corresponding system menu item are enabled by default */
539 GuiData->IsCloseButtonEnabled = TRUE;
540
541 /* There is no user-reserved menu id range by default */
542 GuiData->CmdIdLow = GuiData->CmdIdHigh = 0;
543
544 /* Initialize the selection */
545 RtlZeroMemory(&GuiData->Selection, sizeof(GuiData->Selection));
547 RtlZeroMemory(&GuiData->dwSelectionCursor, sizeof(GuiData->dwSelectionCursor));
548 GuiData->LineSelection = FALSE; // Default to block selection
549 // TODO: Retrieve the selection mode via the registry.
550
551 GuiData->InputThreadId = GuiInitInfo->InputThreadId;
552 GuiData->WinSta = GuiInitInfo->WinSta;
553 GuiData->Desktop = GuiInitInfo->Desktop;
554
555 /* Finally, finish to initialize the frontend structure */
556 This->Context = GuiData;
557 ConsoleFreeHeap(This->Context2);
558 This->Context2 = NULL;
559
560 /*
561 * We need to wait until the GUI has been fully initialized
562 * to retrieve custom settings i.e. WindowSize etc...
563 * Ideally we could use SendNotifyMessage for this but its not
564 * yet implemented.
565 */
570
571 DPRINT("GUI - Checkpoint\n");
572
573 /* Create the terminal window */
575
576 /* Wait until initialization has finished */
578 DPRINT("OK we created the console window\n");
579 NtClose(GuiData->hGuiInitEvent);
580 GuiData->hGuiInitEvent = NULL;
581
582 /* Check whether we really succeeded in initializing the terminal window */
583 if (GuiData->hWindow == NULL)
584 {
585 DPRINT("GuiInitConsole - We failed at creating a new terminal window\n");
587 return STATUS_UNSUCCESSFUL;
588 }
589
590 return STATUS_SUCCESS;
591}
592
593static VOID NTAPI
595{
596 PGUI_CONSOLE_DATA GuiData = This->Context;
597
598 DPRINT("Send PM_DESTROY_CONSOLE message and wait on hGuiTermEvent...\n");
601 DPRINT("hGuiTermEvent set\n");
602 NtClose(GuiData->hGuiTermEvent);
603 GuiData->hGuiTermEvent = NULL;
604
605 CloseDesktop(GuiData->Desktop); // NtUserCloseDesktop
606 CloseWindowStation(GuiData->WinSta); // NtUserCloseWindowStation
607
608 DPRINT("Destroying icons !! - GuiData->hIcon = 0x%p ; ghDefaultIcon = 0x%p ; GuiData->hIconSm = 0x%p ; ghDefaultIconSm = 0x%p\n",
609 GuiData->hIcon, ghDefaultIcon, GuiData->hIconSm, ghDefaultIconSm);
610 if (GuiData->hIcon != NULL && GuiData->hIcon != ghDefaultIcon)
611 {
612 DPRINT("Destroy hIcon\n");
613 DestroyIcon(GuiData->hIcon);
614 }
615 if (GuiData->hIconSm != NULL && GuiData->hIconSm != ghDefaultIconSm)
616 {
617 DPRINT("Destroy hIconSm\n");
618 DestroyIcon(GuiData->hIconSm);
619 }
620
621 This->Context = NULL;
622 DeleteCriticalSection(&GuiData->Lock);
623 ConsoleFreeHeap(GuiData);
624
625 DPRINT("Quit GuiDeinitFrontEnd\n");
626}
627
628static VOID NTAPI
631{
632 PGUI_CONSOLE_DATA GuiData = This->Context;
633
634 /* Do nothing if the window is hidden */
635 if (!GuiData->IsWindowVisible) return;
636
637 DrawRegion(GuiData, Region);
638}
639
640static VOID NTAPI
643 SHORT CursorStartX,
644 SHORT CursorStartY,
645 UINT ScrolledLines,
647 UINT Length)
648{
649 PGUI_CONSOLE_DATA GuiData = This->Context;
651 SHORT CursorEndX, CursorEndY;
652 RECT ScrollRect;
653
654 if (NULL == GuiData || NULL == GuiData->hWindow) return;
655
656 /* Do nothing if the window is hidden */
657 if (!GuiData->IsWindowVisible) return;
658
659 Buff = GuiData->ActiveBuffer;
660 if (GetType(Buff) != TEXTMODE_BUFFER) return;
661
662 if (0 != ScrolledLines)
663 {
664 ScrollRect.left = 0;
665 ScrollRect.top = 0;
666 ScrollRect.right = Buff->ViewSize.X * GuiData->CharWidth;
667 ScrollRect.bottom = Region->Top * GuiData->CharHeight;
668
669 ScrollWindowEx(GuiData->hWindow,
670 0,
671 -(int)(ScrolledLines * GuiData->CharHeight),
672 &ScrollRect,
673 NULL,
674 NULL,
675 NULL,
677 }
678
679 DrawRegion(GuiData, Region);
680
681 if (CursorStartX < Region->Left || Region->Right < CursorStartX
682 || CursorStartY < Region->Top || Region->Bottom < CursorStartY)
683 {
684 InvalidateCell(GuiData, CursorStartX, CursorStartY);
685 }
686
687 CursorEndX = Buff->CursorPosition.X;
688 CursorEndY = Buff->CursorPosition.Y;
689 if ((CursorEndX < Region->Left || Region->Right < CursorEndX
690 || CursorEndY < Region->Top || Region->Bottom < CursorEndY)
691 && (CursorEndX != CursorStartX || CursorEndY != CursorStartY))
692 {
693 InvalidateCell(GuiData, CursorEndX, CursorEndY);
694 }
695
696 // HACK!!
697 // Set up the update timer (very short interval) - this is a "hack" for getting the OS to
698 // repaint the window without having it just freeze up and stay on the screen permanently.
699 Buff->CursorBlinkOn = TRUE;
701}
702
703/* static */ VOID NTAPI
705{
706 PGUI_CONSOLE_DATA GuiData = This->Context;
707
708 /* Emit an error beep sound */
710}
711
712static BOOL NTAPI
715{
716 PGUI_CONSOLE_DATA GuiData = This->Context;
717
718 /* Do nothing if the window is hidden */
719 if (!GuiData->IsWindowVisible) return TRUE;
720
721 if (GuiData->ActiveBuffer == Buff)
722 {
723 InvalidateCell(GuiData, Buff->CursorPosition.X, Buff->CursorPosition.Y);
724 }
725
726 return TRUE;
727}
728
729static BOOL NTAPI
732 SHORT OldCursorX,
733 SHORT OldCursorY)
734{
735 PGUI_CONSOLE_DATA GuiData = This->Context;
736
737 /* Do nothing if the window is hidden */
738 if (!GuiData->IsWindowVisible) return TRUE;
739
740 if (GuiData->ActiveBuffer == Buff)
741 {
742 /* Redraw char at old position (remove cursor) */
743 InvalidateCell(GuiData, OldCursorX, OldCursorY);
744 /* Redraw char at new position (show cursor) */
745 InvalidateCell(GuiData, Buff->CursorPosition.X, Buff->CursorPosition.Y);
746 }
747
748 return TRUE;
749}
750
751static VOID NTAPI
753{
754 PGUI_CONSOLE_DATA GuiData = This->Context;
755
756 /* Resize the window to the user's values */
757 PostMessageW(GuiData->hWindow, PM_RESIZE_TERMINAL, 0, 0);
758}
759
760static VOID NTAPI
762{
763 PGUI_CONSOLE_DATA GuiData = This->Context;
764 PCONSOLE_SCREEN_BUFFER ActiveBuffer;
765 HPALETTE hPalette;
766
767 EnterCriticalSection(&GuiData->Lock);
768 GuiData->WindowSizeLock = TRUE;
769
772
773 GuiData->WindowSizeLock = FALSE;
774 LeaveCriticalSection(&GuiData->Lock);
775
776 ActiveBuffer = GuiData->ActiveBuffer;
777
778 /* Change the current palette */
779 if (ActiveBuffer->PaletteHandle == NULL)
780 hPalette = GuiData->hSysPalette;
781 else
782 hPalette = ActiveBuffer->PaletteHandle;
783
784 DPRINT("GuiSetActiveScreenBuffer using palette 0x%p\n", hPalette);
785
786 /* Set the new palette for the framebuffer */
787 SelectPalette(GuiData->hMemDC, hPalette, FALSE);
788
789 /* Specify the use of the system palette for the framebuffer */
790 SetSystemPaletteUse(GuiData->hMemDC, ActiveBuffer->PaletteUsage);
791
792 /* Realize the (logical) palette */
793 RealizePalette(GuiData->hMemDC);
794
796 // ConioDrawConsole(Console);
797}
798
799static VOID NTAPI
802{
803 PGUI_CONSOLE_DATA GuiData = This->Context;
804
805 /*
806 * If we were notified to release a screen buffer that is not actually
807 * ours, then just ignore the notification...
808 */
809 if (ScreenBuffer != GuiData->ActiveBuffer) return;
810
811 /*
812 * ... else, we must release our active buffer. Two cases are present:
813 * - If ScreenBuffer (== GuiData->ActiveBuffer) IS NOT the console
814 * active screen buffer, then we can safely switch to it.
815 * - If ScreenBuffer IS the console active screen buffer, we must release
816 * it ONLY.
817 */
818
819 /* Release the old active palette and set the default one */
820 if (GetCurrentObject(GuiData->hMemDC, OBJ_PAL) == ScreenBuffer->PaletteHandle)
821 {
822 /* Set the new palette */
823 SelectPalette(GuiData->hMemDC, GuiData->hSysPalette, FALSE);
824 }
825
826 /* Set the adequate active screen buffer */
827 if (ScreenBuffer != GuiData->Console->ActiveBuffer)
828 {
830 }
831 else
832 {
833 EnterCriticalSection(&GuiData->Lock);
834 GuiData->WindowSizeLock = TRUE;
835
837
838 GuiData->WindowSizeLock = FALSE;
839 LeaveCriticalSection(&GuiData->Lock);
840 }
841}
842
843static BOOL NTAPI
845 HCURSOR CursorHandle);
846
847static VOID NTAPI
849{
850 PGUI_CONSOLE_DATA GuiData = This->Context;
851
852 /* Update the console leader information held by the window */
854
855 /*
856 * HACK:
857 * We reset the cursor here so that, when a console app quits, we reset
858 * the cursor to the default one. It's quite a hack since it doesn't proceed
859 * per - console process... This must be fixed.
860 *
861 * See GuiInitConsole(...) for more information.
862 */
863
864 /* Mouse is shown by default with its default cursor shape */
865 GuiData->MouseCursorRefCount = 0; // Reinitialize the reference counter
867}
868
869static VOID NTAPI
871{
872 PGUI_CONSOLE_DATA GuiData = This->Context;
874}
875
876static BOOL NTAPI
878 HICON IconHandle)
879{
880 PGUI_CONSOLE_DATA GuiData = This->Context;
882
883 if (IconHandle == NULL)
884 {
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
919static HDESK NTAPI
921{
922 PGUI_CONSOLE_DATA GuiData = This->Context;
923 return GuiData->Desktop;
924}
925
926static HWND NTAPI
928{
929 PGUI_CONSOLE_DATA GuiData = This->Context;
930 return GuiData->hWindow;
931}
932
933static VOID NTAPI
935 PCOORD pSize)
936{
937 PGUI_CONSOLE_DATA GuiData = This->Context;
938 PCONSOLE_SCREEN_BUFFER ActiveBuffer;
939 HMONITOR hMonitor;
940 MONITORINFO MonitorInfo;
942 UINT WidthUnit, HeightUnit;
943
944 if (!pSize) return;
945
946 /*
947 * Retrieve the monitor that is mostly covered by the current console window;
948 * default to primary monitor otherwise.
949 */
950 MonitorInfo.cbSize = sizeof(MonitorInfo);
951 hMonitor = MonitorFromWindow(GuiData->hWindow, MONITOR_DEFAULTTOPRIMARY);
952 if (hMonitor && GetMonitorInfoW(hMonitor, &MonitorInfo))
953 {
954 /* Retrieve the width and height of the client area of this monitor */
955 Width = MonitorInfo.rcWork.right - MonitorInfo.rcWork.left;
956 Height = MonitorInfo.rcWork.bottom - MonitorInfo.rcWork.top;
957 }
958 else
959 {
960 /*
961 * Retrieve the width and height of the client area for a full-screen
962 * window on the primary display monitor.
963 */
966
967 // RECT WorkArea;
968 // SystemParametersInfoW(SPI_GETWORKAREA, 0, &WorkArea, 0);
969 // Width = WorkArea.right;
970 // Height = WorkArea.bottom;
971 }
972
973 ActiveBuffer = GuiData->ActiveBuffer;
974#if 0
975 // NOTE: This would be surprising if we wouldn't have an associated buffer...
976 if (ActiveBuffer)
977#endif
978 GetScreenBufferSizeUnits(ActiveBuffer, GuiData, &WidthUnit, &HeightUnit);
979#if 0
980 else
981 /* Default: graphics mode */
982 WidthUnit = HeightUnit = 1;
983#endif
984
987
988 if (Width < 0) Width = 0;
989 if (Height < 0) Height = 0;
990
991 pSize->X = (SHORT)(Width / (int)WidthUnit ) /* HACK */ + 2;
992 pSize->Y = (SHORT)(Height / (int)HeightUnit) /* HACK */ + 1;
993}
994
995static BOOL NTAPI
997 PCONSOLE_SELECTION_INFO pSelectionInfo)
998{
999 PGUI_CONSOLE_DATA GuiData = This->Context;
1000
1001 if (pSelectionInfo == NULL) return FALSE;
1002
1003 ZeroMemory(pSelectionInfo, sizeof(*pSelectionInfo));
1004 if (GuiData->Selection.dwFlags != CONSOLE_NO_SELECTION)
1005 RtlCopyMemory(pSelectionInfo, &GuiData->Selection, sizeof(*pSelectionInfo));
1006
1007 return TRUE;
1008}
1009
1010static BOOL NTAPI
1012 HPALETTE PaletteHandle,
1013 UINT PaletteUsage)
1014{
1015 PGUI_CONSOLE_DATA GuiData = This->Context;
1016 HPALETTE OldPalette;
1017
1018 // if (GetType(GuiData->ActiveBuffer) != GRAPHICS_BUFFER) return FALSE;
1019 if (PaletteHandle == NULL) return FALSE;
1020
1021 /* Set the new palette for the framebuffer */
1022 OldPalette = SelectPalette(GuiData->hMemDC, PaletteHandle, FALSE);
1023 if (OldPalette == NULL) return FALSE;
1024
1025 /* Specify the use of the system palette for the framebuffer */
1026 SetSystemPaletteUse(GuiData->hMemDC, PaletteUsage);
1027
1028 /* Realize the (logical) palette */
1029 RealizePalette(GuiData->hMemDC);
1030
1031 /* Save the original system palette handle */
1032 if (GuiData->hSysPalette == NULL) GuiData->hSysPalette = OldPalette;
1033
1034 return TRUE;
1035}
1036
1037static BOOL NTAPI
1039 UINT CodePage)
1040{
1041 PGUI_CONSOLE_DATA GuiData = This->Context;
1042
1043 /*
1044 * Attempt to reinitialize the current font for the new code page,
1045 * trying to keep the current font with the same characteristics.
1046 * If the current font does not support the new code page, switch
1047 * to a different font supporting the code page but having similar
1048 * characteristics.
1049 * If no font can be found for this code page, stay using the
1050 * original font and refuse changing the code page.
1051 */
1052 if (!InitFonts(GuiData,
1053 GuiData->GuiInfo.FaceName,
1054 GuiData->GuiInfo.FontWeight,
1055 GuiData->GuiInfo.FontFamily,
1056 GuiData->GuiInfo.FontSize,
1057 CodePage, FALSE))
1058 {
1059 DPRINT1("Failed to initialize font '%S' for code page %d - Refuse CP change\n",
1060 GuiData->GuiInfo.FaceName, CodePage);
1061 return FALSE;
1062 }
1063
1064 return TRUE;
1065}
1066
1067static ULONG NTAPI
1069{
1070 PGUI_CONSOLE_DATA GuiData = This->Context;
1071 ULONG DisplayMode = 0;
1072
1073 if (GuiData->GuiInfo.FullScreen)
1074 DisplayMode |= CONSOLE_FULLSCREEN_HARDWARE; // CONSOLE_FULLSCREEN
1075 else
1077
1078 return DisplayMode;
1079}
1080
1081static BOOL NTAPI
1083 ULONG NewMode)
1084{
1085 PGUI_CONSOLE_DATA GuiData = This->Context;
1086 BOOL FullScreen;
1087
1089 return FALSE;
1090
1091 /* Do nothing if the window is hidden */
1092 if (!GuiData->IsWindowVisible) return TRUE;
1093
1094 FullScreen = ((NewMode & CONSOLE_FULLSCREEN_MODE) != 0);
1095
1096 if (FullScreen != GuiData->GuiInfo.FullScreen)
1097 {
1098 SwitchFullScreen(GuiData, FullScreen);
1099 }
1100
1101 return TRUE;
1102}
1103
1104static INT NTAPI
1106 BOOL Show)
1107{
1108 PGUI_CONSOLE_DATA GuiData = This->Context;
1109
1110 if (GuiData->IsWindowVisible)
1111 {
1112 /* Set the reference count */
1113 if (Show) ++GuiData->MouseCursorRefCount;
1114 else --GuiData->MouseCursorRefCount;
1115
1116 /* Effectively show (or hide) the cursor (use special values for (w|l)Param) */
1117 PostMessageW(GuiData->hWindow, WM_SETCURSOR, -1, -1);
1118 }
1119
1120 return GuiData->MouseCursorRefCount;
1121}
1122
1123static BOOL NTAPI
1125 HCURSOR CursorHandle)
1126{
1127 PGUI_CONSOLE_DATA GuiData = This->Context;
1128
1129 /* Do nothing if the window is hidden */
1130 if (!GuiData->IsWindowVisible) return TRUE;
1131
1132 /*
1133 * Set the cursor's handle. If the given handle is NULL,
1134 * then restore the default cursor.
1135 */
1136 GuiData->hCursor = (CursorHandle ? CursorHandle : ghDefaultCursor);
1137
1138 /* Effectively modify the shape of the cursor (use special values for (w|l)Param) */
1139 PostMessageW(GuiData->hWindow, WM_SETCURSOR, -1, -1);
1140
1141 return TRUE;
1142}
1143
1144static HMENU NTAPI
1146 UINT CmdIdLow,
1147 UINT CmdIdHigh)
1148{
1149 PGUI_CONSOLE_DATA GuiData = This->Context;
1150
1151 GuiData->CmdIdLow = CmdIdLow ;
1152 GuiData->CmdIdHigh = CmdIdHigh;
1153
1154 return GuiData->hSysMenu;
1155}
1156
1157static BOOL NTAPI
1159 BOOL Enable)
1160{
1161 /*
1162 * NOTE: See http://www.mail-archive.com/harbour@harbour-project.org/msg27509.html
1163 * or http://harbour-devel.1590103.n2.nabble.com/Question-about-hb-gt-win-CtrlHandler-usage-td4670862i20.html
1164 * for more information.
1165 */
1166
1167 PGUI_CONSOLE_DATA GuiData = This->Context;
1168
1169 if (GuiData->hSysMenu == NULL) return FALSE;
1170
1171 GuiData->IsCloseButtonEnabled = Enable;
1173
1174 return TRUE;
1175}
1176
1178{
1204};
1205
1206
1210 IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
1211 IN HANDLE ConsoleLeaderProcessHandle)
1212{
1213 PCONSOLE_START_INFO ConsoleStartInfo;
1214 PGUI_INIT_INFO GuiInitInfo;
1215 USEROBJECTFLAGS UserObjectFlags;
1216
1217 if (FrontEnd == NULL || ConsoleInfo == NULL || ConsoleInitInfo == NULL)
1219
1220 ConsoleStartInfo = ConsoleInitInfo->ConsoleStartInfo;
1221
1222 /*
1223 * Initialize a private initialization info structure for later use.
1224 * It must be freed by a call to GuiUnloadFrontEnd or GuiInitFrontEnd.
1225 */
1226 GuiInitInfo = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*GuiInitInfo));
1227 if (GuiInitInfo == NULL) return STATUS_NO_MEMORY;
1228
1229 /* Initialize GUI terminal emulator common functionalities */
1230 if (!GuiInit(ConsoleInitInfo, ConsoleLeaderProcessHandle, GuiInitInfo))
1231 {
1232 ConsoleFreeHeap(GuiInitInfo);
1233 return STATUS_UNSUCCESSFUL;
1234 }
1235
1236 GuiInitInfo->IsWindowVisible = ConsoleInitInfo->IsWindowVisible;
1237 if (GuiInitInfo->IsWindowVisible)
1238 {
1239 /* Don't show the console if the window station is not interactive */
1240 if (GetUserObjectInformationW(GuiInitInfo->WinSta,
1241 UOI_FLAGS,
1242 &UserObjectFlags,
1243 sizeof(UserObjectFlags),
1244 NULL))
1245 {
1246 if (!(UserObjectFlags.dwFlags & WSF_VISIBLE))
1247 GuiInitInfo->IsWindowVisible = FALSE;
1248 }
1249 }
1250
1251 /*
1252 * Load terminal settings
1253 */
1254#if 0
1255 /* Impersonate the caller in order to retrieve settings in its context */
1256 // if (!CsrImpersonateClient(NULL))
1257 // return STATUS_UNSUCCESSFUL;
1259
1260 /* 1. Load the default settings */
1262#endif
1263
1264 GuiInitInfo->TermInfo.ShowWindow = SW_SHOWNORMAL;
1265
1266 if (GuiInitInfo->IsWindowVisible)
1267 {
1268 /* 2. Load the remaining console settings via the registry */
1269 if ((ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
1270 {
1271#if 0
1272 /* Load the terminal information from the registry */
1273 GuiConsoleReadUserSettings(&GuiInitInfo->TermInfo);
1274#endif
1275
1276 /*
1277 * Now, update them with the properties the user might gave to us
1278 * via the STARTUPINFO structure before calling CreateProcess
1279 * (and which was transmitted via the ConsoleStartInfo structure).
1280 * We therefore overwrite the values read in the registry.
1281 */
1282 if (ConsoleStartInfo->dwStartupFlags & STARTF_USESHOWWINDOW)
1283 {
1284 GuiInitInfo->TermInfo.ShowWindow = ConsoleStartInfo->wShowWindow;
1285 }
1286 if (ConsoleStartInfo->dwStartupFlags & STARTF_USEPOSITION)
1287 {
1288 ConsoleInfo->AutoPosition = FALSE;
1289 ConsoleInfo->WindowPosition.x = ConsoleStartInfo->dwWindowOrigin.X;
1290 ConsoleInfo->WindowPosition.y = ConsoleStartInfo->dwWindowOrigin.Y;
1291 }
1292 if (ConsoleStartInfo->dwStartupFlags & STARTF_RUNFULLSCREEN)
1293 {
1294 ConsoleInfo->FullScreen = TRUE;
1295 }
1296 }
1297 }
1298
1299#if 0
1300 /* Revert impersonation */
1302#endif
1303
1304 // Font data
1305 StringCchCopyNW(GuiInitInfo->TermInfo.FaceName, ARRAYSIZE(GuiInitInfo->TermInfo.FaceName),
1306 ConsoleInfo->FaceName, ARRAYSIZE(ConsoleInfo->FaceName));
1307 GuiInitInfo->TermInfo.FontFamily = ConsoleInfo->FontFamily;
1308 GuiInitInfo->TermInfo.FontSize = ConsoleInfo->FontSize;
1309 GuiInitInfo->TermInfo.FontWeight = ConsoleInfo->FontWeight;
1310
1311 // Display
1312 GuiInitInfo->TermInfo.FullScreen = ConsoleInfo->FullScreen;
1313 GuiInitInfo->TermInfo.AutoPosition = ConsoleInfo->AutoPosition;
1314 GuiInitInfo->TermInfo.WindowOrigin = ConsoleInfo->WindowPosition;
1315
1316 /* Initialize the icon handles */
1317 // if (ConsoleStartInfo->hIcon != NULL)
1318 GuiInitInfo->hIcon = ConsoleStartInfo->hIcon;
1319 // else
1320 // GuiInitInfo->hIcon = ghDefaultIcon;
1321
1322 // if (ConsoleStartInfo->hIconSm != NULL)
1323 GuiInitInfo->hIconSm = ConsoleStartInfo->hIconSm;
1324 // else
1325 // GuiInitInfo->hIconSm = ghDefaultIconSm;
1326
1327 // ASSERT(GuiInitInfo->hIcon && GuiInitInfo->hIconSm);
1328
1329 /* Finally, initialize the frontend structure */
1330 FrontEnd->Vtbl = &GuiVtbl;
1331 FrontEnd->Context = NULL;
1332 FrontEnd->Context2 = GuiInitInfo;
1333
1334 return STATUS_SUCCESS;
1335}
1336
1339{
1340 if (FrontEnd == NULL) return STATUS_INVALID_PARAMETER;
1341
1342 if (FrontEnd->Context ) GuiDeinitFrontEnd(FrontEnd);
1343 if (FrontEnd->Context2) ConsoleFreeHeap(FrontEnd->Context2);
1344
1345 return STATUS_SUCCESS;
1346}
1347
1348/* EOF */
unsigned char BOOLEAN
CConsole Console
#define msg(x)
Definition: auth_time.c:54
HWND hWnd
Definition: settings.c:17
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
static LPHIST_ENTRY Top
Definition: history.c:53
#define HandleToUlong(h)
Definition: basetsd.h:79
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
HINSTANCE hInstance
Definition: charmap.c:19
Definition: bufpool.h:45
PCONSOLE_SCREEN_BUFFER ConDrvGetActiveScreenBuffer(IN PCONSOLE Console)
Definition: conoutput.c:201
HINSTANCE ConSrvDllInstance
Definition: init.c:21
BOOL InitFonts(_Inout_ PGUI_CONSOLE_DATA GuiData, _In_reads_or_z_(LF_FACESIZE) PCWSTR FaceName, _In_ ULONG FontWeight, _In_ ULONG FontFamily, _In_ COORD FontSize, _In_opt_ UINT CodePage, _In_ BOOL UseDefaultFallback)
Definition: conwnd.c:521
#define GUI_CONWND_CLASS
Definition: conwnd.h:15
#define PM_RESIZE_TERMINAL
Definition: conwnd.h:20
struct _GUI_CONSOLE_DATA * PGUI_CONSOLE_DATA
#define PM_CONSOLE_SET_TITLE
Definition: conwnd.h:22
#define PM_CONSOLE_BEEP
Definition: conwnd.h:21
BOOLEAN NTAPI CsrImpersonateClient(IN PCSR_THREAD CsrThread)
Definition: procsup.c:932
BOOLEAN NTAPI CsrRevertToSelf(VOID)
Definition: procsup.c:1057
VOID NTAPI CsrDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:776
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
Definition: thredsup.c:512
PCSR_THREAD NTAPI CsrConnectToUser(VOID)
Definition: api.c:1021
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define ULONG_PTR
Definition: config.h:101
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
@ Success
Definition: eventcreate.c:712
unsigned int BOOL
Definition: ntddk_ex.h:94
VOID SwitchFullScreen(PGUI_CONSOLE_DATA GuiData, BOOL FullScreen)
Definition: fullscreen.c:49
Status
Definition: gdiplustypes.h:25
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
BOOL GuiConsoleReadUserSettings(IN OUT PGUI_CONSOLE_INFO TermInfo)
Definition: guisettings.c:24
VOID GuiConsoleGetDefaultSettings(IN OUT PGUI_CONSOLE_INFO TermInfo)
Definition: guisettings.c:38
static VOID NTAPI GuiReleaseScreenBuffer(IN OUT PFRONTEND This, IN PCONSOLE_SCREEN_BUFFER ScreenBuffer)
Definition: guiterm.c:800
VOID NTAPI GuiRingBell(IN OUT PFRONTEND This)
Definition: guiterm.c:704
VOID CreateSysMenu(HWND hWnd)
Definition: conwnd.c:242
static BOOL NTAPI GuiSetCodePage(IN OUT PFRONTEND This, UINT CodePage)
Definition: guiterm.c:1038
BOOLEAN UnRegisterConWndClass(HINSTANCE hInstance)
Definition: conwnd.c:182
static VOID NTAPI GuiResizeTerminal(IN OUT PFRONTEND This)
Definition: guiterm.c:752
static BOOL NTAPI GuiSetMouseCursor(IN OUT PFRONTEND This, HCURSOR CursorHandle)
Definition: guiterm.c:1124
HCURSOR ghDefaultCursor
Definition: conwnd.c:75
static ULONG NTAPI GuiGetDisplayMode(IN OUT PFRONTEND This)
Definition: guiterm.c:1068
#define CONGUI_UPDATE_TIME
Definition: guiterm.c:24
static VOID NTAPI GuiWriteStream(IN OUT PFRONTEND This, SMALL_RECT *Region, SHORT CursorStartX, SHORT CursorStartY, UINT ScrolledLines, PWCHAR Buffer, UINT Length)
Definition: guiterm.c:641
static HDESK NTAPI GuiGetThreadConsoleDesktop(IN OUT PFRONTEND This)
Definition: guiterm.c:920
HICON ghDefaultIcon
Definition: conwnd.c:73
NTSTATUS NTAPI GuiLoadFrontEnd(IN OUT PFRONTEND FrontEnd, IN OUT PCONSOLE_STATE_INFO ConsoleInfo, IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle)
Definition: guiterm.c:1208
VOID InvalidateCell(PGUI_CONSOLE_DATA GuiData, SHORT x, SHORT y)
Definition: guiterm.c:88
static BOOL NTAPI GuiChangeIcon(IN OUT PFRONTEND This, HICON IconHandle)
Definition: guiterm.c:877
static ULONG NTAPI GuiConsoleInputThread(PVOID Param)
Definition: guiterm.c:105
static VOID NTAPI GuiDrawRegion(IN OUT PFRONTEND This, SMALL_RECT *Region)
Definition: guiterm.c:629
static BOOL ConsInitialized
Definition: guiterm.c:45
static FRONTEND_VTBL GuiVtbl
Definition: guiterm.c:1177
static VOID DrawRegion(PGUI_CONSOLE_DATA GuiData, SMALL_RECT *Region)
Definition: guiterm.c:76
static HMENU NTAPI GuiMenuControl(IN OUT PFRONTEND This, UINT CmdIdLow, UINT CmdIdHigh)
Definition: guiterm.c:1145
NTSTATUS NTAPI GuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd)
Definition: guiterm.c:1338
VOID SetConWndConsoleLeaderCID(IN PGUI_CONSOLE_DATA GuiData)
Definition: conwnd.c:48
static VOID NTAPI GuiSetActiveScreenBuffer(IN OUT PFRONTEND This)
Definition: guiterm.c:761
struct _GUI_INIT_INFO * PGUI_INIT_INFO
static INT NTAPI GuiShowMouseCursor(IN OUT PFRONTEND This, BOOL Show)
Definition: guiterm.c:1105
struct _GUI_INIT_INFO GUI_INIT_INFO
static BOOL NTAPI GuiSetMenuClose(IN OUT PFRONTEND This, BOOL Enable)
Definition: guiterm.c:1158
static NTSTATUS NTAPI GuiInitFrontEnd(IN OUT PFRONTEND This, IN PCONSRV_CONSOLE Console)
Definition: guiterm.c:480
static BOOL GuiInit(IN PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle, IN OUT PGUI_INIT_INFO GuiInitInfo)
Definition: guiterm.c:284
static BOOL NTAPI GuiSetPalette(IN OUT PFRONTEND This, HPALETTE PaletteHandle, UINT PaletteUsage)
Definition: guiterm.c:1011
VOID GuiConsoleMoveWindow(PGUI_CONSOLE_DATA GuiData)
Definition: guiterm.c:61
static VOID NTAPI GuiDeinitFrontEnd(IN OUT PFRONTEND This)
Definition: guiterm.c:594
static BOOL NTAPI GuiSetDisplayMode(IN OUT PFRONTEND This, ULONG NewMode)
Definition: guiterm.c:1082
static BOOL NTAPI GuiGetSelectionInfo(IN OUT PFRONTEND This, PCONSOLE_SELECTION_INFO pSelectionInfo)
Definition: guiterm.c:996
static VOID NTAPI GuiGetLargestConsoleWindowSize(IN OUT PFRONTEND This, PCOORD pSize)
Definition: guiterm.c:934
static BOOL NTAPI GuiSetScreenInfo(IN OUT PFRONTEND This, PCONSOLE_SCREEN_BUFFER Buff, SHORT OldCursorX, SHORT OldCursorY)
Definition: guiterm.c:730
static BOOL NTAPI GuiSetCursorInfo(IN OUT PFRONTEND This, PCONSOLE_SCREEN_BUFFER Buff)
Definition: guiterm.c:713
static VOID NTAPI GuiChangeTitle(IN OUT PFRONTEND This)
Definition: guiterm.c:870
BOOLEAN RegisterConWndClass(IN HINSTANCE hInstance)
Definition: conwnd.c:136
static HWND NTAPI GuiGetConsoleWindowHandle(IN OUT PFRONTEND This)
Definition: guiterm.c:927
#define PM_DESTROY_CONSOLE
Definition: guiterm.c:28
HICON ghDefaultIconSm
Definition: conwnd.c:74
static VOID NTAPI GuiRefreshInternalInfo(IN OUT PFRONTEND This)
Definition: guiterm.c:848
#define PM_CREATE_CONSOLE
Definition: guiterm.c:27
#define CONGUI_UPDATE_TIMER
Definition: guiterm.c:25
FORCEINLINE VOID SmallRectToRect(PGUI_CONSOLE_DATA GuiData, PRECT Rect, PSMALL_RECT SmallRect)
Definition: guiterm.h:43
FORCEINLINE VOID GetScreenBufferSizeUnits(IN PCONSOLE_SCREEN_BUFFER Buffer, IN PGUI_CONSOLE_DATA GuiData, OUT PUINT WidthUnit, OUT PUINT HeightUnit)
Definition: guiterm.h:22
@ ConsoleCtrlDesktopConsoleThread
Definition: ntuser.h:1798
NTSTATUS APIENTRY NtUserConsoleControl(IN CONSOLECONTROL ConsoleCtrl, IN PVOID ConsoleCtrlInfo, IN ULONG ConsoleCtrlInfoLength)
Definition: console.c:14
HDESK NTAPI NtUserResolveDesktop(IN HANDLE ProcessHandle, IN PUNICODE_STRING DesktopPath, IN BOOL bInherit, OUT HWINSTA *phWinSta)
Definition: desktop.c:2829
long __cdecl _InterlockedIncrement(_Interlocked_operand_ long volatile *_Addend)
long __cdecl _InterlockedDecrement(_Interlocked_operand_ long volatile *_Addend)
#define NtCurrentTeb
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
if(dx< 0)
Definition: linetemp.h:194
#define ASSERT(a)
Definition: mode.c:44
static HICON
Definition: imagelist.c:84
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
HICON hIcon
Definition: msconfig.c:44
HICON hIconSm
Definition: msconfig.c:44
HMONITOR WINAPI MonitorFromWindow(HWND, DWORD)
static UINT WindowCount
Definition: multiwin.c:4
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI VOID NTAPI RtlExitUserThread(_In_ NTSTATUS Status)
NTSYSAPI NTSTATUS NTAPI RtlCreateUserThread(_In_ PVOID ThreadContext, _Out_ HANDLE *OutThreadHandle, _Reserved_ PVOID Reserved1, _Reserved_ PVOID Reserved2, _Reserved_ PVOID Reserved3, _Reserved_ PVOID Reserved4, _Reserved_ PVOID Reserved5, _Reserved_ PVOID Reserved6, _Reserved_ PVOID Reserved7, _Reserved_ PVOID Reserved8)
HANDLE hThread
Definition: wizard.c:28
HANDLE ScreenBuffer
Definition: notevil.c:37
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define NtCurrentProcess()
Definition: nt_native.h:1657
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI NTSTATUS NTAPI NtWaitForSingleObject(IN HANDLE hObject, IN BOOLEAN bAlertable, IN PLARGE_INTEGER Timeout)
#define UNICODE_NULL
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:142
@ SynchronizationEvent
NTSTATUS NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL)
Definition: event.c:455
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:96
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI NtDuplicateObject(IN HANDLE SourceProcessHandle, IN HANDLE SourceHandle, IN HANDLE TargetProcessHandle OPTIONAL, OUT PHANDLE TargetHandle OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG HandleAttributes, IN ULONG Options)
Definition: obhandle.c:3410
#define OBJ_PAL
Definition: objidl.idl:1413
#define TEXTMODE_BUFFER
Definition: pccons.c:21
static VIDEODISPLAYMODE DisplayMode
Definition: pcvideo.c:117
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236
HANDLE UniqueThread
Definition: compat.h:826
COORD CursorPosition
Definition: conio.h:71
BOOLEAN CursorBlinkOn
Definition: conio.h:72
HPALETTE PaletteHandle
Definition: conio.h:78
Definition: bl.h:1338
ULONG Y
Definition: bl.h:1340
ULONG X
Definition: bl.h:1339
HANDLE ThreadHandle
Definition: csrsrv.h:71
HMENU hSysMenu
Definition: conwnd.h:77
UINT CmdIdHigh
Definition: conwnd.h:80
PCONSOLE_SCREEN_BUFFER ActiveBuffer
Definition: conwnd.h:92
HWINSTA WinSta
Definition: conwnd.h:49
HDESK Desktop
Definition: conwnd.h:50
CONSOLE_SELECTION_INFO Selection
Definition: conwnd.h:93
HANDLE hGuiInitEvent
Definition: conwnd.h:44
BOOLEAN IsWindowVisible
Definition: conwnd.h:52
BOOL IsCloseButtonEnabled
Definition: conwnd.h:78
HANDLE hGuiTermEvent
Definition: conwnd.h:45
BOOL WindowSizeLock
Definition: conwnd.h:43
BOOL LineSelection
Definition: conwnd.h:95
BOOL HackCORE8394IgnoreNextMove
Definition: conwnd.h:75
BOOL IgnoreNextMouseEvent
Definition: conwnd.h:73
PCONSRV_CONSOLE Console
Definition: conwnd.h:91
HCURSOR hCursor
Definition: conwnd.h:71
CRITICAL_SECTION Lock
Definition: conwnd.h:42
UINT CharWidth
Definition: conwnd.h:87
ULONG_PTR InputThreadId
Definition: conwnd.h:48
GUI_CONSOLE_INFO GuiInfo
Definition: conwnd.h:97
HICON hIconSm
Definition: conwnd.h:68
HPALETTE hSysPalette
Definition: conwnd.h:65
UINT CharHeight
Definition: conwnd.h:88
INT MouseCursorRefCount
Definition: conwnd.h:72
COORD dwSelectionCursor
Definition: conwnd.h:94
WCHAR FaceName[LF_FACESIZE]
Definition: guisettings.h:18
HDESK Desktop
Definition: guiterm.c:38
HICON hIcon
Definition: guiterm.c:39
GUI_CONSOLE_INFO TermInfo
Definition: guiterm.c:42
ULONG_PTR InputThreadId
Definition: guiterm.c:36
HANDLE GuiThreadStartupEvent
Definition: guiterm.c:35
HICON hIconSm
Definition: guiterm.c:40
BOOLEAN IsWindowVisible
Definition: guiterm.c:41
HWINSTA WinSta
Definition: guiterm.c:37
USHORT MaximumLength
Definition: env_spec_w32.h:370
DWORD cbSize
Definition: winuser.h:3783
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
static CONSOLE_SCREEN_BUFFER_INFO ConsoleInfo
Definition: video.c:47
static HPALETTE PaletteHandle
Definition: svga.c:215
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define ICON_BIG
Definition: tnclass.cpp:51
#define ICON_SMALL
Definition: tnclass.cpp:48
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
#define NTAPI
Definition: typedefs.h:36
int32_t INT
Definition: typedefs.h:58
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
_In_ HFONT _Out_ PUINT _Out_ PUINT Width
Definition: font.h:89
_In_ HFONT _Out_ PUINT Height
Definition: font.h:88
VOID InitTTFontCache(VOID)
Initializes the console TrueType font cache.
Definition: font.c:1013
#define ConsoleAllocHeap(Flags, Size)
Definition: heap.h:14
#define ConsoleFreeHeap(HeapBase)
Definition: heap.h:15
#define GetType(This)
Definition: conio.h:54
#define ZeroMemory
Definition: winbase.h:1712
#define STARTF_USEPOSITION
Definition: winbase.h:493
#define STARTF_USESHOWWINDOW
Definition: winbase.h:491
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define STARTF_RUNFULLSCREEN
Definition: winbase.h:496
#define CONSOLE_NO_SELECTION
Definition: wincon.h:102
#define CONSOLE_FULLSCREEN_MODE
Definition: wincon.h:33
#define CONSOLE_FULLSCREEN_HARDWARE
Definition: wincon.h:30
#define CONSOLE_WINDOWED_MODE
Definition: wincon.h:34
#define CONSOLE_WINDOWED
Definition: wincon.h:28
LONG_PTR LPARAM
Definition: windef.h:208
HICON HCURSOR
Definition: windef.h:299
UINT WINAPI RealizePalette(_In_ HDC)
Definition: palette.c:138
HPALETTE WINAPI SelectPalette(_In_ HDC, _In_ HPALETTE, _In_ BOOL)
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC, _In_ UINT)
Definition: dc.c:428
UINT WINAPI SetSystemPaletteUse(_In_ HDC, _In_ UINT)
#define SW_SHOWNORMAL
Definition: winuser.h:769
#define HWND_MESSAGE
Definition: winuser.h:1209
#define SW_HIDE
Definition: winuser.h:767
#define SWP_NOACTIVATE
Definition: winuser.h:1241
#define MF_BYCOMMAND
Definition: winuser.h:202
#define SM_CYEDGE
Definition: winuser.h:1008
BOOL WINAPI TranslateMessage(_In_ const MSG *)
#define SM_CXEDGE
Definition: winuser.h:1007
BOOL WINAPI GetMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI SetThreadDesktop(_In_ HDESK)
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define SM_CXFRAME
Definition: winuser.h:993
HICON WINAPI CopyIcon(_In_ HICON)
Definition: cursoricon.c:1994
#define SW_INVALIDATE
Definition: winuser.h:2578
#define SWP_NOSIZE
Definition: winuser.h:1244
BOOL WINAPI CloseWindowStation(_In_ HWINSTA)
#define SM_CYFRAME
Definition: winuser.h:995
#define SM_CXFULLSCREEN
Definition: winuser.h:976
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
#define HWND_DESKTOP
Definition: winuser.h:1208
BOOL WINAPI ShowWindowAsync(_In_ HWND, _In_ int)
#define MF_ENABLED
Definition: winuser.h:128
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
HWND WINAPI CreateWindowExW(_In_ DWORD dwExStyle, _In_opt_ LPCWSTR lpClassName, _In_opt_ LPCWSTR lpWindowName, _In_ DWORD dwStyle, _In_ int X, _In_ int Y, _In_ int nWidth, _In_ int nHeight, _In_opt_ HWND hWndParent, _In_opt_ HMENU hMenu, _In_opt_ HINSTANCE hInstance, _In_opt_ LPVOID lpParam)
#define PM_REMOVE
Definition: winuser.h:1195
#define WSF_VISIBLE
Definition: winuser.h:2451
#define SM_CYFULLSCREEN
Definition: winuser.h:977
#define SC_CLOSE
Definition: winuser.h:2591
#define CW_USEDEFAULT
Definition: winuser.h:225
BOOL WINAPI GetUserObjectInformationW(_In_ HANDLE hObj, _In_ int nIndex, _Out_writes_bytes_opt_(nLength) PVOID pvInfo, _In_ DWORD nLength, _Out_opt_ LPDWORD lpnLengthNeeded)
LRESULT WINAPI DispatchMessageW(_In_ const MSG *)
#define WM_SETCURSOR
Definition: winuser.h:1635
#define UOI_FLAGS
Definition: winuser.h:1082
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
BOOL WINAPI GetMonitorInfoW(_In_ HMONITOR, _Inout_ LPMONITORINFO)
BOOL WINAPI CloseDesktop(_In_ HDESK)
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
#define SWP_NOZORDER
Definition: winuser.h:1246
#define SendNotifyMessage
Definition: winuser.h:5845
BOOL WINAPI DestroyWindow(_In_ HWND)
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
int WINAPI ScrollWindowEx(_In_ HWND, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT, _In_ UINT)
#define SM_CYCAPTION
Definition: winuser.h:962
int WINAPI GetSystemMetrics(_In_ int)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2036
#define MF_GRAYED
Definition: winuser.h:129
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1151
#define DUPLICATE_SAME_ACCESS