ReactOS  0.4.14-dev-390-g34947ad
conio.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _CONSOLE_IO_OBJECT
 
struct  _CONSOLE_SCREEN_BUFFER_VTBL
 
struct  _CONSOLE_SCREEN_BUFFER
 
struct  _TEXTMODE_BUFFER_INFO
 
struct  _TEXTMODE_SCREEN_BUFFER
 
struct  _GRAPHICS_BUFFER_INFO
 
struct  _GRAPHICS_SCREEN_BUFFER
 
struct  _CONSOLE_INPUT_BUFFER
 
struct  _FRONTEND_VTBL
 
struct  _FRONTEND
 
struct  _CONSOLE
 

Macros

#define CSR_DEFAULT_CURSOR_SIZE   25
 
#define DEFAULT_SCREEN_ATTRIB   (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED)
 
#define DEFAULT_POPUP_ATTRIB
 
#define GetType(This)   (This)->Vtbl->GetType(This)
 
#define PAUSED_FROM_KEYBOARD   0x1
 
#define PAUSED_FROM_SCROLLBAR   0x2
 
#define PAUSED_FROM_SELECTION   0x4
 
#define ConioInitRect(Rect, top, left, bottom, right)
 
#define ConioIsRectEmpty(Rect)   (((Rect)->Left > (Rect)->Right) || ((Rect)->Top > (Rect)->Bottom))
 
#define ConioRectHeight(Rect)   (((Rect)->Top) > ((Rect)->Bottom) ? 0 : ((Rect)->Bottom) - ((Rect)->Top) + 1)
 
#define ConioRectWidth(Rect)   (((Rect)->Left) > ((Rect)->Right) ? 0 : ((Rect)->Right) - ((Rect)->Left) + 1)
 
#define ConsoleUnicodeCharToAnsiChar(Console, dChar, sWChar)   WideCharToMultiByte((Console)->OutputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
 
#define ConsoleAnsiCharToUnicodeChar(Console, dWChar, sChar)   MultiByteToWideChar((Console)->OutputCodePage, 0, (sChar), 1, (dWChar), 1)
 

Typedefs

typedef enum _CONSOLE_IO_OBJECT_TYPE CONSOLE_IO_OBJECT_TYPE
 
typedef struct _CONSOLE_IO_OBJECT CONSOLE_IO_OBJECT
 
typedef struct _CONSOLE_IO_OBJECTPCONSOLE_IO_OBJECT
 
typedef struct _CONSOLE_SCREEN_BUFFER CONSOLE_SCREEN_BUFFER
 
typedef struct _CONSOLE_SCREEN_BUFFERPCONSOLE_SCREEN_BUFFER
 
typedef struct _CONSOLE_SCREEN_BUFFER_VTBL CONSOLE_SCREEN_BUFFER_VTBL
 
typedef struct _CONSOLE_SCREEN_BUFFER_VTBLPCONSOLE_SCREEN_BUFFER_VTBL
 
typedef struct _TEXTMODE_BUFFER_INFO TEXTMODE_BUFFER_INFO
 
typedef struct _TEXTMODE_BUFFER_INFOPTEXTMODE_BUFFER_INFO
 
typedef struct _TEXTMODE_SCREEN_BUFFER TEXTMODE_SCREEN_BUFFER
 
typedef struct _TEXTMODE_SCREEN_BUFFERPTEXTMODE_SCREEN_BUFFER
 
typedef struct _GRAPHICS_BUFFER_INFO GRAPHICS_BUFFER_INFO
 
typedef struct _GRAPHICS_BUFFER_INFOPGRAPHICS_BUFFER_INFO
 
typedef struct _GRAPHICS_SCREEN_BUFFER GRAPHICS_SCREEN_BUFFER
 
typedef struct _GRAPHICS_SCREEN_BUFFERPGRAPHICS_SCREEN_BUFFER
 
typedef struct _CONSOLE_INPUT_BUFFER CONSOLE_INPUT_BUFFER
 
typedef struct _CONSOLE_INPUT_BUFFERPCONSOLE_INPUT_BUFFER
 
typedef struct _FRONTEND FRONTEND
 
typedef struct _FRONTENDPFRONTEND
 
typedef struct _CONSOLE_INFOPCONSOLE_INFO
 
typedef struct _FRONTEND_VTBL FRONTEND_VTBL
 
typedef struct _FRONTEND_VTBLPFRONTEND_VTBL
 
typedef enum _CONSOLE_STATE CONSOLE_STATE
 
typedef enum _CONSOLE_STATEPCONSOLE_STATE
 
typedef struct _CONSOLE CONSOLE
 
typedef struct _CONSOLEPCONSOLE
 

Enumerations

enum  _CONSOLE_IO_OBJECT_TYPE {
  UNKNOWN = 0x00, TEXTMODE_BUFFER = 0x01, GRAPHICS_BUFFER = 0x02, SCREEN_BUFFER = 0x03,
  INPUT_BUFFER = 0x04, ANY_TYPE_BUFFER = 0x07, TEXTMODE_BUFFER = 0x01, GRAPHICS_BUFFER = 0x02,
  SCREEN_BUFFER = 0x03, INPUT_BUFFER = 0x04
}
 
