ReactOS 0.4.15-dev-8146-gdc0ed6d
guiterm.c File Reference
#include <consrv.h>
#include <debug.h>
#include "concfg/font.h"
#include "guiterm.h"
#include "resource.h"
Include dependency graph for guiterm.c:

Go to the source code of this file.

Classes

struct  _GUI_INIT_INFO
 

Macros

#define NDEBUG
 
#define CONGUI_UPDATE_TIME   0
 
#define CONGUI_UPDATE_TIMER   1
 
#define PM_CREATE_CONSOLE   (WM_APP + 1)
 
#define PM_DESTROY_CONSOLE   (WM_APP + 2)
 

Typedefs

typedef struct _GUI_INIT_INFO GUI_INIT_INFO
 
typedef struct _GUI_INIT_INFOPGUI_INIT_INFO
 

Functions

VOID SetConWndConsoleLeaderCID (IN PGUI_CONSOLE_DATA GuiData)
 
BOOLEAN RegisterConWndClass (IN HINSTANCE hInstance)
 
BOOLEAN UnRegisterConWndClass (HINSTANCE hInstance)
 
VOID GuiConsoleMoveWindow (PGUI_CONSOLE_DATA GuiData)
 
static VOID DrawRegion (PGUI_CONSOLE_DATA GuiData, SMALL_RECT *Region)
 
VOID InvalidateCell (PGUI_CONSOLE_DATA GuiData, SHORT x, SHORT y)
 
VOID CreateSysMenu (HWND hWnd)
 
static ULONG NTAPI GuiConsoleInputThread (PVOID Param)
 
static BOOL GuiInit (IN PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle, IN OUT PGUI_INIT_INFO GuiInitInfo)
 
static VOID NTAPI GuiDeinitFrontEnd (IN OUT PFRONTEND This)
 
static NTSTATUS NTAPI GuiInitFrontEnd (IN OUT PFRONTEND This, IN PCONSRV_CONSOLE Console)
 
static VOID NTAPI GuiDrawRegion (IN OUT PFRONTEND This, SMALL_RECT *Region)
 
static VOID NTAPI GuiWriteStream (IN OUT PFRONTEND This, SMALL_RECT *Region, SHORT CursorStartX, SHORT CursorStartY, UINT ScrolledLines, PWCHAR Buffer, UINT Length)
 
VOID NTAPI GuiRingBell (IN OUT PFRONTEND This)
 
static BOOL NTAPI GuiSetCursorInfo (IN OUT PFRONTEND This, PCONSOLE_SCREEN_BUFFER Buff)
 
static BOOL NTAPI GuiSetScreenInfo (IN OUT PFRONTEND This, PCONSOLE_SCREEN_BUFFER Buff, SHORT OldCursorX, SHORT OldCursorY)
 
static VOID NTAPI GuiResizeTerminal (IN OUT PFRONTEND This)
 
static VOID NTAPI GuiSetActiveScreenBuffer (IN OUT PFRONTEND This)
 
static VOID NTAPI GuiReleaseScreenBuffer (IN OUT PFRONTEND This, IN PCONSOLE_SCREEN_BUFFER ScreenBuffer)
 
static BOOL NTAPI GuiSetMouseCursor (IN OUT PFRONTEND This, HCURSOR CursorHandle)
 
static VOID NTAPI GuiRefreshInternalInfo (IN OUT PFRONTEND This)
 
static VOID NTAPI GuiChangeTitle (IN OUT PFRONTEND This)
 
static BOOL NTAPI GuiChangeIcon (IN OUT PFRONTEND This, HICON IconHandle)
 
static HDESK NTAPI GuiGetThreadConsoleDesktop (IN OUT PFRONTEND This)
 
static HWND NTAPI GuiGetConsoleWindowHandle (IN OUT PFRONTEND This)
 
static VOID NTAPI GuiGetLargestConsoleWindowSize (IN OUT PFRONTEND This, PCOORD pSize)
 
static BOOL NTAPI GuiGetSelectionInfo (IN OUT PFRONTEND This, PCONSOLE_SELECTION_INFO pSelectionInfo)
 
static BOOL NTAPI GuiSetPalette (IN OUT PFRONTEND This, HPALETTE PaletteHandle, UINT PaletteUsage)
 
static BOOL NTAPI GuiSetCodePage (IN OUT PFRONTEND This, UINT CodePage)
 
static ULONG NTAPI GuiGetDisplayMode (IN OUT PFRONTEND This)
 
static BOOL NTAPI GuiSetDisplayMode (IN OUT PFRONTEND This, ULONG NewMode)
 
static INT NTAPI GuiShowMouseCursor (IN OUT PFRONTEND This, BOOL Show)
 
static HMENU NTAPI GuiMenuControl (IN OUT PFRONTEND This, UINT CmdIdLow, UINT CmdIdHigh)
 
static BOOL NTAPI GuiSetMenuClose (IN OUT PFRONTEND This, BOOL Enable)
 
