/* INCLUDES *******************************************************************/
-#include "consrv.h"
-#include "include/conio.h"
-#include "include/conio2.h"
-#include "handle.h"
-#include "lineinput.h"
+#include <consrv.h>
#define NDEBUG
#include <debug.h>
-
/* GLOBALS ********************************************************************/
-#define ConSrvGetInputBuffer(ProcessData, Handle, Ptr, Access, LockConsole) \
- ConSrvGetObject((ProcessData), (Handle), (PCONSOLE_IO_OBJECT*)(Ptr), NULL, \
- (Access), (LockConsole), INPUT_BUFFER)
-#define ConSrvGetInputBufferAndHandleEntry(ProcessData, Handle, Ptr, Entry, Access, LockConsole) \
- ConSrvGetObject((ProcessData), (Handle), (PCONSOLE_IO_OBJECT*)(Ptr), (Entry), \
- (Access), (LockConsole), INPUT_BUFFER)
-#define ConSrvReleaseInputBuffer(Buff, IsConsoleLocked) \
- ConSrvReleaseObject(&(Buff)->Header, (IsConsoleLocked))
-
-
+/*
+ * From MSDN:
+ * "The lpMultiByteStr and lpWideCharStr pointers must not be the same.
+ * If they are the same, the function fails, and GetLastError returns
+ * ERROR_INVALID_PARAMETER."
+ */
#define ConsoleInputUnicodeCharToAnsiChar(Console, dChar, sWChar) \
- WideCharToMultiByte((Console)->CodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
+ ASSERT((ULONG_PTR)dChar != (ULONG_PTR)sWChar); \
+ WideCharToMultiByte((Console)->InputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
#define ConsoleInputAnsiCharToUnicodeChar(Console, dWChar, sChar) \
- MultiByteToWideChar((Console)->CodePage, 0, (sChar), 1, (dWChar), 1)
+ ASSERT((ULONG_PTR)dWChar != (ULONG_PTR)sChar); \
+ MultiByteToWideChar((Console)->InputCodePage, 0, (sChar), 1, (dWChar), 1)
typedef struct ConsoleInput_t
{
/* PRIVATE FUNCTIONS **********************************************************/
-static VOID FASTCALL
+static VOID
ConioInputEventToAnsi(PCONSOLE Console, PINPUT_RECORD InputEvent)
{
if (InputEvent->EventType == KEY_EVENT)
}
}
-NTSTATUS FASTCALL
-ConioProcessInputEvent(PCONSOLE Console,
- PINPUT_RECORD InputEvent)
+static VOID
+ConioInputEventToUnicode(PCONSOLE Console, PINPUT_RECORD InputEvent)
+{
+ if (InputEvent->EventType == KEY_EVENT)
+ {
+ CHAR AsciiChar = InputEvent->Event.KeyEvent.uChar.AsciiChar;
+ InputEvent->Event.KeyEvent.uChar.AsciiChar = 0;
+ ConsoleInputAnsiCharToUnicodeChar(Console,
+ &InputEvent->Event.KeyEvent.uChar.UnicodeChar,
+ &AsciiChar);
+ }
+}
+
+
+/*
+ * This pre-processing code MUST be IN consrv ONLY
+ */
+static ULONG
+PreprocessInput(PCONSOLE Console,
+ PINPUT_RECORD InputEvent,
+ ULONG NumEventsToWrite)
{
- ConsoleInput *ConInRec;
+ ULONG NumEvents;
- /* Check for pause or unpause */
- if (InputEvent->EventType == KEY_EVENT && InputEvent->Event.KeyEvent.bKeyDown)
+ /*
+ * Loop each event, and for each, check for pause or unpause
+ * and perform adequate behaviour.
+ */
+ for (NumEvents = NumEventsToWrite; NumEvents > 0; --NumEvents)
{
- WORD vk = InputEvent->Event.KeyEvent.wVirtualKeyCode;
- if (!(Console->PauseFlags & PAUSED_FROM_KEYBOARD))
+ /* Check for pause or unpause */
+ if (InputEvent->EventType == KEY_EVENT && InputEvent->Event.KeyEvent.bKeyDown)
{
- DWORD cks = InputEvent->Event.KeyEvent.dwControlKeyState;
- if (Console->InputBuffer.Mode & ENABLE_LINE_INPUT &&
- (vk == VK_PAUSE || (vk == 'S' &&
- (cks & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) &&
- !(cks & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)))))
+ WORD vk = InputEvent->Event.KeyEvent.wVirtualKeyCode;
+ if (!(Console->PauseFlags & PAUSED_FROM_KEYBOARD))
{
- ConioPause(Console, PAUSED_FROM_KEYBOARD);
- return STATUS_SUCCESS;
+ DWORD cks = InputEvent->Event.KeyEvent.dwControlKeyState;
+ if (Console->InputBuffer.Mode & ENABLE_LINE_INPUT &&
+ (vk == VK_PAUSE ||
+ (vk == 'S' && (cks & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) &&
+ !(cks & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)))))
+ {
+ ConioPause(Console, PAUSED_FROM_KEYBOARD);
+
+ /* Skip the event */
+ RtlMoveMemory(InputEvent,
+ InputEvent + 1,
+ (NumEvents - 1) * sizeof(INPUT_RECORD));
+ --NumEventsToWrite;
+ continue;
+ }
}
- }
- else
- {
- if ((vk < VK_SHIFT || vk > VK_CAPITAL) && vk != VK_LWIN &&
- vk != VK_RWIN && vk != VK_NUMLOCK && vk != VK_SCROLL)
+ else
{
- ConioUnpause(Console, PAUSED_FROM_KEYBOARD);
- return STATUS_SUCCESS;
+ if ((vk < VK_SHIFT || vk > VK_CAPITAL) && vk != VK_LWIN &&
+ vk != VK_RWIN && vk != VK_NUMLOCK && vk != VK_SCROLL)
+ {
+ ConioUnpause(Console, PAUSED_FROM_KEYBOARD);
+
+ /* Skip the event */
+ RtlMoveMemory(InputEvent,
+ InputEvent + 1,
+ (NumEvents - 1) * sizeof(INPUT_RECORD));
+ --NumEventsToWrite;
+ continue;
+ }
}
}
- }
- /* Add event to the queue */
- ConInRec = ConsoleAllocHeap(0, sizeof(ConsoleInput));
- if (ConInRec == NULL) return STATUS_INSUFFICIENT_RESOURCES;
+ /* Go to the next event */
+ ++InputEvent;
+ }
- ConInRec->InputEvent = *InputEvent;
- InsertTailList(&Console->InputBuffer.InputEvents, &ConInRec->ListEntry);
+ return NumEventsToWrite;
+}
- SetEvent(Console->InputBuffer.ActiveEvent);
- CsrNotifyWait(&Console->InputBuffer.ReadWaitQueue,
- WaitAny,
+/*
+ * This post-processing code MUST be IN consrv ONLY
+ */
+static VOID
+PostprocessInput(PCONSOLE Console)
+{
+ CsrNotifyWait(&Console->ReadWaitQueue,
+ FALSE,
NULL,
NULL);
- if (!IsListEmpty(&Console->InputBuffer.ReadWaitQueue))
+ if (!IsListEmpty(&Console->ReadWaitQueue))
{
- CsrDereferenceWait(&Console->InputBuffer.ReadWaitQueue);
+ CsrDereferenceWait(&Console->ReadWaitQueue);
}
-
- return STATUS_SUCCESS;
}
-VOID FASTCALL
-PurgeInputBuffer(PCONSOLE Console)
+NTSTATUS
+ConioAddInputEvents(PCONSOLE Console,
+ PINPUT_RECORD InputRecords, // InputEvent
+ ULONG NumEventsToWrite,
+ PULONG NumEventsWritten,
+ BOOLEAN AppendToEnd)
{
- PLIST_ENTRY CurrentEntry;
- ConsoleInput* Event;
+ NTSTATUS Status = STATUS_SUCCESS;
+ ULONG i = 0;
+ BOOLEAN SetWaitEvent = FALSE;
- while (!IsListEmpty(&Console->InputBuffer.InputEvents))
- {
- CurrentEntry = RemoveHeadList(&Console->InputBuffer.InputEvents);
- Event = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
- ConsoleFreeHeap(Event);
- }
+ if (NumEventsWritten) *NumEventsWritten = 0;
- CloseHandle(Console->InputBuffer.ActiveEvent);
-}
+ /*
+ * This pre-processing code MUST be IN consrv ONLY!!
+ */
+ NumEventsToWrite = PreprocessInput(Console, InputRecords, NumEventsToWrite);
+ if (NumEventsToWrite == 0) return STATUS_SUCCESS;
-VOID NTAPI
-ConDrvProcessKey(IN PCONSOLE Console,
- IN BOOLEAN Down,
- IN UINT VirtualKeyCode,
- IN UINT VirtualScanCode,
- IN WCHAR UnicodeChar,
- IN ULONG ShiftState,
- IN BYTE KeyStateCtrl)
-{
- INPUT_RECORD er;
- /* process Ctrl-C and Ctrl-Break */
- if ( Console->InputBuffer.Mode & ENABLE_PROCESSED_INPUT &&
- Down && (VirtualKeyCode == VK_PAUSE || VirtualKeyCode == 'C') &&
- (ShiftState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED) || KeyStateCtrl & 0x80) )
+ /*
+ * When adding many single events, in the case of repeated mouse move or
+ * key down events, we try to coalesce them so that we do not saturate
+ * too quickly the input buffer.
+ */
+ if (NumEventsToWrite == 1 && !IsListEmpty(&Console->InputBuffer.InputEvents))
{
- DPRINT1("Console_Api Ctrl-C\n");
- ConDrvConsoleProcessCtrlEvent(Console, 0, CTRL_C_EVENT);
+ PINPUT_RECORD InputRecord = InputRecords; // Only one element
+ PINPUT_RECORD LastInputRecord;
+ ConsoleInput* ConInRec; // Input
- if (Console->LineBuffer && !Console->LineComplete)
+ /* Get the "next" event of the input buffer */
+ if (AppendToEnd)
{
- /* Line input is in progress; end it */
- Console->LinePos = Console->LineSize = 0;
- Console->LineComplete = TRUE;
+ /* Get the tail element */
+ ConInRec = CONTAINING_RECORD(Console->InputBuffer.InputEvents.Blink,
+ ConsoleInput, ListEntry);
}
- return;
- }
-
- if ( (ShiftState & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)) != 0 &&
- (VK_UP == VirtualKeyCode || VK_DOWN == VirtualKeyCode) )
- {
- if (!Down) return;
+ else
+ {
+ /* Get the head element */
+ ConInRec = CONTAINING_RECORD(Console->InputBuffer.InputEvents.Flink,
+ ConsoleInput, ListEntry);
+ }
+ LastInputRecord = &ConInRec->InputEvent;
- /* scroll up or down */
- if (VK_UP == VirtualKeyCode)
+ if (InputRecord->EventType == MOUSE_EVENT &&
+ InputRecord->Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
{
- /* only scroll up if there is room to scroll up into */
- if (Console->ActiveBuffer->CursorPosition.Y != Console->ActiveBuffer->ScreenBufferSize.Y - 1)
+ if (LastInputRecord->EventType == MOUSE_EVENT &&
+ LastInputRecord->Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
{
- Console->ActiveBuffer->VirtualY = (Console->ActiveBuffer->VirtualY +
- Console->ActiveBuffer->ScreenBufferSize.Y - 1) %
- Console->ActiveBuffer->ScreenBufferSize.Y;
- Console->ActiveBuffer->CursorPosition.Y++;
+ /* Update the mouse position */
+ LastInputRecord->Event.MouseEvent.dwMousePosition.X =
+ InputRecord->Event.MouseEvent.dwMousePosition.X;
+ LastInputRecord->Event.MouseEvent.dwMousePosition.Y =
+ InputRecord->Event.MouseEvent.dwMousePosition.Y;
+
+ i = 1;
+ // return STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
}
- else
+ else if (InputRecord->EventType == KEY_EVENT &&
+ InputRecord->Event.KeyEvent.bKeyDown)
{
- /* only scroll down if there is room to scroll down into */
- if (Console->ActiveBuffer->CursorPosition.Y != 0)
+ if (LastInputRecord->EventType == KEY_EVENT &&
+ LastInputRecord->Event.KeyEvent.bKeyDown &&
+ (LastInputRecord->Event.KeyEvent.wVirtualScanCode == // Same scancode
+ InputRecord->Event.KeyEvent.wVirtualScanCode) &&
+ (LastInputRecord->Event.KeyEvent.uChar.UnicodeChar == // Same character
+ InputRecord->Event.KeyEvent.uChar.UnicodeChar) &&
+ (LastInputRecord->Event.KeyEvent.dwControlKeyState == // Same Ctrl/Alt/Shift state
+ InputRecord->Event.KeyEvent.dwControlKeyState) )
{
- Console->ActiveBuffer->VirtualY = (Console->ActiveBuffer->VirtualY + 1) %
- Console->ActiveBuffer->ScreenBufferSize.Y;
- Console->ActiveBuffer->CursorPosition.Y--;
+ /* Update the repeat count */
+ LastInputRecord->Event.KeyEvent.wRepeatCount +=
+ InputRecord->Event.KeyEvent.wRepeatCount;
+
+ i = 1;
+ // return STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
}
+ }
- ConioDrawConsole(Console);
- return;
+ /* If we coalesced the only one element, we can quit */
+ if (i == 1 && Status == STATUS_SUCCESS /* && NumEventsToWrite == 1 */)
+ goto Done;
+
+ /*
+ * No event coalesced, add them in the usual way.
+ */
+
+ if (AppendToEnd)
+ {
+ /* Go to the beginning of the list */
+ // InputRecords = InputRecords;
+ }
+ else
+ {
+ /* Go to the end of the list */
+ InputRecords = &InputRecords[NumEventsToWrite - 1];
}
- er.EventType = KEY_EVENT;
- er.Event.KeyEvent.bKeyDown = Down;
- er.Event.KeyEvent.wRepeatCount = 1;
- er.Event.KeyEvent.wVirtualKeyCode = VirtualKeyCode;
- er.Event.KeyEvent.wVirtualScanCode = VirtualScanCode;
- er.Event.KeyEvent.uChar.UnicodeChar = UnicodeChar;
- er.Event.KeyEvent.dwControlKeyState = ShiftState;
+ /* Set the event if the list is going to be non-empty */
+ if (IsListEmpty(&Console->InputBuffer.InputEvents))
+ SetWaitEvent = TRUE;
- ConioProcessInputEvent(Console, &er);
+ for (i = 0; i < NumEventsToWrite && NT_SUCCESS(Status); ++i)
+ {
+ PINPUT_RECORD InputRecord;
+ ConsoleInput* ConInRec;
+
+ if (AppendToEnd)
+ {
+ /* Select the event and go to the next one */
+ InputRecord = InputRecords++;
+ }
+ else
+ {
+ /* Select the event and go to the previous one */
+ InputRecord = InputRecords--;
+ }
+
+ /* Add event to the queue */
+ ConInRec = ConsoleAllocHeap(0, sizeof(ConsoleInput));
+ if (ConInRec == NULL)
+ {
+ // return STATUS_INSUFFICIENT_RESOURCES;
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ continue;
+ }
+
+ ConInRec->InputEvent = *InputRecord;
+
+ if (AppendToEnd)
+ {
+ /* Append the event to the end of the queue */
+ InsertTailList(&Console->InputBuffer.InputEvents, &ConInRec->ListEntry);
+ }
+ else
+ {
+ /* Append the event to the beginning of the queue */
+ InsertHeadList(&Console->InputBuffer.InputEvents, &ConInRec->ListEntry);
+ }
+
+ // return STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
+ }
+
+ if (SetWaitEvent) SetEvent(Console->InputBuffer.ActiveEvent);
+
+Done:
+ if (NumEventsWritten) *NumEventsWritten = i;
+
+
+ /*
+ * This post-processing code MUST be IN consrv ONLY!!
+ */
+ // if (NT_SUCCESS(Status))
+ if (Status == STATUS_SUCCESS) PostprocessInput(Console);
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+ConioProcessInputEvent(PCONSOLE Console,
+ PINPUT_RECORD InputEvent)
+{
+ ULONG NumEventsWritten;
+ return ConioAddInputEvents(Console,
+ InputEvent,
+ 1,
+ &NumEventsWritten,
+ TRUE);
+}
+
+
+VOID
+PurgeInputBuffer(PCONSOLE Console)
+{
+ PLIST_ENTRY CurrentEntry;
+ ConsoleInput* Event;
+
+ while (!IsListEmpty(&Console->InputBuffer.InputEvents))
+ {
+ CurrentEntry = RemoveHeadList(&Console->InputBuffer.InputEvents);
+ Event = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
+ ConsoleFreeHeap(Event);
+ }
+
+ CloseHandle(Console->InputBuffer.ActiveEvent);
}
NTSTATUS NTAPI
ConDrvReadConsole(IN PCONSOLE Console,
IN PCONSOLE_INPUT_BUFFER InputBuffer,
+ /**/IN PUNICODE_STRING ExeName /**/OPTIONAL/**/,/**/
IN BOOLEAN Unicode,
OUT PVOID Buffer,
IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
NTSTATUS Status = STATUS_PENDING;
PLIST_ENTRY CurrentEntry;
ConsoleInput *Input;
- ULONG i = ReadControl->nInitialChars;
+ ULONG i;
if (Console == NULL || InputBuffer == NULL || /* Buffer == NULL || */
ReadControl == NULL || ReadControl->nLength != sizeof(CONSOLE_READCONSOLE_CONTROL))
/* Validity checks */
ASSERT(Console == InputBuffer->Header.Console);
- ASSERT( (Buffer != NULL && NumCharsToRead >= 0) ||
- (Buffer == NULL && NumCharsToRead == 0) );
+ ASSERT((Buffer != NULL) || (Buffer == NULL && NumCharsToRead == 0));
/* We haven't read anything (yet) */
+ i = ReadControl->nInitialChars;
+
if (InputBuffer->Mode & ENABLE_LINE_INPUT)
{
if (Console->LineBuffer == NULL)
Console->LineComplete = FALSE;
Console->LineUpPressed = FALSE;
- Console->LineInsertToggle = 0;
+ Console->LineInsertToggle = Console->InsertMode;
Console->LineWakeupMask = ReadControl->dwCtrlWakeupMask;
Console->LineSize = ReadControl->nInitialChars;
Console->LinePos = Console->LineSize;
if (Input->InputEvent.EventType == KEY_EVENT &&
Input->InputEvent.Event.KeyEvent.bKeyDown)
{
- LineInputKeyDown(Console, &Input->InputEvent.Event.KeyEvent);
+ LineInputKeyDown(Console, ExeName,
+ &Input->InputEvent.Event.KeyEvent);
ReadControl->dwControlKeyState = Input->InputEvent.Event.KeyEvent.dwControlKeyState;
}
ConsoleFreeHeap(Input);
}
}
+ // FIXME: Only set if Status == STATUS_SUCCESS ???
if (NumCharsRead) *NumCharsRead = i;
return Status;
NTSTATUS NTAPI
ConDrvGetConsoleInput(IN PCONSOLE Console,
IN PCONSOLE_INPUT_BUFFER InputBuffer,
+ IN BOOLEAN KeepEvents,
IN BOOLEAN WaitForMoreEvents,
IN BOOLEAN Unicode,
OUT PINPUT_RECORD InputRecord,
/* Validity checks */
ASSERT(Console == InputBuffer->Header.Console);
- ASSERT( (InputRecord != NULL && NumEventsToRead >= 0) ||
- (InputRecord == NULL && NumEventsToRead == 0) );
+ ASSERT((InputRecord != NULL) || (InputRecord == NULL && NumEventsToRead == 0));
- // Do NOT do that !! Use the existing number of events already read, if any...
- // if (NumEventsRead) *NumEventsRead = 0;
+ if (NumEventsRead) *NumEventsRead = 0;
if (IsListEmpty(&InputBuffer->InputEvents))
{
/* Only get input if there is any */
CurrentInput = InputBuffer->InputEvents.Flink;
- if (NumEventsRead) i = *NumEventsRead; // We will read the remaining events...
-
+ i = 0;
while ((CurrentInput != &InputBuffer->InputEvents) && (i < NumEventsToRead))
{
Input = CONTAINING_RECORD(CurrentInput, ConsoleInput, ListEntry);
*InputRecord = Input->InputEvent;
- if (!Unicode)
- {
- ConioInputEventToAnsi(InputBuffer->Header.Console, InputRecord);
- }
-
++InputRecord;
++i;
CurrentInput = CurrentInput->Flink;
- if (WaitForMoreEvents) // TRUE --> Read, we remove inputs from the buffer ; FALSE --> Peek, we keep inputs.
+ /* Remove the events from the queue if needed */
+ if (!KeepEvents)
{
RemoveEntryList(&Input->ListEntry);
ConsoleFreeHeap(Input);
if (NumEventsRead) *NumEventsRead = i;
+ /* Now translate everything to ANSI */
+ if (!Unicode)
+ {
+ for (; i > 0; --i)
+ {
+ ConioInputEventToAnsi(InputBuffer->Header.Console, --InputRecord);
+ }
+ }
+
if (IsListEmpty(&InputBuffer->InputEvents))
{
ResetEvent(InputBuffer->ActiveEvent);
ConDrvWriteConsoleInput(IN PCONSOLE Console,
IN PCONSOLE_INPUT_BUFFER InputBuffer,
IN BOOLEAN Unicode,
+ IN BOOLEAN AppendToEnd,
IN PINPUT_RECORD InputRecord,
IN ULONG NumEventsToWrite,
OUT PULONG NumEventsWritten OPTIONAL)
/* Validity checks */
ASSERT(Console == InputBuffer->Header.Console);
- ASSERT( (InputRecord != NULL && NumEventsToWrite >= 0) ||
- (InputRecord == NULL && NumEventsToWrite == 0) );
-
- // Do NOT do that !! Use the existing number of events already written, if any...
- // if (NumEventsWritten) *NumEventsWritten = 0;
+ ASSERT((InputRecord != NULL) || (InputRecord == NULL && NumEventsToWrite == 0));
- for (i = (NumEventsWritten ? *NumEventsWritten : 0); i < NumEventsToWrite && NT_SUCCESS(Status); ++i)
+ /* First translate everything to UNICODE */
+ if (!Unicode)
{
- if (InputRecord->EventType == KEY_EVENT && !Unicode)
+ for (i = 0; i < NumEventsToWrite; ++i)
{
- CHAR AsciiChar = InputRecord->Event.KeyEvent.uChar.AsciiChar;
- ConsoleInputAnsiCharToUnicodeChar(Console,
- &InputRecord->Event.KeyEvent.uChar.UnicodeChar,
- &AsciiChar);
+ ConioInputEventToUnicode(Console, &InputRecord[i]);
}
-
- Status = ConioProcessInputEvent(Console, InputRecord++);
}
- if (NumEventsWritten) *NumEventsWritten = i;
+ /* Now, add the events */
+ // if (NumEventsWritten) *NumEventsWritten = 0;
+ Status = ConioAddInputEvents(Console,
+ InputRecord,
+ NumEventsToWrite,
+ NumEventsWritten,
+ AppendToEnd);
+ // if (NumEventsWritten) *NumEventsWritten = i;
return Status;
}
NTSTATUS NTAPI
ConDrvGetConsoleNumberOfInputEvents(IN PCONSOLE Console,
IN PCONSOLE_INPUT_BUFFER InputBuffer,
- OUT PULONG NumEvents)
+ OUT PULONG NumberOfEvents)
{
PLIST_ENTRY CurrentInput;
- if (Console == NULL || InputBuffer == NULL || NumEvents == NULL)
+ if (Console == NULL || InputBuffer == NULL || NumberOfEvents == NULL)
return STATUS_INVALID_PARAMETER;
/* Validity check */
ASSERT(Console == InputBuffer->Header.Console);
- *NumEvents = 0;
+ *NumberOfEvents = 0;
/* If there are any events ... */
CurrentInput = InputBuffer->InputEvents.Flink;
while (CurrentInput != &InputBuffer->InputEvents)
{
CurrentInput = CurrentInput->Flink;
- (*NumEvents)++;
+ (*NumberOfEvents)++;
}
return STATUS_SUCCESS;