enum  _CONSOLE_STATE {
  CONSOLE_INITIALIZING, CONSOLE_RUNNING, CONSOLE_TERMINATING, CONSOLE_IN_DESTRUCTION,
  CONSOLE_INITIALIZING, CONSOLE_RUNNING, CONSOLE_TERMINATING, CONSOLE_IN_DESTRUCTION
}
 

Functions

VOID FASTCALL ConioPause (PCONSOLE Console, UINT Flags)
 
VOID FASTCALL ConioUnpause (PCONSOLE Console, UINT Flags)
 
NTSTATUS NTAPI ConDrvConsoleProcessCtrlEvent (IN PCONSOLE Console, IN ULONG ProcessGroupId, IN ULONG Event)
 
VOID WINAPI ConioProcessKey (PCONSOLE Console, MSG *msg)
 
NTSTATUS FASTCALL ConioProcessInputEvent (PCONSOLE Console, PINPUT_RECORD InputEvent)
 
PCHAR_INFO ConioCoordToPointer (PTEXTMODE_SCREEN_BUFFER Buff, ULONG X, ULONG Y)
 
VOID FASTCALL ConioDrawConsole (PCONSOLE Console)
 
NTSTATUS ConioResizeBuffer (PCONSOLE Console, PTEXTMODE_SCREEN_BUFFER ScreenBuffer, COORD Size)
 
NTSTATUS ConioWriteConsole (PCONSOLE Console, PTEXTMODE_SCREEN_BUFFER Buff, PWCHAR Buffer, DWORD Length, BOOL Attrib)
 
DWORD FASTCALL ConioEffectiveCursorSize (PCONSOLE Console, DWORD Scale)
 

Macro Definition Documentation

◆ ConioInitRect

#define ConioInitRect (   Rect,
  top,
  left,
  bottom,
  right 
)
Value:
do { \
((Rect)->Top) = top; \
((Rect)->Left) = left; \
((Rect)->Bottom) = bottom; \
((Rect)->Right) = right; \
} while (0)
GLint GLint bottom
Definition: glext.h:7726
GLint left
Definition: glext.h:7726
GLdouble GLdouble right
Definition: glext.h:10859
static LPHIST_ENTRY Bottom
Definition: history.c:54
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
static LPHIST_ENTRY Top
Definition: history.c:53
struct Rect Rect

Definition at line 344 of file conio.h.

◆ ConioIsRectEmpty

#define ConioIsRectEmpty (   Rect)    (((Rect)->Left > (Rect)->Right) || ((Rect)->Top > (Rect)->Bottom))

Definition at line 351 of file conio.h.

◆ ConioRectHeight

#define ConioRectHeight (   Rect)    (((Rect)->Top) > ((Rect)->Bottom) ? 0 : ((Rect)->Bottom) - ((Rect)->Top) + 1)

Definition at line 353 of file conio.h.

◆ ConioRectWidth

#define ConioRectWidth (   Rect)    (((Rect)->Left) > ((Rect)->Right) ? 0 : ((Rect)->Right) - ((Rect)->Left) + 1)

Definition at line 355 of file conio.h.

◆ ConsoleAnsiCharToUnicodeChar

#define ConsoleAnsiCharToUnicodeChar (   Console,
  dWChar,
  sChar 
)    MultiByteToWideChar((Console)->OutputCodePage, 0, (sChar), 1, (dWChar), 1)

Definition at line 361 of file conio.h.

◆ ConsoleUnicodeCharToAnsiChar

#define ConsoleUnicodeCharToAnsiChar (   Console,
  dChar,
  sWChar 
)    WideCharToMultiByte((Console)->OutputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)

Definition at line 358 of file conio.h.

◆ CSR_DEFAULT_CURSOR_SIZE

#define CSR_DEFAULT_CURSOR_SIZE   25

Definition at line 13 of file conio.h.

◆ DEFAULT_POPUP_ATTRIB

#define DEFAULT_POPUP_ATTRIB
Value:
#define BACKGROUND_GREEN
Definition: wincon.h:44
#define FOREGROUND_RED
Definition: wincon.h:41
#define BACKGROUND_RED
Definition: wincon.h:45
#define FOREGROUND_BLUE
Definition: wincon.h:39
#define BACKGROUND_INTENSITY
Definition: wincon.h:46

Definition at line 17 of file conio.h.

◆ DEFAULT_SCREEN_ATTRIB

#define DEFAULT_SCREEN_ATTRIB   (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED)

Definition at line 16 of file conio.h.

◆ GetType

#define GetType (   This)    (This)->Vtbl->GetType(This)

Definition at line 58 of file conio.h.

◆ PAUSED_FROM_KEYBOARD

#define PAUSED_FROM_KEYBOARD   0x1

Definition at line 325 of file conio.h.

◆ PAUSED_FROM_SCROLLBAR

#define PAUSED_FROM_SCROLLBAR   0x2

Definition at line 326 of file conio.h.

◆ PAUSED_FROM_SELECTION

#define PAUSED_FROM_SELECTION   0x4

Definition at line 327 of file conio.h.

Typedef Documentation

◆ CONSOLE

◆ CONSOLE_INPUT_BUFFER

◆ CONSOLE_IO_OBJECT

◆ CONSOLE_IO_OBJECT_TYPE

◆ CONSOLE_SCREEN_BUFFER

Definition at line 50 of file conio.h.

◆ CONSOLE_SCREEN_BUFFER_VTBL

◆ CONSOLE_STATE