NTSTATUS NTAPI GuiLoadFrontEnd (IN OUT PFRONTEND FrontEnd, IN OUT PCONSOLE_STATE_INFO ConsoleInfo, IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle)
 
NTSTATUS NTAPI GuiUnloadFrontEnd (IN OUT PFRONTEND FrontEnd)
 

Variables

static BOOL ConsInitialized = FALSE
 
HICON ghDefaultIcon
 
HICON ghDefaultIconSm
 
HCURSOR ghDefaultCursor
 
static FRONTEND_VTBL GuiVtbl
 

Macro Definition Documentation

◆ CONGUI_UPDATE_TIME

#define CONGUI_UPDATE_TIME   0

Definition at line 24 of file guiterm.c.

◆ CONGUI_UPDATE_TIMER

#define CONGUI_UPDATE_TIMER   1

Definition at line 25 of file guiterm.c.

◆ NDEBUG

#define NDEBUG

Definition at line 16 of file guiterm.c.

◆ PM_CREATE_CONSOLE

#define PM_CREATE_CONSOLE   (WM_APP + 1)

Definition at line 27 of file guiterm.c.

◆ PM_DESTROY_CONSOLE

#define PM_DESTROY_CONSOLE   (WM_APP + 2)

Definition at line 28 of file guiterm.c.

Typedef Documentation

◆ GUI_INIT_INFO

◆ PGUI_INIT_INFO

Function Documentation

◆ CreateSysMenu()

VOID CreateSysMenu ( HWND  hWnd)

Definition at line 242 of file conwnd.c.

243{
244 MENUITEMINFOW mii;
245 HMENU hMenu;
246 PWCHAR ptrTab;
247 WCHAR szMenuStringBack[255];
248
249 hMenu = GetSystemMenu(hWnd, FALSE);
250 if (hMenu == NULL)
251 return;
252
253 mii.cbSize = sizeof(mii);
254 mii.fMask = MIIM_STRING;
255 mii.dwTypeData = szMenuStringBack;
256 mii.cch = ARRAYSIZE(szMenuStringBack);
257
258 GetMenuItemInfoW(hMenu, SC_CLOSE, FALSE, &mii);
259
260 ptrTab = wcschr(szMenuStringBack, L'\t');
261 if (ptrTab)
262 {
263 *ptrTab = L'\0';
264 mii.cch = (UINT)wcslen(szMenuStringBack);
265
266 SetMenuItemInfoW(hMenu, SC_CLOSE, FALSE, &mii);
267 }
268
271}
HWND hWnd
Definition: settings.c:17
static VOID AppendMenuItems(HMENU hMenu, const GUICONSOLE_MENUITEM *Items)
Definition: conwnd.c:188
static const GUICONSOLE_MENUITEM GuiConsoleMainMenuItems[]
Definition: conwnd.c:96
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define wcschr
Definition: compat.h:17
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
unsigned int UINT
Definition: ndis.h:50
#define L(x)
Definition: ntvdm.h:50
LPWSTR dwTypeData
Definition: winuser.h:3269
uint16_t * PWCHAR
Definition: typedefs.h:56
#define MIIM_STRING
Definition: winuser.h:727
BOOL WINAPI SetMenuItemInfoW(_In_ HMENU, _In_ UINT, _In_ BOOL, _In_ LPCMENUITEMINFOW)
HMENU WINAPI GetSystemMenu(_In_ HWND, _In_ BOOL)
BOOL WINAPI DrawMenuBar(_In_ HWND)
#define SC_CLOSE
Definition: winuser.h:2592
BOOL WINAPI GetMenuItemInfoW(_In_ HMENU, _In_ UINT, _In_ BOOL, _Inout_ LPMENUITEMINFOW)
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by GuiConsoleInputThread().

◆ DrawRegion()

static VOID DrawRegion ( PGUI_CONSOLE_DATA  GuiData,
SMALL_RECT Region 
)
static

UpdateWindow(GuiData->hWindow);

Definition at line 76 of file guiterm.c.

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}
FORCEINLINE VOID SmallRectToRect(PGUI_CONSOLE_DATA GuiData, PRECT Rect, PSMALL_RECT SmallRect)
Definition: guiterm.h:43
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)

Referenced by GuiDrawRegion(), GuiWriteStream(), and InvalidateCell().

◆ GuiChangeIcon()

static BOOL NTAPI GuiChangeIcon ( IN OUT PFRONTEND  This,
HICON  IconHandle 
)
static

Definition at line 877 of file guiterm.c.

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}
#define TRUE
Definition: types.h:120
HICON ghDefaultIcon
Definition: conwnd.c:73
HICON ghDefaultIconSm
Definition: conwnd.c:74
static HICON
Definition: imagelist.c:84
HICON hIcon
Definition: msconfig.c:44
HICON hIconSm
Definition: msconfig.c:44
#define DPRINT
Definition: sndvol32.h:73
HICON hIconSm
Definition: conwnd.h:68
#define ICON_BIG
Definition: tnclass.cpp:51
#define ICON_SMALL
Definition: tnclass.cpp:48
LONG_PTR LPARAM
Definition: windef.h:208
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
HICON WINAPI CopyIcon(_In_ HICON)
Definition: cursoricon.c:2042
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2084

