ReactOS  0.4.14-dev-57-g333b8f1
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 
33 typedef struct _GUI_INIT_INFO
34 {
37  HWINSTA WinSta;
38  HDESK Desktop;
44 
46 
47 extern HICON ghDefaultIcon;
48 extern HICON ghDefaultIconSm;
50 
51 VOID
53 BOOLEAN
55 BOOLEAN
57 
58 /* FUNCTIONS ******************************************************************/
59 
60 VOID
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 
75 static 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 
87 VOID
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.
101 VOID
103 
104 static ULONG NTAPI
106 {
108  PCSR_THREAD pcsrt = NULL;
109  PGUI_INIT_INFO GuiInitInfo = (PGUI_INIT_INFO)Param;
110  DESKTOP_CONSOLE_THREAD DesktopConsoleThreadInfo;
112  HANDLE hThread = NULL;
113 
114  LONG WindowCount = 0;
115  MSG msg;
116 
117  /*
118  * This thread dispatches all the console notifications to the
119  * notification window. It is common for all the console windows
120  * in a given desktop in a window station.
121  */
122 
123  /* Assign this console input thread to this desktop */
124  DesktopConsoleThreadInfo.DesktopHandle = GuiInitInfo->Desktop; // Duplicated desktop handle
125  DesktopConsoleThreadInfo.ThreadId = InputThreadId;
127  &DesktopConsoleThreadInfo,
128  sizeof(DesktopConsoleThreadInfo));
129  if (!NT_SUCCESS(Status)) goto Quit;
130 
131  /* Connect this CSR thread to the USER subsystem */
132  pcsrt = CsrConnectToUser();
133  if (pcsrt == NULL) goto Quit;
134  hThread = pcsrt->ThreadHandle;
135 
136  /* Assign the desktop to this thread */
137  if (!SetThreadDesktop(DesktopConsoleThreadInfo.DesktopHandle)) goto Quit;
138 
139  /* The thread has been initialized, set the event */
140  NtSetEvent(GuiInitInfo->GuiThreadStartupEvent, NULL);
142 
143  while (GetMessageW(&msg, NULL, 0, 0))
144  {
145  switch (msg.message)
146  {
147  case PM_CREATE_CONSOLE:
148  {
149  PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam;
150  PCONSRV_CONSOLE Console = GuiData->Console;
151  HWND NewWindow;
152  RECT rcWnd;
153 
154  DPRINT("PM_CREATE_CONSOLE -- creating window\n");
155 
156  NewWindow = CreateWindowExW(WS_EX_CLIENTEDGE,
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 
217  case PM_DESTROY_CONSOLE:
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 
255 Quit:
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 
274  CsrDereferenceThread(pcsrt);
275  }
276 
277  /* Exit the thread */
279  return 0;
280 }
281 
282 // FIXME: Maybe return a NTSTATUS
283 static BOOL
284 GuiInit(IN PCONSOLE_INIT_INFO ConsoleInitInfo,
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 fonts cache */
305  InitTTFontCache();
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 
337  CsrRevertToSelf();
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,
396  0, 0, DUPLICATE_SAME_ACCESS);
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 
456 Quit:
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 
476 static VOID NTAPI
478 
479 static 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 
509  InitializeCriticalSection(&GuiData->Lock);
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 signals */
534  GuiData->IgnoreNextMouseSignal = 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 */
577  NtWaitForSingleObject(GuiData->hGuiInitEvent, FALSE, NULL);
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 
593 static VOID NTAPI
595 {
596  PGUI_CONSOLE_DATA GuiData = This->Context;
597 
598  DPRINT("Send PM_DESTROY_CONSOLE message and wait on hGuiTermEvent...\n");
600  NtWaitForSingleObject(GuiData->hGuiTermEvent, FALSE, NULL);
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 
628 static 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 
640 static VOID NTAPI
643  SHORT CursorStartX,
644  SHORT CursorStartY,
645  UINT ScrolledLines,
646  PWCHAR Buffer,
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,
676  SW_INVALIDATE);
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 */
709  SendNotifyMessage(GuiData->hWindow, PM_CONSOLE_BEEP, 0, 0);
710 }
711 
712 static 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 
729 static 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 
751 static 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 
760 static 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 
799 static 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 
843 static BOOL NTAPI
845  HCURSOR CursorHandle);
846 
847 static VOID NTAPI
849 {
850  PGUI_CONSOLE_DATA GuiData = This->Context;
851 
852  /* Update the console leader information held by the window */
853  SetConWndConsoleLeaderCID(GuiData);
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 
869 static VOID NTAPI
871 {
872  PGUI_CONSOLE_DATA GuiData = This->Context;
873  PostMessageW(GuiData->hWindow, PM_CONSOLE_SET_TITLE, 0, 0);
874 }
875 
876 static 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 
919 static HDESK NTAPI
921 {
922  PGUI_CONSOLE_DATA GuiData = This->Context;
923  return GuiData->Desktop;
924 }
925 
926 static HWND NTAPI
928 {
929  PGUI_CONSOLE_DATA GuiData = This->Context;
930  return GuiData->hWindow;
931 }
932 
933 static VOID NTAPI
935  PCOORD pSize)
936 {
937  PGUI_CONSOLE_DATA GuiData = This->Context;
938  PCONSOLE_SCREEN_BUFFER ActiveBuffer;
939  HMONITOR hMonitor;
940  MONITORINFO MonitorInfo;
941  LONG Width, Height;
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 
995 static 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 
1010 static 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 
1037 static ULONG NTAPI
1039 {
1040  PGUI_CONSOLE_DATA GuiData = This->Context;
1041  ULONG DisplayMode = 0;
1042 
1043  if (GuiData->GuiInfo.FullScreen)
1044  DisplayMode |= CONSOLE_FULLSCREEN_HARDWARE; // CONSOLE_FULLSCREEN
1045  else
1047 
1048  return DisplayMode;
1049 }
1050 
1051 static BOOL NTAPI
1053  ULONG NewMode)
1054 {
1055  PGUI_CONSOLE_DATA GuiData = This->Context;
1056  BOOL FullScreen;
1057 
1059  return FALSE;
1060 
1061  /* Do nothing if the window is hidden */
1062  if (!GuiData->IsWindowVisible) return TRUE;
1063 
1064  FullScreen = ((NewMode & CONSOLE_FULLSCREEN_MODE) != 0);
1065 
1066  if (FullScreen != GuiData->GuiInfo.FullScreen)
1067  {
1068  SwitchFullScreen(GuiData, FullScreen);
1069  }
1070 
1071  return TRUE;
1072 }
1073 
1074 static INT NTAPI
1076  BOOL Show)
1077 {
1078  PGUI_CONSOLE_DATA GuiData = This->Context;
1079 
1080  if (GuiData->IsWindowVisible)
1081  {
1082  /* Set the reference count */
1083  if (Show) ++GuiData->MouseCursorRefCount;
1084  else --GuiData->MouseCursorRefCount;
1085 
1086  /* Effectively show (or hide) the cursor (use special values for (w|l)Param) */
1087  PostMessageW(GuiData->hWindow, WM_SETCURSOR, -1, -1);
1088  }
1089 
1090  return GuiData->MouseCursorRefCount;
1091 }
1092 
1093 static BOOL NTAPI
1095  HCURSOR CursorHandle)
1096 {
1097  PGUI_CONSOLE_DATA GuiData = This->Context;
1098 
1099  /* Do nothing if the window is hidden */
1100  if (!GuiData->IsWindowVisible) return TRUE;
1101 
1102  /*
1103  * Set the cursor's handle. If the given handle is NULL,
1104  * then restore the default cursor.
1105  */
1106  GuiData->hCursor = (CursorHandle ? CursorHandle : ghDefaultCursor);
1107 
1108  /* Effectively modify the shape of the cursor (use special values for (w|l)Param) */
1109  PostMessageW(GuiData->hWindow, WM_SETCURSOR, -1, -1);
1110 
1111  return TRUE;
1112 }
1113 
1114 static HMENU NTAPI
1116  UINT CmdIdLow,
1117  UINT CmdIdHigh)
1118 {
1119  PGUI_CONSOLE_DATA GuiData = This->Context;
1120 
1121  GuiData->CmdIdLow = CmdIdLow ;
1122  GuiData->CmdIdHigh = CmdIdHigh;
1123 
1124  return GuiData->hSysMenu;
1125 }
1126 
1127 static BOOL NTAPI
1129  BOOL Enable)
1130 {
1131  /*
1132  * NOTE: See http://www.mail-archive.com/harbour@harbour-project.org/msg27509.html
1133  * or http://harbour-devel.1590103.n2.nabble.com/Question-about-hb-gt-win-CtrlHandler-usage-td4670862i20.html
1134  * for more information.
1135  */
1136 
1137  PGUI_CONSOLE_DATA GuiData = This->Context;
1138 
1139  if (GuiData->hSysMenu == NULL) return FALSE;
1140 
1141  GuiData->IsCloseButtonEnabled = Enable;
1143 
1144  return TRUE;
1145 }
1146 
1148 {
1151  GuiDrawRegion,
1153  GuiRingBell,
1161  GuiChangeIcon,
1166  GuiSetPalette,
1173 };
1174 
1175 
1179  IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
1180  IN HANDLE ConsoleLeaderProcessHandle)
1181 {
1182  PCONSOLE_START_INFO ConsoleStartInfo;
1183  PGUI_INIT_INFO GuiInitInfo;
1184  USEROBJECTFLAGS UserObjectFlags;
1185 
1186  if (FrontEnd == NULL || ConsoleInfo == NULL || ConsoleInitInfo == NULL)
1187  return STATUS_INVALID_PARAMETER;
1188 
1189  ConsoleStartInfo = ConsoleInitInfo->ConsoleStartInfo;
1190 
1191  /*
1192  * Initialize a private initialization info structure for later use.
1193  * It must be freed by a call to GuiUnloadFrontEnd or GuiInitFrontEnd.
1194  */
1195  GuiInitInfo = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*GuiInitInfo));
1196  if (GuiInitInfo == NULL) return STATUS_NO_MEMORY;
1197 
1198  /* Initialize GUI terminal emulator common functionalities */
1199  if (!GuiInit(ConsoleInitInfo, ConsoleLeaderProcessHandle, GuiInitInfo))
1200  {
1201  ConsoleFreeHeap(GuiInitInfo);
1202  return STATUS_UNSUCCESSFUL;
1203  }
1204 
1205  GuiInitInfo->IsWindowVisible = ConsoleInitInfo->IsWindowVisible;
1206  if (GuiInitInfo->IsWindowVisible)
1207  {
1208  /* Don't show the console if the window station is not interactive */
1209  if (GetUserObjectInformationW(GuiInitInfo->WinSta,
1210  UOI_FLAGS,
1211  &UserObjectFlags,
1212  sizeof(UserObjectFlags),
1213  NULL))
1214  {
1215  if (!(UserObjectFlags.dwFlags & WSF_VISIBLE))
1216  GuiInitInfo->IsWindowVisible = FALSE;
1217  }
1218  }
1219 
1220  /*
1221  * Load terminal settings
1222  */
1223 #if 0
1224  /* Impersonate the caller in order to retrieve settings in its context */
1225  // if (!CsrImpersonateClient(NULL))
1226  // return STATUS_UNSUCCESSFUL;
1228 
1229  /* 1. Load the default settings */
1230  GuiConsoleGetDefaultSettings(&GuiInitInfo->TermInfo);
1231 #endif
1232 
1233  GuiInitInfo->TermInfo.ShowWindow = SW_SHOWNORMAL;
1234 
1235  if (GuiInitInfo->IsWindowVisible)
1236  {
1237  /* 2. Load the remaining console settings via the registry */
1238  if ((ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
1239  {
1240 #if 0
1241  /* Load the terminal infos from the registry */
1242  GuiConsoleReadUserSettings(&GuiInitInfo->TermInfo);
1243 #endif
1244 
1245  /*
1246  * Now, update them with the properties the user might gave to us
1247  * via the STARTUPINFO structure before calling CreateProcess
1248  * (and which was transmitted via the ConsoleStartInfo structure).
1249  * We therefore overwrite the values read in the registry.
1250  */
1251  if (ConsoleStartInfo->dwStartupFlags & STARTF_USESHOWWINDOW)
1252  {
1253  GuiInitInfo->TermInfo.ShowWindow = ConsoleStartInfo->wShowWindow;
1254  }
1255  if (ConsoleStartInfo->dwStartupFlags & STARTF_USEPOSITION)
1256  {
1257  ConsoleInfo->AutoPosition = FALSE;
1258  ConsoleInfo->WindowPosition.x = ConsoleStartInfo->dwWindowOrigin.X;
1259  ConsoleInfo->WindowPosition.y = ConsoleStartInfo->dwWindowOrigin.Y;
1260  }
1261  if (ConsoleStartInfo->dwStartupFlags & STARTF_RUNFULLSCREEN)
1262  {
1263  ConsoleInfo->FullScreen = TRUE;
1264  }
1265  }
1266  }
1267 
1268 #if 0
1269  /* Revert impersonation */
1270  CsrRevertToSelf();
1271 #endif
1272 
1273  // Font data
1274  StringCchCopyNW(GuiInitInfo->TermInfo.FaceName, ARRAYSIZE(GuiInitInfo->TermInfo.FaceName),
1275  ConsoleInfo->FaceName, ARRAYSIZE(ConsoleInfo->FaceName));
1276  GuiInitInfo->TermInfo.FontFamily = ConsoleInfo->FontFamily;
1277  GuiInitInfo->TermInfo.FontSize = ConsoleInfo->FontSize;
1278  GuiInitInfo->TermInfo.FontWeight = ConsoleInfo->FontWeight;
1279 
1280  // Display
1281  GuiInitInfo->TermInfo.FullScreen = ConsoleInfo->FullScreen;
1282  GuiInitInfo->TermInfo.AutoPosition = ConsoleInfo->AutoPosition;
1283  GuiInitInfo->TermInfo.WindowOrigin = ConsoleInfo->WindowPosition;
1284 
1285  /* Initialize the icon handles */
1286  // if (ConsoleStartInfo->hIcon != NULL)
1287  GuiInitInfo->hIcon = ConsoleStartInfo->hIcon;
1288  // else
1289  // GuiInitInfo->hIcon = ghDefaultIcon;
1290 
1291  // if (ConsoleStartInfo->hIconSm != NULL)
1292  GuiInitInfo->hIconSm = ConsoleStartInfo->hIconSm;
1293  // else
1294  // GuiInitInfo->hIconSm = ghDefaultIconSm;
1295 
1296  // ASSERT(GuiInitInfo->hIcon && GuiInitInfo->hIconSm);
1297 
1298  /* Finally, initialize the frontend structure */
1299  FrontEnd->Vtbl = &GuiVtbl;
1300  FrontEnd->Context = NULL;
1301  FrontEnd->Context2 = GuiInitInfo;
1302 
1303  return STATUS_SUCCESS;
1304 }
1305 
1308 {
1309  if (FrontEnd == NULL) return STATUS_INVALID_PARAMETER;
1310 
1311  if (FrontEnd->Context ) GuiDeinitFrontEnd(FrontEnd);
1312  if (FrontEnd->Context2) ConsoleFreeHeap(FrontEnd->Context2);
1313 
1314  return STATUS_SUCCESS;
1315 }
1316 
1317 /* EOF */
static BOOL NTAPI GuiSetMouseCursor(IN OUT PFRONTEND This, HCURSOR CursorHandle)
Definition: guiterm.c:1094
COORD dwSelectionCursor
Definition: conwnd.h:93
HICON ghDefaultIcon
Definition: conwnd.c:62
HANDLE hGuiTermEvent
Definition: conwnd.h:45
static BOOL NTAPI GuiSetCursorInfo(IN OUT PFRONTEND This, PCONSOLE_SCREEN_BUFFER Buff)
Definition: guiterm.c:713
VOID CreateSysMenu(HWND hWnd)
Definition: conwnd.c:231
#define IN
Definition: typedefs.h:38
#define STARTF_RUNFULLSCREEN
Definition: winbase.h:477
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236
BOOL WINAPI TranslateMessage(_In_ const MSG *)
static HICON
Definition: imagelist.c:84
#define CONSOLE_WINDOWED_MODE
Definition: wincon.h:34
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
FORCEINLINE VOID SmallRectToRect(PGUI_CONSOLE_DATA GuiData, PRECT Rect, PSMALL_RECT SmallRect)
Definition: guiterm.h:43
BOOL WINAPI GetUserObjectInformationW(_In_ HANDLE hObj, _In_ int nIndex, _Out_writes_bytes_opt_(nLength) PVOID pvInfo, _In_ DWORD nLength, _Out_opt_ LPDWORD lpnLengthNeeded)
INT MouseCursorRefCount
Definition: conwnd.h:71
HANDLE hGuiInitEvent
Definition: conwnd.h:44
BOOL IsCloseButtonEnabled
Definition: conwnd.h:77
#define MF_BYCOMMAND
Definition: winuser.h:202
UINT WINAPI SetSystemPaletteUse(_In_ HDC, _In_ UINT)
long y
Definition: polytest.cpp:48
HICON hIcon
Definition: guiterm.c:39
PCONSOLE_SCREEN_BUFFER ConDrvGetActiveScreenBuffer(IN PCONSOLE Console)
Definition: conoutput.c:194
VOID SetConWndConsoleLeaderCID(IN PGUI_CONSOLE_DATA GuiData)
Definition: conwnd.c:48
BOOLEAN CursorBlinkOn
Definition: conio.h:99
#define PM_DESTROY_CONSOLE
Definition: guiterm.c:28
static HDESK NTAPI GuiGetThreadConsoleDesktop(IN OUT PFRONTEND This)
Definition: guiterm.c:920
USHORT MaximumLength
Definition: env_spec_w32.h:370
long x
Definition: polytest.cpp:48
NTSYSAPI VOID NTAPI RtlExitUserThread(_In_ NTSTATUS Status)
static VOID NTAPI GuiSetActiveScreenBuffer(IN OUT PFRONTEND This)
Definition: guiterm.c:761
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2022
#define CONSOLE_FULLSCREEN_HARDWARE
Definition: wincon.h:30
static BOOL NTAPI GuiSetDisplayMode(IN OUT PFRONTEND This, ULONG NewMode)
Definition: guiterm.c:1052
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
HWINSTA WinSta
Definition: conwnd.h:49
#define SW_HIDE
Definition: winuser.h:762
struct _GUI_CONSOLE_DATA * PGUI_CONSOLE_DATA
static VOID NTAPI GuiResizeTerminal(IN OUT PFRONTEND This)
Definition: guiterm.c:752
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1827
LONG NTSTATUS
Definition: precomp.h:26
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:140
#define HandleToUlong(h)
Definition: basetsd.h:79
COORD CursorPosition
Definition: conio.h:98
HWND hWnd
Definition: settings.c:17
#define ConsoleAllocHeap(Flags, Size)
Definition: heap.h:14
BOOLEAN NTAPI CsrRevertToSelf(VOID)
Definition: procsup.c:1048
LONG top
Definition: windef.h:292
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:100
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
HDESK Desktop
Definition: guiterm.c:38
#define STARTF_USEPOSITION
Definition: winbase.h:474
#define ZeroMemory
Definition: winbase.h:1635
#define SM_CXEDGE
Definition: winuser.h:998
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define CONSOLE_NO_SELECTION
Definition: wincon.h:96
static UINT WindowCount
Definition: multiwin.c:4
BOOL IgnoreNextMouseSignal
Definition: conwnd.h:72
HICON ghDefaultIconSm
Definition: conwnd.c:63
#define HWND_MESSAGE
Definition: winuser.h:1196
VOID NTAPI CsrDereferenceThread(IN PCSR_THREAD CsrThread)
Definition: thredsup.c:775
CONSOLE_SELECTION_INFO Selection
Definition: conwnd.h:92
uint16_t * PWCHAR
Definition: typedefs.h:54
static HPALETTE PaletteHandle
Definition: svga.c:215
LONG left
Definition: windef.h:291
#define SWP_NOZORDER
Definition: winuser.h:1232
HICON HCURSOR
Definition: windef.h:284
#define SM_CYFRAME
Definition: winuser.h:986
#define TEXTMODE_BUFFER
Definition: pccons.c:21
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
BOOLEAN IsWindowVisible
Definition: guiterm.c:41
#define SM_CXFRAME
Definition: winuser.h:984
#define PCONSRV_CONSOLE
Definition: conio.h:27
VOID NTAPI GuiRingBell(IN OUT PFRONTEND This)
Definition: guiterm.c:704
#define PM_CONSOLE_SET_TITLE
Definition: guiterm.c:44
LONG right
Definition: windef.h:293
BOOL WINAPI DestroyWindow(_In_ HWND)
#define PM_CREATE_CONSOLE
Definition: guiterm.c:27
int32_t INT
Definition: typedefs.h:56
static HMENU NTAPI GuiMenuControl(IN OUT PFRONTEND This, UINT CmdIdLow, UINT CmdIdHigh)
Definition: guiterm.c:1115
struct _GUI_INIT_INFO GUI_INIT_INFO
static BOOL NTAPI GuiChangeIcon(IN OUT PFRONTEND This, HICON IconHandle)
Definition: guiterm.c:877
VOID InitTTFontCache(VOID)
Definition: font.c:391
HICON hIconSm
Definition: guiterm.c:40
#define ICON_SMALL
Definition: tnclass.cpp:48
BOOL WINAPI SetThreadDesktop(_In_ HDESK)
uint32_t ULONG_PTR
Definition: typedefs.h:63
BOOL WindowSizeLock
Definition: conwnd.h:43
UINT CharHeight
Definition: conwnd.h:87
static VOID DrawRegion(PGUI_CONSOLE_DATA GuiData, SMALL_RECT *Region)
Definition: guiterm.c:76
HPALETTE PaletteHandle
Definition: conio.h:105
static BOOL NTAPI GuiGetSelectionInfo(IN OUT PFRONTEND This, PCONSOLE_SELECTION_INFO pSelectionInfo)
Definition: guiterm.c:996
while(1)
Definition: macro.lex.yy.c:740
ULONG_PTR InputThreadId
Definition: guiterm.c:36
HINSTANCE hInstance
Definition: charmap.c:20
BOOL WINAPI ShowWindowAsync(_In_ HWND, _In_ int)
HDESK Desktop
Definition: conwnd.h:50
PCSR_THREAD NTAPI CsrAddStaticServerThread(IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
Definition: thredsup.c:511
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define DUPLICATE_SAME_ACCESS
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define UNICODE_NULL
GUI_CONSOLE_INFO TermInfo
Definition: guiterm.c:42
LRESULT WINAPI DispatchMessageW(_In_ const MSG *)
BOOL HackCORE8394IgnoreNextMove
Definition: conwnd.h:74
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
HWINSTA WinSta
Definition: guiterm.c:37
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
#define WM_SETCURSOR
Definition: winuser.h:1618
short SHORT
Definition: pedump.c:59
static ULONG NTAPI GuiGetDisplayMode(IN OUT PFRONTEND This)
Definition: guiterm.c:1038
HICON hIconSm
Definition: conwnd.h:67
#define CONGUI_UPDATE_TIMER
Definition: guiterm.c:25
NTSTATUS APIENTRY NtUserConsoleControl(IN CONSOLECONTROL ConsoleCtrl, IN PVOID ConsoleCtrlInfo, IN ULONG ConsoleCtrlInfoLength)
Definition: console.c:14
#define CW_USEDEFAULT
Definition: winuser.h:225
PCONSOLE_SCREEN_BUFFER ActiveBuffer
Definition: conwnd.h:91
VOID InvalidateCell(PGUI_CONSOLE_DATA GuiData, SHORT x, SHORT y)
Definition: guiterm.c:88
unsigned char BOOLEAN
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
HPALETTE WINAPI SelectPalette(_In_ HDC, _In_ HPALETTE, _In_ BOOL)
smooth NULL
Definition: ftsmooth.c:416
HDESK NTAPI NtUserResolveDesktop(IN HANDLE ProcessHandle, IN PUNICODE_STRING DesktopPath, IN BOOL bInherit, OUT HWINSTA *phWinSta)
Definition: desktop.c:2781
LONG_PTR LPARAM
Definition: windef.h:208
#define SM_CYEDGE
Definition: winuser.h:999
void DPRINT(...)
Definition: polytest.cpp:61
int WINAPI ScrollWindowEx(_In_ HWND, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT, _In_ UINT)
Definition: bufpool.h:45
#define STARTF_USESHOWWINDOW
Definition: winbase.h:472
HMENU hSysMenu
Definition: conwnd.h:76
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
BOOL LineSelection
Definition: conwnd.h:94
#define NtCurrentProcess()
Definition: nt_native.h:1657
VOID SwitchFullScreen(PGUI_CONSOLE_DATA GuiData, BOOL FullScreen)
Definition: fullscreen.c:49
ULONG X
Definition: bl.h:1340
#define WSF_VISIBLE
Definition: winuser.h:2427
static VOID NTAPI GuiRefreshInternalInfo(IN OUT PFRONTEND This)
Definition: guiterm.c:848
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
NTSTATUS NTAPI NtResumeThread(IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
Definition: state.c:290
static FRONTEND_VTBL GuiVtbl
Definition: guiterm.c:1147
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
#define SM_CYCAPTION
Definition: winuser.h:953
NTSTATUS NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL)
Definition: event.c:458
if(!(yy_init))
Definition: macro.lex.yy.c:714
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static INT NTAPI GuiShowMouseCursor(IN OUT PFRONTEND This, BOOL Show)
Definition: guiterm.c:1075
BOOL WINAPI GetMonitorInfoW(_In_ HMONITOR, _Inout_ LPMONITORINFO)
#define SWP_NOACTIVATE
Definition: winuser.h:1227
struct _GUI_INIT_INFO * PGUI_INIT_INFO
#define MF_ENABLED
Definition: winuser.h:128
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
int WINAPI GetSystemMetrics(_In_ int)
static ULONG NTAPI GuiConsoleInputThread(PVOID Param)
Definition: guiterm.c:105
#define GUI_CONWND_CLASS
Definition: conwnd.h:15
UINT CmdIdHigh
Definition: conwnd.h:79
CRITICAL_SECTION Lock
Definition: conwnd.h:42
#define OBJ_PAL
Definition: objidl.idl:1413
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
#define PM_CONSOLE_BEEP
Definition: guiterm.c:43
HANDLE UniqueThread
Definition: compat.h:475
HANDLE ThreadHandle
Definition: csrsrv.h:71
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
static VIDEODISPLAYMODE DisplayMode
Definition: pcvideo.c:115
#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 VOID NTAPI GuiGetLargestConsoleWindowSize(IN OUT PFRONTEND This, PCOORD pSize)
Definition: guiterm.c:934
INT GetType(BOOL bLocal, LPOSVERSIONINFOEX osvi, LPSERVER_INFO_102 pBuf102)
Definition: gettype.c:129
static const WCHAR L[]
Definition: oid.c:1250
#define InterlockedDecrement
Definition: armddk.h:52
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)
static BOOL GuiInit(IN PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle, IN OUT PGUI_INIT_INFO GuiInitInfo)
Definition: guiterm.c:284
HANDLE GuiThreadStartupEvent
Definition: guiterm.c:35
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
static BOOL ConsInitialized
Definition: guiterm.c:45
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)
BOOLEAN IsWindowVisible
Definition: conwnd.h:52
Definition: bl.h:1338
static BOOL NTAPI GuiSetScreenInfo(IN OUT PFRONTEND This, PCONSOLE_SCREEN_BUFFER Buff, SHORT OldCursorX, SHORT OldCursorY)
Definition: guiterm.c:730
#define SW_INVALIDATE
Definition: winuser.h:2554
static HWND NTAPI GuiGetConsoleWindowHandle(IN OUT PFRONTEND This)
Definition: guiterm.c:927
Status
Definition: gdiplustypes.h:24
#define CONSOLE_WINDOWED
Definition: wincon.h:28
static VOID NTAPI GuiChangeTitle(IN OUT PFRONTEND This)
Definition: guiterm.c:870
#define SWP_NOSIZE
Definition: winuser.h:1230
BOOLEAN UnRegisterConWndClass(HINSTANCE hInstance)
Definition: conwnd.c:171
HICON WINAPI CopyIcon(_In_ HICON)
Definition: cursoricon.c:1980
#define SW_SHOWNORMAL
Definition: winuser.h:764
PCSR_THREAD NTAPI CsrConnectToUser(VOID)
Definition: api.c:1003
NTSTATUS NTAPI GuiUnloadFrontEnd(IN OUT PFRONTEND FrontEnd)
Definition: guiterm.c:1307
FORCEINLINE VOID GetScreenBufferSizeUnits(IN PCONSOLE_SCREEN_BUFFER Buffer, IN PGUI_CONSOLE_DATA GuiData, OUT PUINT WidthUnit, OUT PUINT HeightUnit)
Definition: guiterm.h:22
#define InterlockedIncrement
Definition: armddk.h:53
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
#define PM_RESIZE_TERMINAL
Definition: guiterm.c:42
HICON hIcon
Definition: msconfig.c:44
DWORD cbSize
Definition: winuser.h:3758
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:1177
HCURSOR ghDefaultCursor
Definition: conwnd.c:64
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
static CONSOLE_SCREEN_BUFFER_INFO ConsoleInfo
Definition: video.c:47
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
VOID GuiConsoleMoveWindow(PGUI_CONSOLE_DATA GuiData)
Definition: guiterm.c:61
HMONITOR WINAPI MonitorFromWindow(HWND, DWORD)
#define UOI_FLAGS
Definition: winuser.h:1073
#define HWND_DESKTOP
Definition: winuser.h:1195
unsigned int UINT
Definition: ndis.h:50
static BOOL NTAPI GuiSetMenuClose(IN OUT PFRONTEND This, BOOL Enable)
Definition: guiterm.c:1128
BOOLEAN RegisterConWndClass(IN HINSTANCE hInstance)
Definition: conwnd.c:125
#define CONSOLE_FULLSCREEN_MODE
Definition: wincon.h:33
WCHAR FaceName[LF_FACESIZE]
Definition: guisettings.h:18
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
BOOL WINAPI GetMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
UINT CharWidth
Definition: conwnd.h:86
HANDLE hThread
Definition: wizard.c:27
static VOID NTAPI GuiDrawRegion(IN OUT PFRONTEND This, SMALL_RECT *Region)
Definition: guiterm.c:629
HCURSOR hCursor
Definition: conwnd.h:70
CConsole Console
#define DPRINT1
Definition: precomp.h:8
GUI_CONSOLE_INFO GuiInfo
Definition: conwnd.h:96
#define ConsoleFreeHeap(HeapBase)
Definition: heap.h:15
HINSTANCE ConSrvDllInstance
Definition: init.c:21
#define msg(x)
Definition: auth_time.c:54
#define SC_CLOSE
Definition: winuser.h:2567
static VOID NTAPI GuiReleaseScreenBuffer(IN OUT PFRONTEND This, IN PCONSOLE_SCREEN_BUFFER ScreenBuffer)
Definition: guiterm.c:800
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
HPALETTE hSysPalette
Definition: conwnd.h:64
HANDLE ScreenBuffer
Definition: notevil.c:37
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:3407
#define OUT
Definition: typedefs.h:39
#define SM_CYFULLSCREEN
Definition: winuser.h:968
BOOL WINAPI CloseDesktop(_In_ HDESK)
HICON hIconSm
Definition: msconfig.c:44
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
BOOLEAN NTAPI CsrImpersonateClient(IN PCSR_THREAD CsrThread)
Definition: procsup.c:925
LONG bottom
Definition: windef.h:294
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
static VOID NTAPI GuiDeinitFrontEnd(IN OUT PFRONTEND This)
Definition: guiterm.c:594
#define ULONG_PTR
Definition: config.h:101
#define SM_CXFULLSCREEN
Definition: winuser.h:967
PCONSRV_CONSOLE Console
Definition: conwnd.h:90
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)
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
#define PM_REMOVE
Definition: winuser.h:1182
#define MF_GRAYED
Definition: winuser.h:129
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
return STATUS_SUCCESS
Definition: btrfs.c:2966
ULONG Y
Definition: bl.h:1341
BOOL GuiConsoleReadUserSettings(IN OUT PGUI_CONSOLE_INFO TermInfo)
Definition: guisettings.c:24
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
static LPHIST_ENTRY Top
Definition: history.c:53
static NTSTATUS NTAPI GuiInitFrontEnd(IN OUT PFRONTEND This, IN PCONSRV_CONSOLE Console)
Definition: guiterm.c:480
UINT WINAPI RealizePalette(_In_ HDC)
Definition: palette.c:138
#define SendNotifyMessage
Definition: winuser.h:5747
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC, _In_ UINT)
Definition: dc.c:439
BOOL WINAPI CloseWindowStation(_In_ HWINSTA)
#define ICON_BIG
Definition: tnclass.cpp:51
VOID GuiConsoleGetDefaultSettings(IN OUT PGUI_CONSOLE_INFO TermInfo)
Definition: guisettings.c:38
ULONG_PTR InputThreadId
Definition: conwnd.h:48
static BOOL NTAPI GuiSetPalette(IN OUT PFRONTEND This, HPALETTE PaletteHandle, UINT PaletteUsage)
Definition: guiterm.c:1011
NTSYSAPI NTSTATUS NTAPI NtWaitForSingleObject(IN HANDLE hObject, IN BOOLEAN bAlertable, IN PLARGE_INTEGER Timeout)