◆ FRONTEND

Definition at line 177 of file conio.h.

◆ FRONTEND_VTBL

◆ GRAPHICS_BUFFER_INFO

◆ GRAPHICS_SCREEN_BUFFER

◆ PCONSOLE

◆ PCONSOLE_INFO

Definition at line 178 of file conio.h.

◆ PCONSOLE_INPUT_BUFFER

◆ PCONSOLE_IO_OBJECT

◆ PCONSOLE_SCREEN_BUFFER

Definition at line 50 of file conio.h.

◆ PCONSOLE_SCREEN_BUFFER_VTBL

◆ PCONSOLE_STATE

◆ PFRONTEND

Definition at line 177 of file conio.h.

◆ PFRONTEND_VTBL

◆ PGRAPHICS_BUFFER_INFO

◆ PGRAPHICS_SCREEN_BUFFER

◆ PTEXTMODE_BUFFER_INFO

◆ PTEXTMODE_SCREEN_BUFFER

◆ TEXTMODE_BUFFER_INFO

◆ TEXTMODE_SCREEN_BUFFER

Enumeration Type Documentation

◆ _CONSOLE_IO_OBJECT_TYPE

Enumerator
UNKNOWN 
TEXTMODE_BUFFER 
GRAPHICS_BUFFER 
SCREEN_BUFFER 
INPUT_BUFFER 
ANY_TYPE_BUFFER 
TEXTMODE_BUFFER 
GRAPHICS_BUFFER 
SCREEN_BUFFER 
INPUT_BUFFER 

Definition at line 21 of file conio.h.