◆ GuiChangeTitle()

static VOID NTAPI GuiChangeTitle ( IN OUT PFRONTEND  This)
static

Definition at line 870 of file guiterm.c.

871{
872 PGUI_CONSOLE_DATA GuiData = This->Context;
874}
#define PM_CONSOLE_SET_TITLE
Definition: conwnd.h:22

◆ GuiConsoleInputThread()

static ULONG NTAPI GuiConsoleInputThread ( PVOID  Param)
static

Definition at line 105 of file guiterm.c.

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}
CConsole Console
#define msg(x)
Definition: auth_time.c:54
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
#define HandleToUlong(h)
Definition: basetsd.h:79
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
HINSTANCE ConSrvDllInstance
Definition: init.c:21
#define GUI_CONWND_CLASS
Definition: conwnd.h:15
#define PM_RESIZE_TERMINAL
Definition: conwnd.h:20
struct _GUI_CONSOLE_DATA * PGUI_CONSOLE_DATA
VOID NTAPI CsrDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:776
PCSR_THREAD NTAPI CsrConnectToUser(VOID)
Definition: api.c:1021
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID SwitchFullScreen(PGUI_CONSOLE_DATA GuiData, BOOL FullScreen)
Definition: fullscreen.c:49
Status
Definition: gdiplustypes.h:25
VOID CreateSysMenu(HWND hWnd)
Definition: conwnd.c:242
struct _GUI_INIT_INFO * PGUI_INIT_INFO
VOID GuiConsoleMoveWindow(PGUI_CONSOLE_DATA GuiData)
Definition: guiterm.c:61
#define PM_DESTROY_CONSOLE
Definition: guiterm.c:28
#define PM_CREATE_CONSOLE
Definition: guiterm.c:27
@ ConsoleCtrlDesktopConsoleThread
Definition: ntuser.h:1798
NTSTATUS APIENTRY NtUserConsoleControl(IN CONSOLECONTROL ConsoleCtrl, IN PVOID ConsoleCtrlInfo, IN ULONG ConsoleCtrlInfoLength)
Definition: console.c:14
long __cdecl _InterlockedIncrement(_Interlocked_operand_ long volatile *_Addend)
long __cdecl _InterlockedDecrement(_Interlocked_operand_ long volatile *_Addend)
#define NtCurrentTeb
#define ASSERT(a)
Definition: mode.c:44
static UINT WindowCount
Definition: multiwin.c:4
NTSYSAPI VOID NTAPI RtlExitUserThread(_In_ NTSTATUS Status)
HANDLE hThread
Definition: wizard.c:28
NTSTATUS NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL)
Definition: event.c:455
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
long LONG
Definition: pedump.c:60
#define STATUS_SUCCESS
Definition: shellext.h:65
HANDLE UniqueThread
Definition: compat.h:826
HANDLE ThreadHandle
Definition: csrsrv.h:71
BOOLEAN IsWindowVisible
Definition: conwnd.h:52
HANDLE hGuiTermEvent
Definition: conwnd.h:45
PCONSRV_CONSOLE Console
Definition: conwnd.h:91
GUI_CONSOLE_INFO GuiInfo
Definition: conwnd.h:97
HDESK Desktop
Definition: guiterm.c:38
HANDLE GuiThreadStartupEvent
Definition: guiterm.c:35
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define HWND_MESSAGE
Definition: winuser.h:1210
#define SW_HIDE
Definition: winuser.h:768
BOOL WINAPI TranslateMessage(_In_ const MSG *)
BOOL WINAPI GetMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
BOOL WINAPI SetThreadDesktop(_In_ HDESK)
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
#define HWND_DESKTOP
Definition: winuser.h:1209
BOOL WINAPI ShowWindowAsync(_In_ HWND, _In_ int)
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
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:1196
#define CW_USEDEFAULT
Definition: winuser.h:225
LRESULT WINAPI DispatchMessageW(_In_ const MSG *)
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
BOOL WINAPI CloseDesktop(_In_ HDESK)
BOOL WINAPI DestroyWindow(_In_ HWND)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1151

Referenced by GuiInit().

◆ GuiConsoleMoveWindow()

VOID GuiConsoleMoveWindow ( PGUI_CONSOLE_DATA  GuiData)

Definition at line 61 of file guiterm.c.

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}
#define SWP_NOACTIVATE
Definition: winuser.h:1242
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define SWP_NOSIZE
Definition: winuser.h:1245
#define SWP_NOZORDER
Definition: winuser.h:1247

Referenced by GuiApplyUserSettings(), and GuiConsoleInputThread().

◆ GuiDeinitFrontEnd()

static VOID NTAPI GuiDeinitFrontEnd ( IN OUT PFRONTEND  This)
static

