[CONSRV]: Use an optional parameter for passing things to the "line discipline" funct...
[reactos.git] / win32ss / user / winsrv / consrv / condrv / coninput.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Console Driver DLL
4 * FILE: win32ss/user/winsrv/consrv/condrv/coninput.c
5 * PURPOSE: Console Input functions
6 * PROGRAMMERS: Jeffrey Morlan
7 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8 */
9
10 /* INCLUDES *******************************************************************/
11
12 #include <consrv.h>
13
14 #define NDEBUG
15 #include <debug.h>
16
17 /* GLOBALS ********************************************************************/
18
19 typedef struct ConsoleInput_t
20 {
21 LIST_ENTRY ListEntry;
22 INPUT_RECORD InputEvent;
23 } ConsoleInput;
24
25
26 /* PRIVATE FUNCTIONS **********************************************************/
27
28 // ConDrvAddInputEvents
29 static NTSTATUS
30 AddInputEvents(PCONSOLE Console,
31 PINPUT_RECORD InputRecords, // InputEvent
32 ULONG NumEventsToWrite,
33 PULONG NumEventsWritten,
34 BOOLEAN AppendToEnd)
35 {
36 NTSTATUS Status = STATUS_SUCCESS;
37 ULONG i = 0;
38 BOOLEAN SetWaitEvent = FALSE;
39
40 if (NumEventsWritten) *NumEventsWritten = 0;
41
42 /*
43 * When adding many single events, in the case of repeated mouse move or
44 * key down events, we try to coalesce them so that we do not saturate
45 * too quickly the input buffer.
46 */
47 if (NumEventsToWrite == 1 && !IsListEmpty(&Console->InputBuffer.InputEvents))
48 {
49 PINPUT_RECORD InputRecord = InputRecords; // Only one element
50 PINPUT_RECORD LastInputRecord;
51 ConsoleInput* ConInRec; // Input
52
53 /* Get the "next" event of the input buffer */
54 if (AppendToEnd)
55 {
56 /* Get the tail element */
57 ConInRec = CONTAINING_RECORD(Console->InputBuffer.InputEvents.Blink,
58 ConsoleInput, ListEntry);
59 }
60 else
61 {
62 /* Get the head element */
63 ConInRec = CONTAINING_RECORD(Console->InputBuffer.InputEvents.Flink,
64 ConsoleInput, ListEntry);
65 }
66 LastInputRecord = &ConInRec->InputEvent;
67
68 if (InputRecord->EventType == MOUSE_EVENT &&
69 InputRecord->Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
70 {
71 if (LastInputRecord->EventType == MOUSE_EVENT &&
72 LastInputRecord->Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
73 {
74 /* Update the mouse position */
75 LastInputRecord->Event.MouseEvent.dwMousePosition.X =
76 InputRecord->Event.MouseEvent.dwMousePosition.X;
77 LastInputRecord->Event.MouseEvent.dwMousePosition.Y =
78 InputRecord->Event.MouseEvent.dwMousePosition.Y;
79
80 i = 1;
81 // return STATUS_SUCCESS;
82 Status = STATUS_SUCCESS;
83 }
84 }
85 else if (InputRecord->EventType == KEY_EVENT &&
86 InputRecord->Event.KeyEvent.bKeyDown)
87 {
88 if (LastInputRecord->EventType == KEY_EVENT &&
89 LastInputRecord->Event.KeyEvent.bKeyDown &&
90 (LastInputRecord->Event.KeyEvent.wVirtualScanCode == // Same scancode
91 InputRecord->Event.KeyEvent.wVirtualScanCode) &&
92 (LastInputRecord->Event.KeyEvent.uChar.UnicodeChar == // Same character
93 InputRecord->Event.KeyEvent.uChar.UnicodeChar) &&
94 (LastInputRecord->Event.KeyEvent.dwControlKeyState == // Same Ctrl/Alt/Shift state
95 InputRecord->Event.KeyEvent.dwControlKeyState) )
96 {
97 /* Update the repeat count */
98 LastInputRecord->Event.KeyEvent.wRepeatCount +=
99 InputRecord->Event.KeyEvent.wRepeatCount;
100
101 i = 1;
102 // return STATUS_SUCCESS;
103 Status = STATUS_SUCCESS;
104 }
105 }
106 }
107
108 /* If we coalesced the only one element, we can quit */
109 if (i == 1 && Status == STATUS_SUCCESS /* && NumEventsToWrite == 1 */)
110 goto Done;
111
112 /*
113 * No event coalesced, add them in the usual way.
114 */
115
116 if (AppendToEnd)
117 {
118 /* Go to the beginning of the list */
119 // InputRecords = InputRecords;
120 }
121 else
122 {
123 /* Go to the end of the list */
124 InputRecords = &InputRecords[NumEventsToWrite - 1];
125 }
126
127 /* Set the event if the list is going to be non-empty */
128 if (IsListEmpty(&Console->InputBuffer.InputEvents))
129 SetWaitEvent = TRUE;
130
131 for (i = 0; i < NumEventsToWrite && NT_SUCCESS(Status); ++i)
132 {
133 PINPUT_RECORD InputRecord;
134 ConsoleInput* ConInRec;
135
136 if (AppendToEnd)
137 {
138 /* Select the event and go to the next one */
139 InputRecord = InputRecords++;
140 }
141 else
142 {
143 /* Select the event and go to the previous one */
144 InputRecord = InputRecords--;
145 }
146
147 /* Add event to the queue */
148 ConInRec = ConsoleAllocHeap(0, sizeof(ConsoleInput));
149 if (ConInRec == NULL)
150 {
151 // return STATUS_INSUFFICIENT_RESOURCES;
152 Status = STATUS_INSUFFICIENT_RESOURCES;
153 continue;
154 }
155
156 ConInRec->InputEvent = *InputRecord;
157
158 if (AppendToEnd)
159 {
160 /* Append the event to the end of the queue */
161 InsertTailList(&Console->InputBuffer.InputEvents, &ConInRec->ListEntry);
162 }
163 else
164 {
165 /* Append the event to the beginning of the queue */
166 InsertHeadList(&Console->InputBuffer.InputEvents, &ConInRec->ListEntry);
167 }
168
169 // return STATUS_SUCCESS;
170 Status = STATUS_SUCCESS;
171 }
172
173 if (SetWaitEvent) NtSetEvent(Console->InputBuffer.ActiveEvent, NULL);
174
175 Done:
176 if (NumEventsWritten) *NumEventsWritten = i;
177
178 return Status;
179 }
180
181 static VOID
182 PurgeInputBuffer(PCONSOLE Console)
183 {
184 PLIST_ENTRY CurrentEntry;
185 ConsoleInput* Event;
186
187 while (!IsListEmpty(&Console->InputBuffer.InputEvents))
188 {
189 CurrentEntry = RemoveHeadList(&Console->InputBuffer.InputEvents);
190 Event = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
191 ConsoleFreeHeap(Event);
192 }
193
194 // CloseHandle(Console->InputBuffer.ActiveEvent);
195 }
196
197 NTSTATUS NTAPI
198 ConDrvInitInputBuffer(IN PCONSOLE Console,
199 IN ULONG InputBufferSize)
200 {
201 NTSTATUS Status;
202 OBJECT_ATTRIBUTES ObjectAttributes;
203
204 ConSrvInitObject(&Console->InputBuffer.Header, INPUT_BUFFER, Console);
205
206 InitializeObjectAttributes(&ObjectAttributes,
207 NULL,
208 OBJ_INHERIT,
209 NULL,
210 NULL);
211
212 Status = NtCreateEvent(&Console->InputBuffer.ActiveEvent, EVENT_ALL_ACCESS,
213 &ObjectAttributes, NotificationEvent, FALSE);
214 if (!NT_SUCCESS(Status))
215 {
216 return STATUS_UNSUCCESSFUL;
217 // return Status;
218 }
219
220 Console->InputBuffer.InputBufferSize = InputBufferSize;
221 InitializeListHead(&Console->InputBuffer.InputEvents);
222 Console->InputBuffer.Mode = ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT |
223 ENABLE_ECHO_INPUT | ENABLE_MOUSE_INPUT;
224
225 return STATUS_SUCCESS;
226 }
227
228 VOID NTAPI
229 ConDrvDeinitInputBuffer(IN PCONSOLE Console)
230 {
231 PurgeInputBuffer(Console);
232 CloseHandle(Console->InputBuffer.ActiveEvent);
233 }
234
235
236 /* PUBLIC DRIVER APIS *********************************************************/
237
238 NTSTATUS NTAPI
239 ConDrvReadConsole(IN PCONSOLE Console,
240 IN PCONSOLE_INPUT_BUFFER InputBuffer,
241 IN BOOLEAN Unicode,
242 OUT PVOID Buffer,
243 IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
244 IN PVOID Parameter OPTIONAL,
245 IN ULONG NumCharsToRead,
246 OUT PULONG NumCharsRead OPTIONAL)
247 {
248 // STATUS_PENDING : Wait if more to read ; STATUS_SUCCESS : Don't wait.
249 // NTSTATUS Status; = STATUS_PENDING;
250
251 if (Console == NULL || InputBuffer == NULL || /* Buffer == NULL || */
252 ReadControl == NULL || ReadControl->nLength != sizeof(CONSOLE_READCONSOLE_CONTROL))
253 {
254 return STATUS_INVALID_PARAMETER;
255 }
256
257 /* Validity checks */
258 ASSERT(Console == InputBuffer->Header.Console);
259 ASSERT((Buffer != NULL) || (Buffer == NULL && NumCharsToRead == 0));
260
261 /* Call the line-discipline */
262 return TermReadStream(Console,
263 Unicode,
264 Buffer,
265 ReadControl,
266 Parameter,
267 NumCharsToRead,
268 NumCharsRead);
269 }
270
271 NTSTATUS NTAPI
272 ConDrvGetConsoleInput(IN PCONSOLE Console,
273 IN PCONSOLE_INPUT_BUFFER InputBuffer,
274 IN BOOLEAN KeepEvents,
275 IN BOOLEAN WaitForMoreEvents,
276 OUT PINPUT_RECORD InputRecord,
277 IN ULONG NumEventsToRead,
278 OUT PULONG NumEventsRead OPTIONAL)
279 {
280 PLIST_ENTRY CurrentInput;
281 ConsoleInput* Input;
282 ULONG i = 0;
283
284 if (Console == NULL || InputBuffer == NULL /* || InputRecord == NULL */)
285 return STATUS_INVALID_PARAMETER;
286
287 /* Validity checks */
288 ASSERT(Console == InputBuffer->Header.Console);
289 ASSERT((InputRecord != NULL) || (InputRecord == NULL && NumEventsToRead == 0));
290
291 if (NumEventsRead) *NumEventsRead = 0;
292
293 if (IsListEmpty(&InputBuffer->InputEvents))
294 {
295 /*
296 * No input is available. Wait for more input if requested,
297 * otherwise, we don't wait, so we return success.
298 */
299 return (WaitForMoreEvents ? STATUS_PENDING : STATUS_SUCCESS);
300 }
301
302 /* Only get input if there is any */
303 CurrentInput = InputBuffer->InputEvents.Flink;
304 i = 0;
305 while ((CurrentInput != &InputBuffer->InputEvents) && (i < NumEventsToRead))
306 {
307 Input = CONTAINING_RECORD(CurrentInput, ConsoleInput, ListEntry);
308
309 *InputRecord = Input->InputEvent;
310
311 ++InputRecord;
312 ++i;
313 CurrentInput = CurrentInput->Flink;
314
315 /* Remove the events from the queue if needed */
316 if (!KeepEvents)
317 {
318 RemoveEntryList(&Input->ListEntry);
319 ConsoleFreeHeap(Input);
320 }
321 }
322
323 if (NumEventsRead) *NumEventsRead = i;
324
325 if (IsListEmpty(&InputBuffer->InputEvents))
326 {
327 ResetEvent(InputBuffer->ActiveEvent);
328 }
329
330 // FIXME: If we add back UNICODE support, it's here that we need to do the translation.
331
332 /* We read all the inputs available, we return success */
333 return STATUS_SUCCESS;
334 }
335
336 NTSTATUS NTAPI
337 ConDrvWriteConsoleInput(IN PCONSOLE Console,
338 IN PCONSOLE_INPUT_BUFFER InputBuffer,
339 IN BOOLEAN AppendToEnd,
340 IN PINPUT_RECORD InputRecord,
341 IN ULONG NumEventsToWrite,
342 OUT PULONG NumEventsWritten OPTIONAL)
343 {
344 if (Console == NULL || InputBuffer == NULL /* || InputRecord == NULL */)
345 return STATUS_INVALID_PARAMETER;
346
347 /* Validity checks */
348 ASSERT(Console == InputBuffer->Header.Console);
349 ASSERT((InputRecord != NULL) || (InputRecord == NULL && NumEventsToWrite == 0));
350
351 /* Now, add the events */
352 if (NumEventsWritten) *NumEventsWritten = 0;
353
354 // FIXME: If we add back UNICODE support, it's here that we need to do the translation.
355
356 return AddInputEvents(Console,
357 InputRecord,
358 NumEventsToWrite,
359 NumEventsWritten,
360 AppendToEnd);
361 }
362
363 NTSTATUS NTAPI
364 ConDrvFlushConsoleInputBuffer(IN PCONSOLE Console,
365 IN PCONSOLE_INPUT_BUFFER InputBuffer)
366 {
367 PLIST_ENTRY CurrentEntry;
368 ConsoleInput* Event;
369
370 if (Console == NULL || InputBuffer == NULL)
371 return STATUS_INVALID_PARAMETER;
372
373 /* Validity check */
374 ASSERT(Console == InputBuffer->Header.Console);
375
376 /* Discard all entries in the input event queue */
377 while (!IsListEmpty(&InputBuffer->InputEvents))
378 {
379 CurrentEntry = RemoveHeadList(&InputBuffer->InputEvents);
380 Event = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
381 ConsoleFreeHeap(Event);
382 }
383 ResetEvent(InputBuffer->ActiveEvent);
384
385 return STATUS_SUCCESS;
386 }
387
388 NTSTATUS NTAPI
389 ConDrvGetConsoleNumberOfInputEvents(IN PCONSOLE Console,
390 IN PCONSOLE_INPUT_BUFFER InputBuffer,
391 OUT PULONG NumberOfEvents)
392 {
393 PLIST_ENTRY CurrentInput;
394
395 if (Console == NULL || InputBuffer == NULL || NumberOfEvents == NULL)
396 return STATUS_INVALID_PARAMETER;
397
398 /* Validity check */
399 ASSERT(Console == InputBuffer->Header.Console);
400
401 *NumberOfEvents = 0;
402
403 /* If there are any events ... */
404 CurrentInput = InputBuffer->InputEvents.Flink;
405 while (CurrentInput != &InputBuffer->InputEvents)
406 {
407 CurrentInput = CurrentInput->Flink;
408 (*NumberOfEvents)++;
409 }
410
411 return STATUS_SUCCESS;
412 }
413
414 /* EOF */