22 {
23 // ANY_TYPE_BUFFER = 0x00, // --> Match any types of IO handles
24  TEXTMODE_BUFFER = 0x01, // --> Output-type handles for text SBs
25  GRAPHICS_BUFFER = 0x02, // --> Output-type handles for graphics SBs
26  SCREEN_BUFFER = 0x03, // --> Any SB type
27  INPUT_BUFFER = 0x04 // --> Input-type handles
enum _CONSOLE_IO_OBJECT_TYPE CONSOLE_IO_OBJECT_TYPE

◆ _CONSOLE_STATE

Enumerator
CONSOLE_INITIALIZING 
CONSOLE_RUNNING 
CONSOLE_TERMINATING 
CONSOLE_IN_DESTRUCTION 
CONSOLE_INITIALIZING 
CONSOLE_RUNNING 
CONSOLE_TERMINATING 
CONSOLE_IN_DESTRUCTION 

Definition at line 259 of file conio.h.

260 {
261  CONSOLE_INITIALIZING, /* Console is initializing */
262  CONSOLE_RUNNING , /* Console running */
263  CONSOLE_TERMINATING , /* Console about to be destroyed (but still not) */
264  CONSOLE_IN_DESTRUCTION /* Console in destruction */
enum _CONSOLE_STATE * PCONSOLE_STATE
enum _CONSOLE_STATE CONSOLE_STATE

Function Documentation

◆ ConDrvConsoleProcessCtrlEvent()

NTSTATUS NTAPI ConDrvConsoleProcessCtrlEvent ( IN PCONSOLE  Console,
IN ULONG  ProcessGroupId,
IN ULONG  Event 
)

Definition at line 1069 of file console.c.

1072 {
1074  PLIST_ENTRY current_entry;
1076 
1077  /* If the console is already being destroyed, just return */
1079  return STATUS_UNSUCCESSFUL;
1080 
1081  /*
1082  * Loop through the process list, from the most recent process
1083  * (the active one) to the oldest one (the first created, i.e.
1084  * the console leader process), and for each, send an event
1085  * (new processes are inserted at the head of the console process list).
1086  */
1087  current_entry = Console->ProcessList.Flink;
1088  while (current_entry != &Console->ProcessList)
1089  {
1090  current = CONTAINING_RECORD(current_entry, CONSOLE_PROCESS_DATA, ConsoleLink);
1091  current_entry = current_entry->Flink;
1092 
1093  /*
1094  * Only processes belonging to the same process group are signaled.
1095  * If the process group ID is zero, then all the processes are signaled.
1096  */
1097  if (ProcessGroupId == 0 || current->Process->ProcessGroupId == ProcessGroupId)
1098  {
1100  }
1101  }
1102 
1103  return Status;
1104 }
BOOLEAN NTAPI ConDrvValidateConsoleState(IN PCONSOLE Console, IN CONSOLE_STATE ExpectedState)
Definition: console.c:108
LONG NTSTATUS
Definition: precomp.h:26
static NTSTATUS ConDrvConsoleCtrlEvent(IN ULONG Event, IN PCONSOLE_PROCESS_DATA ProcessData)
Definition: console.c:254
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
Definition: typedefs.h:117
Status
Definition: gdiplustypes.h:24
CConsole Console
return STATUS_SUCCESS
Definition: btrfs.c:2938
struct task_struct * current
Definition: linux.c:32

Referenced by ConDrvProcessKey(), CSR_API(), and GuiConsoleHandleClose().

◆ ConioCoordToPointer()

PCHAR_INFO ConioCoordToPointer ( PTEXTMODE_SCREEN_BUFFER  Buff,
ULONG  X,
ULONG  Y 
)

Definition at line 140 of file text.c.

141 {
142  return &Buff->Buffer[((Y + Buff->VirtualY) % Buff->ScreenBufferSize.Y) * Buff->ScreenBufferSize.X + X];
143 }
#define Y(I)
PCHAR_INFO Buffer
Definition: conio.h:154
#define X(b, s)

Referenced by ClearLineBuffer(), ConDrvReadConsoleOutput(), ConDrvWriteConsoleOutput(), ConDrvWriteConsoleOutputVDM(), ConioMoveRegion(), ConioResizeBuffer(), ConioWriteConsole(), CopyBlock(), CopyLines(), GuiCopyFromTextModeBuffer(), GuiPaintTextModeBuffer(), and OnMouse().

◆ ConioDrawConsole()

VOID FASTCALL ConioDrawConsole ( PCONSOLE  Console)

Definition at line 136 of file conoutput.c.

137 {
139  PCONSOLE_SCREEN_BUFFER ActiveBuffer = Console->ActiveBuffer;
140 
141  if (ActiveBuffer)
142  {
143  ConioInitRect(&Region, 0, 0, ActiveBuffer->ViewSize.Y - 1, ActiveBuffer->ViewSize.X - 1);
145  }
146 }
#define ConioDrawRegion(Console, Region)
Definition: conio2.h:13
ULONG X
Definition: bl.h:1340
#define ConioInitRect(Rect, top, left, bottom, right)
Definition: rect.h:20
CConsole Console
ULONG Y
Definition: bl.h:1341

◆ ConioEffectiveCursorSize()

DWORD FASTCALL ConioEffectiveCursorSize ( PCONSOLE  Console,
DWORD  Scale 
)

Definition at line 303 of file text.c.

304 {
305  DWORD Size = (Console->ActiveBuffer->CursorInfo.dwSize * Scale + 99) / 100;
306  /* If line input in progress, perhaps adjust for insert toggle */
307  if (Console->LineBuffer && !Console->LineComplete && Console->LineInsertToggle)
308  return (Size * 2 <= Scale) ? (Size * 2) : (Size / 2);
309  return Size;
310 }
unsigned long DWORD
Definition: ntddk_ex.h:95
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
CConsole Console

Referenced by GuiPaintTextModeBuffer().

◆ ConioPause()

VOID FASTCALL ConioPause ( PCONSOLE  Console,
UINT  Flags 
)

Definition at line 261 of file console.c.

262 {
263  Console->PauseFlags |= Flags;
264  if (!Console->UnpauseEvent)
265  Console->UnpauseEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
266 }
#define CreateEvent
Definition: winbase.h:3572
#define TRUE
Definition: types.h:120
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
smooth NULL
Definition: ftsmooth.c:416
CConsole Console

◆ ConioProcessInputEvent()

NTSTATUS FASTCALL ConioProcessInputEvent ( PCONSOLE  Console,
PINPUT_RECORD  InputEvent 
)

Definition at line 63 of file coninput.c.

65 {
66  ConsoleInput *ConInRec;
67 
68  /* Check for pause or unpause */
69  if (InputEvent->EventType == KEY_EVENT && InputEvent->Event.KeyEvent.bKeyDown)
70  {
71  WORD vk = InputEvent->Event.KeyEvent.wVirtualKeyCode;
72  if (!(Console->PauseFlags & PAUSED_FROM_KEYBOARD))
73  {
74  DWORD cks = InputEvent->Event.KeyEvent.dwControlKeyState;
75  if (Console->InputBuffer.Mode & ENABLE_LINE_INPUT &&
76  (vk == VK_PAUSE || (vk == 'S' &&
78  !(cks & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)))))
79  {
81  return STATUS_SUCCESS;
82  }
83  }
84  else
85  {
86  if ((vk < VK_SHIFT || vk > VK_CAPITAL) && vk != VK_LWIN &&
87  vk != VK_RWIN && vk != VK_NUMLOCK && vk != VK_SCROLL)
88  {
90  return STATUS_SUCCESS;
91  }
92  }
93  }
94 
95  /* Add event to the queue */
96  ConInRec = ConsoleAllocHeap(0, sizeof(ConsoleInput));
97  if (ConInRec == NULL) return STATUS_INSUFFICIENT_RESOURCES;
98 
99  ConInRec->InputEvent = *InputEvent;
100  InsertTailList(&Console->InputBuffer.InputEvents, &ConInRec->ListEntry);
101 
102  SetEvent(Console->InputBuffer.ActiveEvent);
103  CsrNotifyWait(&Console->InputBuffer.ReadWaitQueue,
104  WaitAny,
105  NULL,
106  NULL);
107  if (!IsListEmpty(&Console->InputBuffer.ReadWaitQueue))
108  {
109  CsrDereferenceWait(&Console->InputBuffer.ReadWaitQueue);
110  }
111 
112  return STATUS_SUCCESS;
113 }
VOID ConioUnpause(PCONSRV_CONSOLE Console, UINT Flags)
Definition: console.c:250
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define PAUSED_FROM_KEYBOARD
Definition: conio_winsrv.h:126
#define ConsoleAllocHeap(Flags, Size)
Definition: heap.h:14
DWORD dwControlKeyState
Definition: wincon.h:233
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
INPUT_RECORD InputEvent
Definition: consrv.h:60
#define VK_LWIN
Definition: winuser.h:2210
#define InsertTailList(ListHead, Entry)
union _INPUT_RECORD::@3177 Event
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
BOOLEAN NTAPI CsrNotifyWait(IN PLIST_ENTRY WaitList, IN BOOLEAN NotifyAll, IN PVOID WaitArgument1, IN PVOID WaitArgument2)
Definition: wait.c:388
WORD wVirtualKeyCode
Definition: wincon.h:227
#define KEY_EVENT
Definition: wincon.h:122
smooth NULL
Definition: ftsmooth.c:416
#define LEFT_ALT_PRESSED
Definition: wincon.h:132
KEY_EVENT_RECORD KeyEvent
Definition: wincon.h:263
LIST_ENTRY ListEntry
Definition: consrv.h:59
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
#define ENABLE_LINE_INPUT
Definition: wincon.h:76
VOID NTAPI CsrDereferenceWait(IN PLIST_ENTRY WaitList)
Definition: wait.c:266
#define LEFT_CTRL_PRESSED
Definition: wincon.h:134
#define VK_RWIN
Definition: winuser.h:2211
#define VK_SCROLL
Definition: winuser.h:2255
#define VK_NUMLOCK
Definition: winuser.h:2254
#define VK_CAPITAL
Definition: winuser.h:2181
CConsole Console
WORD EventType
Definition: wincon.h:261
VOID ConioPause(PCONSRV_CONSOLE Console, UINT Flags)
Definition: console.c:243
#define VK_PAUSE
Definition: winuser.h:2180
#define RIGHT_CTRL_PRESSED
Definition: wincon.h:133
return STATUS_SUCCESS
Definition: btrfs.c:2938
#define RIGHT_ALT_PRESSED
Definition: wincon.h:131

◆ ConioProcessKey()

VOID WINAPI ConioProcessKey ( PCONSOLE  Console,
MSG msg 
)

Definition at line 58 of file input.c.

59 {
60  static BYTE KeyState[256] = { 0 };
61  /* MSDN mentions that you should use the last virtual key code received
62  * when putting a virtual key identity to a WM_CHAR message since multiple
63  * or translated keys may be involved. */
64  static UINT LastVirtualKey = 0;
65  DWORD ShiftState;
66  WCHAR UnicodeChar;
67  UINT VirtualKeyCode;
68  UINT VirtualScanCode;
69  BOOL Down = FALSE;
70  BOOLEAN Fake; // synthesized, not a real event
71  BOOLEAN NotChar; // message should not be used to return a character
72 
73  if (NULL == Console)
74  {
75  DPRINT1("No Active Console!\n");
76  return;
77  }
78 
79  VirtualScanCode = HIWORD(msg->lParam) & 0xFF;
80  Down = msg->message == WM_KEYDOWN || msg->message == WM_CHAR ||
81  msg->message == WM_SYSKEYDOWN || msg->message == WM_SYSCHAR;
82 
83  GetKeyboardState(KeyState);
84  ShiftState = ConioGetShiftState(KeyState, msg->lParam);
85 
86  if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
87  {
88  VirtualKeyCode = LastVirtualKey;
89  UnicodeChar = msg->wParam;
90  }
91  else
92  {
93  WCHAR Chars[2];
94  INT RetChars = 0;
95 
96  VirtualKeyCode = msg->wParam;
97  RetChars = ToUnicodeEx(VirtualKeyCode,
98  VirtualScanCode,
99  KeyState,
100  Chars,
101  2,
102  0,
103  NULL);
104  UnicodeChar = (1 == RetChars ? Chars[0] : 0);
105  }
106 
108  msg,
109  KeyState[VK_MENU],
110  ShiftState,
111  VirtualKeyCode,
112  Down))
113  {
114  return;
115  }
116 
117  Fake = UnicodeChar &&
118  (msg->message != WM_CHAR && msg->message != WM_SYSCHAR &&
119  msg->message != WM_KEYUP && msg->message != WM_SYSKEYUP);
120  NotChar = (msg->message != WM_CHAR && msg->message != WM_SYSCHAR);
121  if (NotChar) LastVirtualKey = msg->wParam;
122 
123  DPRINT("CONSRV: %s %s %s %s %02x %02x '%lc' %04x\n",
124  Down ? "down" : "up ",
125  (msg->message == WM_CHAR || msg->message == WM_SYSCHAR) ?
126  "char" : "key ",
127  Fake ? "fake" : "real",
128  NotChar ? "notc" : "char",
129  VirtualScanCode,
130  VirtualKeyCode,
131  (UnicodeChar >= L' ') ? UnicodeChar : L'.',
132  ShiftState);
133 
134  if (Fake) return;
135 
136  /* Send the key press to the console driver */
138  Down,
139  VirtualKeyCode,
140  VirtualScanCode,
141  UnicodeChar,
142  ShiftState,
143  KeyState[VK_CONTROL]);
144 }
#define WM_CHAR
Definition: winuser.h:1699
#define VK_MENU
Definition: winuser.h:2179
int32_t INT
Definition: typedefs.h:56
unsigned int BOOL
Definition: ntddk_ex.h:94
#define WM_SYSCHAR
Definition: winuser.h:1703
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define WM_KEYDOWN
Definition: winuser.h:1697
void DPRINT(...)
Definition: polytest.cpp:61
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define WM_KEYUP
Definition: winuser.h:1698
unsigned long DWORD
Definition: ntddk_ex.h:95
_Check_return_ BOOL WINAPI GetKeyboardState(_Out_writes_(256) PBYTE lpKeyState)
static const WCHAR L[]
Definition: oid.c:1250
unsigned char BYTE
Definition: mem.h:68
int WINAPI ToUnicodeEx(UINT wVirtKey, UINT wScanCode, CONST BYTE *lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags, HKL dwhkl)
Definition: input.c:481
#define WM_SYSKEYUP
Definition: winuser.h:1702
#define ConioProcessKeyCallback(Console, Msg, KeyStateMenu, ShiftState, VirtualKeyCode, Down)
Definition: conio2.h:24
unsigned int UINT
Definition: ndis.h:50
static DWORD FASTCALL ConioGetShiftState(PBYTE KeyState, LPARAM lParam)
Definition: input.c:24
#define VK_CONTROL
Definition: winuser.h:2178
CConsole Console
#define DPRINT1
Definition: precomp.h:8
#define msg(x)
Definition: auth_time.c:54
#define WM_SYSKEYDOWN
Definition: winuser.h:1701
#define HIWORD(l)
Definition: typedefs.h:246
VOID NTAPI ConDrvProcessKey(IN PCONSOLE Console, IN BOOLEAN Down, IN UINT VirtualKeyCode, IN UINT VirtualScanCode, IN WCHAR UnicodeChar, IN ULONG ShiftState, IN BYTE KeyStateCtrl)
Definition: coninput.c:132