Definition at line 594 of file guiterm.c.

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}
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI NTSTATUS NTAPI NtWaitForSingleObject(IN HANDLE hObject, IN BOOLEAN bAlertable, IN PLARGE_INTEGER Timeout)
HWINSTA WinSta
Definition: conwnd.h:49
HDESK Desktop
Definition: conwnd.h:50
CRITICAL_SECTION Lock
Definition: conwnd.h:42
ULONG_PTR InputThreadId
Definition: conwnd.h:48
#define ConsoleFreeHeap(HeapBase)
Definition: heap.h:15
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
BOOL WINAPI CloseWindowStation(_In_ HWINSTA)
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by GuiInitFrontEnd(), and GuiUnloadFrontEnd().

◆ GuiDrawRegion()

static VOID NTAPI GuiDrawRegion ( IN OUT PFRONTEND  This,
SMALL_RECT Region 
)
static

Definition at line 629 of file guiterm.c.

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}
static VOID DrawRegion(PGUI_CONSOLE_DATA GuiData, SMALL_RECT *Region)
Definition: guiterm.c:76

◆ GuiGetConsoleWindowHandle()

static HWND NTAPI GuiGetConsoleWindowHandle ( IN OUT PFRONTEND  This)
static

Definition at line 927 of file guiterm.c.

928{
929 PGUI_CONSOLE_DATA GuiData = This->Context;
930 return GuiData->hWindow;
931}

◆ GuiGetDisplayMode()

static ULONG NTAPI GuiGetDisplayMode ( IN OUT PFRONTEND  This)
static

Definition at line 1068 of file guiterm.c.

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}
static VIDEODISPLAYMODE DisplayMode
Definition: pcvideo.c:117
uint32_t ULONG
Definition: typedefs.h:59
#define CONSOLE_FULLSCREEN_HARDWARE
Definition: wincon.h:30
#define CONSOLE_WINDOWED
Definition: wincon.h:28

◆ GuiGetLargestConsoleWindowSize()

static VOID NTAPI GuiGetLargestConsoleWindowSize ( IN OUT PFRONTEND  This,
PCOORD  pSize 
)
static

Definition at line 934 of file guiterm.c.

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}
FORCEINLINE VOID GetScreenBufferSizeUnits(IN PCONSOLE_SCREEN_BUFFER Buffer, IN PGUI_CONSOLE_DATA GuiData, OUT PUINT WidthUnit, OUT PUINT HeightUnit)
Definition: guiterm.h:22
HMONITOR WINAPI MonitorFromWindow(HWND, DWORD)
short SHORT
Definition: pedump.c:59
ULONG Y
Definition: bl.h:1340
ULONG X
Definition: bl.h:1339
PCONSOLE_SCREEN_BUFFER ActiveBuffer
Definition: conwnd.h:92
DWORD cbSize
Definition: winuser.h:3784
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
_In_ HFONT _Out_ PUINT _Out_ PUINT Width
Definition: font.h:89
_In_ HFONT _Out_ PUINT Height
Definition: font.h:88
#define SM_CYEDGE
Definition: winuser.h:1009
#define SM_CXEDGE
Definition: winuser.h:1008
#define SM_CXFRAME
Definition: winuser.h:994
#define SM_CYFRAME
Definition: winuser.h:996
#define SM_CXFULLSCREEN
Definition: winuser.h:977
#define SM_CYFULLSCREEN
Definition: winuser.h:978
BOOL WINAPI GetMonitorInfoW(_In_ HMONITOR, _Inout_ LPMONITORINFO)
#define SM_CYCAPTION
Definition: winuser.h:963
int WINAPI GetSystemMetrics(_In_ int)

◆ GuiGetSelectionInfo()

static BOOL NTAPI GuiGetSelectionInfo ( IN OUT PFRONTEND  This,
PCONSOLE_SELECTION_INFO  pSelectionInfo 
)
static

Definition at line 996 of file guiterm.c.

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}
CONSOLE_SELECTION_INFO Selection
Definition: conwnd.h:93
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define ZeroMemory
Definition: winbase.h:1712
#define CONSOLE_NO_SELECTION
Definition: wincon.h:102

◆ GuiGetThreadConsoleDesktop()

static HDESK NTAPI GuiGetThreadConsoleDesktop ( IN OUT PFRONTEND  This)
static

Definition at line 920 of file guiterm.c.

921{
922 PGUI_CONSOLE_DATA GuiData = This->Context;
923 return GuiData->Desktop;
924}

◆ GuiInit()

static BOOL GuiInit ( IN PCONSOLE_INIT_INFO  ConsoleInitInfo,
IN HANDLE  ConsoleLeaderProcessHandle,
IN OUT PGUI_INIT_INFO  GuiInitInfo 
)
static