◆ ConioResizeBuffer()

NTSTATUS ConioResizeBuffer ( PCONSOLE  Console,
PTEXTMODE_SCREEN_BUFFER  ScreenBuffer,
COORD  Size 
)

Definition at line 257 of file text.c.

260 {
262  DWORD Offset = 0;
263  PCHAR_INFO ptr;
264  WORD CurrentAttribute;
265  USHORT CurrentY;
266  PCHAR_INFO OldBuffer;
267  DWORD i;
268  DWORD diff;
269 
270  /* Buffer size is not allowed to be smaller than the view size */
271  if (Size.X < ScreenBuffer->ViewSize.X || Size.Y < ScreenBuffer->ViewSize.Y)
273 
274  if (Size.X == ScreenBuffer->ScreenBufferSize.X && Size.Y == ScreenBuffer->ScreenBufferSize.Y)
275  {
276  // FIXME: Trigger a buffer resize event ??
277  return STATUS_SUCCESS;
278  }
279 
280  if (Console->FixedSize)
281  {
282  /*
283  * The console is in fixed-size mode, so we cannot resize anything
284  * at the moment. However, keep those settings somewhere so that
285  * we can try to set them up when we will be allowed to do so.
286  */
287  ScreenBuffer->OldScreenBufferSize = Size;
288  return STATUS_NOT_SUPPORTED; // STATUS_SUCCESS
289  }
290 
292  if (!Buffer) return STATUS_NO_MEMORY;
293 
294  DPRINT("Resizing (%d,%d) to (%d,%d)\n", ScreenBuffer->ScreenBufferSize.X, ScreenBuffer->ScreenBufferSize.Y, Size.X, Size.Y);
295  OldBuffer = ScreenBuffer->Buffer;
296 
297  for (CurrentY = 0; CurrentY < ScreenBuffer->ScreenBufferSize.Y && CurrentY < Size.Y; CurrentY++)
298  {
299  ptr = ConioCoordToPointer(ScreenBuffer, 0, CurrentY);
300  if (Size.X <= ScreenBuffer->ScreenBufferSize.X)
301  {
302  /* Reduce size */
303  RtlCopyMemory(Buffer + Offset, ptr, Size.X * sizeof(CHAR_INFO));
304  Offset += Size.X;
305  }
306  else
307  {
308  /* Enlarge size */
309  RtlCopyMemory(Buffer + Offset, ptr, ScreenBuffer->ScreenBufferSize.X * sizeof(CHAR_INFO));
310  Offset += ScreenBuffer->ScreenBufferSize.X;
311 
312  /* The attribute to be used is the one of the last cell of the current line */
313  CurrentAttribute = ConioCoordToPointer(ScreenBuffer,
314  ScreenBuffer->ScreenBufferSize.X - 1,
315  CurrentY)->Attributes;
316 
317  diff = Size.X - ScreenBuffer->ScreenBufferSize.X;
318 
319  /* Zero-out the new part of the buffer */
320  for (i = 0; i < diff; i++)
321  {
322  ptr = Buffer + Offset;
323  ptr->Char.UnicodeChar = L' ';
324  ptr->Attributes = CurrentAttribute;
325  ++Offset;
326  }
327  }
328  }
329 
330  if (Size.Y > ScreenBuffer->ScreenBufferSize.Y)
331  {
332  diff = Size.X * (Size.Y - ScreenBuffer->ScreenBufferSize.Y);
333 
334  /* Zero-out the new part of the buffer */
335  for (i = 0; i < diff; i++)
336  {
337  ptr = Buffer + Offset;
338  ptr->Char.UnicodeChar = L' ';
339  ptr->Attributes = ScreenBuffer->ScreenDefaultAttrib;
340  ++Offset;
341  }
342  }
343 
345  ConsoleFreeHeap(OldBuffer);
346  ScreenBuffer->ScreenBufferSize = ScreenBuffer->OldScreenBufferSize = Size;
347  ScreenBuffer->VirtualY = 0;
348 
349  /* Ensure cursor and window are within buffer */
350  if (ScreenBuffer->CursorPosition.X >= Size.X)
351  ScreenBuffer->CursorPosition.X = Size.X - 1;
352  if (ScreenBuffer->CursorPosition.Y >= Size.Y)
353  ScreenBuffer->CursorPosition.Y = Size.Y - 1;
354  if (ScreenBuffer->ViewOrigin.X > Size.X - ScreenBuffer->ViewSize.X)
355  ScreenBuffer->ViewOrigin.X = Size.X - ScreenBuffer->ViewSize.X;
356  if (ScreenBuffer->ViewOrigin.Y > Size.Y - ScreenBuffer->ViewSize.Y)
357  ScreenBuffer->ViewOrigin.Y = Size.Y - ScreenBuffer->ViewSize.Y;
358 
359  /*
360  * Trigger a buffer resize event
361  */
362  if (Console->InputBuffer.Mode & ENABLE_WINDOW_INPUT)
363  {
364  ULONG NumEventsWritten;
365  INPUT_RECORD er;
366 
368  er.Event.WindowBufferSizeEvent.dwSize = ScreenBuffer->ScreenBufferSize;
369 
370  // ConioProcessInputEvent(Console, &er);
372  &Console->InputBuffer,
373  TRUE,
374  &er,
375  1,
376  &NumEventsWritten);
377  }
378 
379  return STATUS_SUCCESS;
380 }
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
PCHAR_INFO ConioCoordToPointer(PTEXTMODE_SCREEN_BUFFER Buff, ULONG X, ULONG Y)
Definition: text.c:140
#define WINDOW_BUFFER_SIZE_EVENT
Definition: wincon.h:124
#define ConsoleAllocHeap(Flags, Size)
Definition: heap.h:14
WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent
Definition: wincon.h:265
union _INPUT_RECORD::@3177 Event
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
static PVOID ptr
Definition: dispmode.c:27
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
WORD Attributes
Definition: wincon.h:172
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
static const WCHAR L[]
Definition: oid.c:1250
#define ENABLE_WINDOW_INPUT
Definition: wincon.h:78
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
unsigned short USHORT
Definition: pedump.c:61
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
NTSTATUS NTAPI ConDrvWriteConsoleInput(IN PCONSOLE Console, IN PCONSOLE_INPUT_BUFFER InputBuffer, IN BOOLEAN AppendToEnd, IN PINPUT_RECORD InputRecord, IN ULONG NumEventsToWrite, OUT PULONG NumEventsWritten OPTIONAL)
Definition: coninput.c:325
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
CConsole Console
WORD EventType
Definition: wincon.h:261
#define ConsoleFreeHeap(HeapBase)
Definition: heap.h:15
HANDLE ScreenBuffer
Definition: notevil.c:37
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:409
unsigned int ULONG
Definition: retypes.h:1
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by ConDrvSetConsoleScreenBufferSize(), and ConSrvApplyUserSettings().

◆ ConioUnpause()

VOID FASTCALL ConioUnpause ( PCONSOLE  Console,
UINT  Flags 
)

Definition at line 269 of file console.c.

270 {
271  Console->PauseFlags &= ~Flags;
272 
273  // if ((Console->PauseFlags & (PAUSED_FROM_KEYBOARD | PAUSED_FROM_SCROLLBAR | PAUSED_FROM_SELECTION)) == 0)
274  if (Console->PauseFlags == 0 && Console->UnpauseEvent)
275  {
276  SetEvent(Console->UnpauseEvent);
277  CloseHandle(Console->UnpauseEvent);
278  Console->UnpauseEvent = NULL;
279 
280  CsrNotifyWait(&Console->WriteWaitQueue,
281  WaitAll,
282  NULL,
283  NULL);
284  if (!IsListEmpty(&Console->WriteWaitQueue))
285  {
286  CsrDereferenceWait(&Console->WriteWaitQueue);
287  }
288  }
289 }
#define CloseHandle
Definition: compat.h:406
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
BOOLEAN NTAPI CsrNotifyWait(IN PLIST_ENTRY WaitList, IN BOOLEAN NotifyAll, IN PVOID WaitArgument1, IN PVOID WaitArgument2)
Definition: wait.c:388
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
smooth NULL
Definition: ftsmooth.c:416
VOID NTAPI CsrDereferenceWait(IN PLIST_ENTRY WaitList)
Definition: wait.c:266
CConsole Console