Definition at line 284 of file guiterm.c.

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}
BOOLEAN NTAPI CsrImpersonateClient(IN PCSR_THREAD CsrThread)
Definition: procsup.c:932
BOOLEAN NTAPI CsrRevertToSelf(VOID)
Definition: procsup.c:1057
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
Definition: thredsup.c:512
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define ULONG_PTR
Definition: config.h:101
@ Success
Definition: eventcreate.c:712
unsigned int BOOL
Definition: ntddk_ex.h:94
static ULONG NTAPI GuiConsoleInputThread(PVOID Param)
Definition: guiterm.c:105
static BOOL ConsInitialized
Definition: guiterm.c:45
BOOLEAN RegisterConWndClass(IN HINSTANCE hInstance)
Definition: conwnd.c:136
HDESK NTAPI NtUserResolveDesktop(IN HANDLE ProcessHandle, IN PUNICODE_STRING DesktopPath, IN BOOL bInherit, OUT HWINSTA *phWinSta)
Definition: desktop.c:2829
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
if(dx< 0)
Definition: linetemp.h:194
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)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define NtCurrentProcess()
Definition: nt_native.h:1657
#define UNICODE_NULL
@ SynchronizationEvent
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
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
USHORT MaximumLength
Definition: env_spec_w32.h:370
VOID InitTTFontCache(VOID)
Initializes the console TrueType font cache.
Definition: font.c:1013
#define DUPLICATE_SAME_ACCESS

Referenced by GuiLoadFrontEnd().

◆ GuiInitFrontEnd()

static NTSTATUS NTAPI GuiInitFrontEnd ( IN OUT PFRONTEND  This,
IN PCONSRV_CONSOLE  Console 
)
static

/* HACK ‍/ Console->FrontEndIFace.Context = (PVOID)GuiData; / HACK *‍/

Definition at line 480 of file guiterm.c.

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}
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
HCURSOR ghDefaultCursor
Definition: conwnd.c:75
static VOID NTAPI GuiDeinitFrontEnd(IN OUT PFRONTEND This)
Definition: guiterm.c:594
UINT CmdIdHigh
Definition: conwnd.h:80
HANDLE hGuiInitEvent
Definition: conwnd.h:44
BOOL IsCloseButtonEnabled
Definition: conwnd.h:78
BOOL LineSelection
Definition: conwnd.h:95
BOOL HackCORE8394IgnoreNextMove
Definition: conwnd.h:75
BOOL IgnoreNextMouseEvent
Definition: conwnd.h:73
HCURSOR hCursor
Definition: conwnd.h:71
INT MouseCursorRefCount
Definition: conwnd.h:72
COORD dwSelectionCursor
Definition: conwnd.h:94
HICON hIcon
Definition: guiterm.c:39
GUI_CONSOLE_INFO TermInfo
Definition: guiterm.c:42
ULONG_PTR InputThreadId
Definition: guiterm.c:36
HICON hIconSm
Definition: guiterm.c:40
BOOLEAN IsWindowVisible
Definition: guiterm.c:41
HWINSTA WinSta
Definition: guiterm.c:37
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ConsoleAllocHeap(Flags, Size)
Definition: heap.h:14

◆ GuiLoadFrontEnd()

NTSTATUS NTAPI GuiLoadFrontEnd ( IN OUT PFRONTEND  FrontEnd,
IN OUT PCONSOLE_STATE_INFO  ConsoleInfo,
IN OUT PCONSOLE_INIT_INFO  ConsoleInitInfo,
IN HANDLE  ConsoleLeaderProcessHandle 
)

Definition at line 1208 of file guiterm.c.

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}
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 FRONTEND_VTBL GuiVtbl
Definition: guiterm.c:1177
static BOOL GuiInit(IN PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle, IN OUT PGUI_INIT_INFO GuiInitInfo)
Definition: guiterm.c:284
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236
WCHAR FaceName[LF_FACESIZE]
Definition: guisettings.h:18
static CONSOLE_SCREEN_BUFFER_INFO ConsoleInfo
Definition: video.c:47
#define STARTF_USEPOSITION
Definition: winbase.h:493
#define STARTF_USESHOWWINDOW
Definition: winbase.h:491
#define STARTF_RUNFULLSCREEN
Definition: winbase.h:496
#define SW_SHOWNORMAL
Definition: winuser.h:770
#define WSF_VISIBLE
Definition: winuser.h:2452
BOOL WINAPI GetUserObjectInformationW(_In_ HANDLE hObj, _In_ int nIndex, _Out_writes_bytes_opt_(nLength) PVOID pvInfo, _In_ DWORD nLength, _Out_opt_ LPDWORD lpnLengthNeeded)
#define UOI_FLAGS
Definition: winuser.h:1083

◆ GuiMenuControl()

static HMENU NTAPI GuiMenuControl ( IN OUT PFRONTEND  This,
UINT  CmdIdLow,
UINT  CmdIdHigh 
)
static

Definition at line 1145 of file guiterm.c.

1148{
1149 PGUI_CONSOLE_DATA GuiData = This->Context;
1150
1151 GuiData->CmdIdLow = CmdIdLow ;
1152 GuiData->CmdIdHigh = CmdIdHigh;
1153
1154 return GuiData->hSysMenu;
1155}
HMENU hSysMenu
Definition: conwnd.h:77

◆ GuiRefreshInternalInfo()

static VOID NTAPI GuiRefreshInternalInfo ( IN OUT PFRONTEND  This)
static

Definition at line 848 of file guiterm.c.

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}
static BOOL NTAPI GuiSetMouseCursor(IN OUT PFRONTEND This, HCURSOR CursorHandle)
Definition: guiterm.c:1124
VOID SetConWndConsoleLeaderCID(IN PGUI_CONSOLE_DATA GuiData)
Definition: conwnd.c:48

◆ GuiReleaseScreenBuffer()

static VOID NTAPI GuiReleaseScreenBuffer ( IN OUT PFRONTEND  This,
IN PCONSOLE_SCREEN_BUFFER  ScreenBuffer 
)
static

Definition at line 800 of file guiterm.c.

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}
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
static VOID NTAPI GuiSetActiveScreenBuffer(IN OUT PFRONTEND This)
Definition: guiterm.c:761
HANDLE ScreenBuffer
Definition: notevil.c:37
#define OBJ_PAL
Definition: objidl.idl:1413
BOOL WindowSizeLock
Definition: conwnd.h:43
HPALETTE hSysPalette
Definition: conwnd.h:65
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
HPALETTE WINAPI SelectPalette(_In_ HDC, _In_ HPALETTE, _In_ BOOL)
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC, _In_ UINT)
Definition: dc.c:428

◆ GuiResizeTerminal()

static VOID NTAPI GuiResizeTerminal ( IN OUT PFRONTEND  This)
static

Definition at line 752 of file guiterm.c.

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}

Referenced by GuiSetActiveScreenBuffer().

◆ GuiRingBell()

VOID NTAPI GuiRingBell ( IN OUT PFRONTEND  This)

Definition at line 704 of file guiterm.c.

705{
706 PGUI_CONSOLE_DATA GuiData = This->Context;
707
708 /* Emit an error beep sound */
710}
#define PM_CONSOLE_BEEP
Definition: conwnd.h:21
#define SendNotifyMessage
Definition: winuser.h:5846

◆ GuiSetActiveScreenBuffer()

static VOID NTAPI GuiSetActiveScreenBuffer ( IN OUT PFRONTEND  This)
static

Definition at line 761 of file guiterm.c.

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}
PCONSOLE_SCREEN_BUFFER ConDrvGetActiveScreenBuffer(IN PCONSOLE Console)
Definition: conoutput.c:201
static VOID NTAPI GuiResizeTerminal(IN OUT PFRONTEND This)
Definition: guiterm.c:752
HPALETTE PaletteHandle
Definition: conio.h:78
UINT WINAPI RealizePalette(_In_ HDC)
Definition: palette.c:138
UINT WINAPI SetSystemPaletteUse(_In_ HDC, _In_ UINT)

Referenced by GuiReleaseScreenBuffer().

◆ GuiSetCodePage()

static BOOL NTAPI GuiSetCodePage ( IN OUT PFRONTEND  This,
UINT  CodePage 
)
static

Definition at line 1038 of file guiterm.c.

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}
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

◆ GuiSetCursorInfo()

static BOOL NTAPI GuiSetCursorInfo ( IN OUT PFRONTEND  This,
PCONSOLE_SCREEN_BUFFER  Buff 
)
static

Definition at line 713 of file guiterm.c.

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}
VOID InvalidateCell(PGUI_CONSOLE_DATA GuiData, SHORT x, SHORT y)
Definition: guiterm.c:88
COORD CursorPosition
Definition: conio.h:71

◆ GuiSetDisplayMode()

static BOOL NTAPI GuiSetDisplayMode ( IN OUT PFRONTEND  This,
ULONG  NewMode 
)
static

Definition at line 1082 of file guiterm.c.

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}
#define CONSOLE_FULLSCREEN_MODE
Definition: wincon.h:33
#define CONSOLE_WINDOWED_MODE
Definition: wincon.h:34

◆ GuiSetMenuClose()

static BOOL NTAPI GuiSetMenuClose ( IN OUT PFRONTEND  This,
BOOL  Enable 
)
static

Definition at line 1158 of file guiterm.c.

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}
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:142
#define MF_BYCOMMAND
Definition: winuser.h:202
#define MF_ENABLED
Definition: winuser.h:128
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define MF_GRAYED
Definition: winuser.h:129

◆ GuiSetMouseCursor()

static BOOL NTAPI GuiSetMouseCursor ( IN OUT PFRONTEND  This,
HCURSOR  CursorHandle 
)
static

Definition at line 1124 of file guiterm.c.

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}
#define WM_SETCURSOR
Definition: winuser.h:1636

Referenced by GuiRefreshInternalInfo().

◆ GuiSetPalette()

static BOOL NTAPI GuiSetPalette ( IN OUT PFRONTEND  This,
HPALETTE  PaletteHandle,
UINT  PaletteUsage 
)
static