◆ ConioWriteConsole()

NTSTATUS ConioWriteConsole ( PCONSOLE  Console,
PTEXTMODE_SCREEN_BUFFER  Buff,
PWCHAR  Buffer,
DWORD  Length,
BOOL  Attrib 
)

Definition at line 455 of file text.c.

460 {
461  UINT i;
462  PCHAR_INFO Ptr;
464  SHORT CursorStartX, CursorStartY;
465  UINT ScrolledLines;
466 
467  CursorStartX = Buff->CursorPosition.X;
468  CursorStartY = Buff->CursorPosition.Y;
469  UpdateRect.Left = Buff->ScreenBufferSize.X;
470  UpdateRect.Top = Buff->CursorPosition.Y;
471  UpdateRect.Right = -1;
472  UpdateRect.Bottom = Buff->CursorPosition.Y;
473  ScrolledLines = 0;
474 
475  for (i = 0; i < Length; i++)
476  {
477  /*
478  * If we are in processed mode, interpret special characters and
479  * display them correctly. Otherwise, just put them into the buffer.
480  */
481  if (Buff->Mode & ENABLE_PROCESSED_OUTPUT)
482  {
483  /* --- CR --- */
484  if (Buffer[i] == L'\r')
485  {
486  Buff->CursorPosition.X = 0;
487  UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
488  UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
489  continue;
490  }
491  /* --- LF --- */
492  else if (Buffer[i] == L'\n')
493  {
494  Buff->CursorPosition.X = 0;
495  ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
496  continue;
497  }
498  /* --- BS --- */
499  else if (Buffer[i] == L'\b')
500  {
501  /* Only handle BS if we're not on the first pos of the first line */
502  if (0 != Buff->CursorPosition.X || 0 != Buff->CursorPosition.Y)
503  {
504  if (0 == Buff->CursorPosition.X)
505  {
506  /* slide virtual position up */
507  Buff->CursorPosition.X = Buff->ScreenBufferSize.X - 1;
508  Buff->CursorPosition.Y--;
509  UpdateRect.Top = min(UpdateRect.Top, Buff->CursorPosition.Y);
510  }
511  else
512  {
513  Buff->CursorPosition.X--;
514  }
515  Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
516  Ptr->Char.UnicodeChar = L' ';
517  Ptr->Attributes = Buff->ScreenDefaultAttrib;
518  UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
519  UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
520  }
521  continue;
522  }
523  /* --- TAB --- */
524  else if (Buffer[i] == L'\t')
525  {
526  UINT EndX;
527 
528  UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
529  EndX = (Buff->CursorPosition.X + TAB_WIDTH) & ~(TAB_WIDTH - 1);
530  EndX = min(EndX, (UINT)Buff->ScreenBufferSize.X);
531  Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
532  while (Buff->CursorPosition.X < EndX)
533  {
534  Ptr->Char.UnicodeChar = L' ';
535  Ptr->Attributes = Buff->ScreenDefaultAttrib;
536  ++Ptr;
537  Buff->CursorPosition.X++;
538  }
539  UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X - 1);
540  if (Buff->CursorPosition.X == Buff->ScreenBufferSize.X)
541  {
542  if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
543  {
544  Buff->CursorPosition.X = 0;
545  ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
546  }
547  else
548  {
549  Buff->CursorPosition.X--;
550  }
551  }
552  continue;
553  }
554  // /* --- BEL ---*/
555  // else if (Buffer[i] == L'\a')
556  // {
557  // // FIXME: This MUST BE moved to the terminal emulator frontend!!
558  // DPRINT1("Bell\n");
559  // // SendNotifyMessage(Console->hWindow, PM_CONSOLE_BEEP, 0, 0);
560  // continue;
561  // }
562  }
563  UpdateRect.Left = min(UpdateRect.Left, Buff->CursorPosition.X);
564  UpdateRect.Right = max(UpdateRect.Right, Buff->CursorPosition.X);
565 
566  Ptr = ConioCoordToPointer(Buff, Buff->CursorPosition.X, Buff->CursorPosition.Y);
567  Ptr->Char.UnicodeChar = Buffer[i];
568  if (Attrib) Ptr->Attributes = Buff->ScreenDefaultAttrib;
569 
570  Buff->CursorPosition.X++;
571  if (Buff->CursorPosition.X == Buff->ScreenBufferSize.X)
572  {
573  if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
574  {
575  Buff->CursorPosition.X = 0;
576  ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
577  }
578  else
579  {
580  Buff->CursorPosition.X = CursorStartX;
581  }
582  }
583  }
584 
585  if (!ConioIsRectEmpty(&UpdateRect) && (PCONSOLE_SCREEN_BUFFER)Buff == Console->ActiveBuffer)
586  {
587  ConioWriteStream(Console, &UpdateRect, CursorStartX, CursorStartY,
588  ScrolledLines, Buffer, Length);
589  }
590 
591  return STATUS_SUCCESS;
592 }
#define max(a, b)
Definition: svc.c:63
static VOID FASTCALL ConioNextLine(PTEXTMODE_SCREEN_BUFFER Buff, PSMALL_RECT UpdateRect, PUINT ScrolledLines)
Definition: text.c:432
PCHAR_INFO ConioCoordToPointer(PTEXTMODE_SCREEN_BUFFER Buff, ULONG X, ULONG Y)
Definition: text.c:140
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
#define ENABLE_WRAP_AT_EOL_OUTPUT
Definition: blue.h:45
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
short SHORT
Definition: pedump.c:59
Definition: bufpool.h:45
#define ConioWriteStream(Console, Block, CurStartX, CurStartY, ScrolledLines, Buffer, Length)
Definition: conio2.h:15
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
static const WCHAR L[]
Definition: oid.c:1250
#define ENABLE_PROCESSED_OUTPUT
Definition: blue.h:44
#define TAB_WIDTH
Definition: text.c:24
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
CConsole Console
static int UpdateRect(TreeListData *pData, unsigned uItem, unsigned uSub)
Definition: treelist.c:1529
#define ConioIsRectEmpty(Rect)
Definition: rect.h:28
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by ConDrvWriteConsole().