Definition at line 1011 of file guiterm.c.

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}
static HPALETTE PaletteHandle
Definition: svga.c:215

◆ GuiSetScreenInfo()

static BOOL NTAPI GuiSetScreenInfo ( IN OUT PFRONTEND  This,
PCONSOLE_SCREEN_BUFFER  Buff,
SHORT  OldCursorX,
SHORT  OldCursorY 
)
static

Definition at line 730 of file guiterm.c.

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}

◆ GuiShowMouseCursor()

static INT NTAPI GuiShowMouseCursor ( IN OUT PFRONTEND  This,
BOOL  Show 
)
static

Definition at line 1105 of file guiterm.c.

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}

◆ GuiUnloadFrontEnd()

NTSTATUS NTAPI GuiUnloadFrontEnd ( IN OUT PFRONTEND  FrontEnd)

Definition at line 1338 of file guiterm.c.

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}

◆ GuiWriteStream()

static VOID NTAPI GuiWriteStream ( IN OUT PFRONTEND  This,
SMALL_RECT Region,
SHORT  CursorStartX,
SHORT  CursorStartY,
UINT  ScrolledLines,
PWCHAR  Buffer,
UINT  Length 
)
static

Definition at line 641 of file guiterm.c.

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}
static LPHIST_ENTRY Top
Definition: history.c:53
#define CONGUI_UPDATE_TIME
Definition: guiterm.c:24
#define CONGUI_UPDATE_TIMER
Definition: guiterm.c:25
#define TEXTMODE_BUFFER
Definition: pccons.c:21
BOOLEAN CursorBlinkOn
Definition: conio.h:72
UINT CharWidth
Definition: conwnd.h:87
UINT CharHeight
Definition: conwnd.h:88
#define GetType(This)
Definition: conio.h:54
#define SW_INVALIDATE
Definition: winuser.h:2579
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
int WINAPI ScrollWindowEx(_In_ HWND, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT, _In_ UINT)

◆ InvalidateCell()

VOID InvalidateCell ( PGUI_CONSOLE_DATA  GuiData,
SHORT  x,
SHORT  y 
)

Definition at line 88 of file guiterm.c.

90{
91 SMALL_RECT CellRect = { x, y, x, y };
92 DrawRegion(GuiData, &CellRect);
93}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548

Referenced by GuiSetCursorInfo(), GuiSetScreenInfo(), GuiWriteStream(), and OnTimer().

◆ RegisterConWndClass()

BOOLEAN RegisterConWndClass ( IN HINSTANCE  hInstance)

Definition at line 136 of file conwnd.c.

137{
139 ATOM WndClassAtom;
140
146 LR_SHARED);
152 LR_SHARED);
154
155 WndClass.cbSize = sizeof(WNDCLASSEXW);
156 WndClass.lpszClassName = GUI_CONWND_CLASS;
157 WndClass.lpfnWndProc = ConWndProc;
158 WndClass.style = CS_DBLCLKS /* | CS_HREDRAW | CS_VREDRAW */;
159 WndClass.hInstance = hInstance;
160 WndClass.hIcon = ghDefaultIcon;
161 WndClass.hIconSm = ghDefaultIconSm;
162 WndClass.hCursor = ghDefaultCursor;
163 WndClass.hbrBackground = NULL;
164 WndClass.lpszMenuName = NULL;
165 WndClass.cbClsExtra = 0;
166 WndClass.cbWndExtra = GWLP_CONWND_ALLOC;
167
168 WndClassAtom = RegisterClassExW(&WndClass);
169 if (WndClassAtom == 0)
170 {
171 DPRINT1("Failed to register GUI console class\n");
172 }
173 else
174 {
175 NtUserConsoleControl(GuiConsoleWndClassAtom, &WndClassAtom, sizeof(ATOM));
176 }
177
178 return (WndClassAtom != 0);
179}
#define IDI_TERMINAL
Definition: resource.h:44
WCHAR WndClass[]
Definition: capicon.c:23
HINSTANCE hInstance
Definition: charmap.c:19
HCURSOR ghDefaultCursor
Definition: conwnd.c:75
static LRESULT CALLBACK ConWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
Definition: conwnd.c:2278
HICON ghDefaultIcon
Definition: conwnd.c:73
#define GWLP_CONWND_ALLOC
Definition: conwnd.c:43
HICON ghDefaultIconSm
Definition: conwnd.c:74
WORD ATOM
Definition: dimm.idl:113
@ GuiConsoleWndClassAtom
Definition: ntuser.h:1799
#define IMAGE_ICON
Definition: winuser.h:212
HANDLE WINAPI LoadImageW(_In_opt_ HINSTANCE hInst, _In_ LPCWSTR name, _In_ UINT type, _In_ int cx, _In_ int cy, _In_ UINT fuLoad)
Definition: cursoricon.c:2234
#define IDC_ARROW
Definition: winuser.h:687
#define SM_CYSMICON
Definition: winuser.h:1013
#define CS_DBLCLKS
Definition: winuser.h:651
HCURSOR WINAPI LoadCursorW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2136
#define SM_CXSMICON
Definition: winuser.h:1012
#define SM_CYICON
Definition: winuser.h:973
ATOM WINAPI RegisterClassExW(_In_ CONST WNDCLASSEXW *)
#define LR_SHARED
Definition: winuser.h:1100
struct _WNDCLASSEXW WNDCLASSEXW
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define SM_CXICON
Definition: winuser.h:972

Referenced by GuiInit().

◆ SetConWndConsoleLeaderCID()

VOID SetConWndConsoleLeaderCID ( IN PGUI_CONSOLE_DATA  GuiData)

Definition at line 48 of file conwnd.c.

49{
50 PCONSOLE_PROCESS_DATA ProcessData;
51
52 ProcessData = ConSrvGetConsoleLeaderProcess(GuiData->Console);
53
54 ASSERT(ProcessData != NULL);
55 DPRINT("ProcessData: %p, ProcessData->Process %p.\n", ProcessData, ProcessData->Process);
56
57 if (ProcessData->Process)
58 {
59 CLIENT_ID ConsoleLeaderCID = ProcessData->Process->ClientId;
61 (LONG_PTR)(ConsoleLeaderCID.UniqueProcess));
63 (LONG_PTR)(ConsoleLeaderCID.UniqueThread));
64 }
65 else
66 {
67 SetWindowLongPtrW(GuiData->hWindow, GWLP_CONSOLE_LEADER_PID, 0);
68 SetWindowLongPtrW(GuiData->hWindow, GWLP_CONSOLE_LEADER_TID, 0);
69 }
70}
#define GWLP_CONSOLE_LEADER_PID
Definition: conwnd.c:44
#define GWLP_CONSOLE_LEADER_TID
Definition: conwnd.c:45
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
HANDLE UniqueProcess
Definition: compat.h:825
PCSR_PROCESS Process
Definition: consrv.h:43
CLIENT_ID ClientId
Definition: csrsrv.h:38
PCONSOLE_PROCESS_DATA NTAPI ConSrvGetConsoleLeaderProcess(IN PCONSRV_CONSOLE Console)
Definition: console.c:1363
#define SetWindowLongPtrW
Definition: winuser.h:5346

Referenced by GuiRefreshInternalInfo().

◆ UnRegisterConWndClass()

BOOLEAN UnRegisterConWndClass ( HINSTANCE  hInstance)

Definition at line 182 of file conwnd.c.

183{
185}
BOOL WINAPI UnregisterClassW(_In_ LPCWSTR, HINSTANCE)

Variable Documentation

◆ ConsInitialized

BOOL ConsInitialized = FALSE
static

Definition at line 45 of file guiterm.c.

Referenced by GuiInit().

◆ ghDefaultCursor

HCURSOR ghDefaultCursor
extern

Definition at line 75 of file conwnd.c.

Referenced by GuiInitFrontEnd(), GuiSetMouseCursor(), and RegisterConWndClass().

◆ ghDefaultIcon

HICON ghDefaultIcon
extern

◆ ghDefaultIconSm

HICON ghDefaultIconSm
extern

Definition at line 74 of file conwnd.c.

Referenced by GuiChangeIcon(), GuiDeinitFrontEnd(), GuiInitFrontEnd(), and RegisterConWndClass().

◆ GuiVtbl

FRONTEND_VTBL GuiVtbl
static
Initial value:
=
{
}
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
static BOOL NTAPI GuiSetCodePage(IN OUT PFRONTEND This, UINT CodePage)
Definition: guiterm.c:1038
static ULONG NTAPI GuiGetDisplayMode(IN OUT PFRONTEND This)
Definition: guiterm.c:1068
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
static BOOL NTAPI GuiChangeIcon(IN OUT PFRONTEND This, HICON IconHandle)
Definition: guiterm.c:877
static VOID NTAPI GuiDrawRegion(IN OUT PFRONTEND This, SMALL_RECT *Region)
Definition: guiterm.c:629
static HMENU NTAPI GuiMenuControl(IN OUT PFRONTEND This, UINT CmdIdLow, UINT CmdIdHigh)
Definition: guiterm.c:1145
static INT NTAPI GuiShowMouseCursor(IN OUT PFRONTEND This, BOOL Show)
Definition: guiterm.c:1105
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 NTAPI GuiSetPalette(IN OUT PFRONTEND This, HPALETTE PaletteHandle, UINT PaletteUsage)
Definition: guiterm.c:1011
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
static HWND NTAPI GuiGetConsoleWindowHandle(IN OUT PFRONTEND This)
Definition: guiterm.c:927
static VOID NTAPI GuiRefreshInternalInfo(IN OUT PFRONTEND This)
Definition: guiterm.c:848

Definition at line 1177 of file guiterm.c.

Referenced by GuiLoadFrontEnd().