3 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
4 Portions copyright (c) 2010 0 2011,Apple Inc. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20 GopPrivateIsKeyRegistered (
21 IN EFI_KEY_DATA
*RegsiteredData
,
22 IN EFI_KEY_DATA
*InputData
30 RegsiteredData - A pointer to a buffer that is filled in with the keystroke
31 state data for the key that was registered.
32 InputData - A pointer to a buffer that is filled in with the keystroke
33 state data for the key that was pressed.
36 TRUE - Key be pressed matches a registered key.
41 ASSERT (RegsiteredData
!= NULL
&& InputData
!= NULL
);
43 if ((RegsiteredData
->Key
.ScanCode
!= InputData
->Key
.ScanCode
) ||
44 (RegsiteredData
->Key
.UnicodeChar
!= InputData
->Key
.UnicodeChar
)) {
49 // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
51 if (RegsiteredData
->KeyState
.KeyShiftState
!= 0 &&
52 RegsiteredData
->KeyState
.KeyShiftState
!= InputData
->KeyState
.KeyShiftState
) {
55 if (RegsiteredData
->KeyState
.KeyToggleState
!= 0 &&
56 RegsiteredData
->KeyState
.KeyToggleState
!= InputData
->KeyState
.KeyToggleState
) {
67 GopPrivateMakeCallbackFunction (
69 IN EFI_KEY_DATA
*KeyData
73 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
74 GOP_PRIVATE_DATA
*Private
= (GOP_PRIVATE_DATA
*)Context
;
78 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
81 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
83 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
85 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
86 // We could be called at a high TPL so signal an event to call the registered function
88 gBS
->SignalEvent (CurrentNotify
->Event
);
96 GopPrivateBreakCallbackFunction (
98 IN EFI_KEY_DATA
*KeyData
101 GOP_PRIVATE_DATA
*Private
= (GOP_PRIVATE_DATA
*)Context
;
103 KeyMapBreak (KeyData
);
109 // Simple Text In implementation.
113 Reset the input device and optionally run diagnostics
115 @param This Protocol instance pointer.
116 @param ExtendedVerification Driver may perform diagnostics on reset.
118 @retval EFI_SUCCESS The device was reset.
119 @retval EFI_DEVICE_ERROR The device is not functioning properly and could not be reset.
124 EmuGopSimpleTextInReset (
125 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
126 IN BOOLEAN ExtendedVerification
129 GOP_PRIVATE_DATA
*Private
;
130 EFI_KEY_DATA KeyData
;
133 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
134 if (Private
->EmuGraphicsWindow
== NULL
) {
139 // Enter critical section
141 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
144 // A reset is draining the Queue
146 while (Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
) == EFI_SUCCESS
)
150 // Leave critical section and return
152 gBS
->RestoreTPL (OldTpl
);
158 Reads the next keystroke from the input device. The WaitForKey Event can
159 be used to test for existence of a keystroke via WaitForEvent () call.
161 @param This Protocol instance pointer.
162 @param Key A pointer to a buffer that is filled in with the keystroke
163 information for the key that was pressed.
165 @retval EFI_SUCCESS The keystroke information was returned.
166 @retval EFI_NOT_READY There was no keystroke data available.
167 @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
173 EmuGopSimpleTextInReadKeyStroke (
174 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
175 OUT EFI_INPUT_KEY
*Key
178 GOP_PRIVATE_DATA
*Private
;
181 EFI_KEY_DATA KeyData
;
183 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
184 if (Private
->EmuGraphicsWindow
== NULL
) {
185 return EFI_NOT_READY
;
189 // Enter critical section
191 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
193 Status
= Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
);
194 CopyMem (Key
, &KeyData
.Key
, sizeof (EFI_INPUT_KEY
));
197 // Leave critical section and return
199 gBS
->RestoreTPL (OldTpl
);
207 SimpleTextIn and SimpleTextInEx Notify Wait Event
209 @param Event Event whose notification function is being invoked.
210 @param Context Pointer to GOP_PRIVATE_DATA.
215 EmuGopSimpleTextInWaitForKey (
220 GOP_PRIVATE_DATA
*Private
;
224 Private
= (GOP_PRIVATE_DATA
*) Context
;
225 if (Private
->EmuGraphicsWindow
== NULL
) {
230 // Enter critical section
232 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
234 Status
= Private
->EmuGraphicsWindow
->CheckKey (Private
->EmuGraphicsWindow
);
235 if (!EFI_ERROR (Status
)) {
237 // If a there is a key in the queue signal our event.
239 gBS
->SignalEvent (Event
);
242 // Leave critical section and return
244 gBS
->RestoreTPL (OldTpl
);
249 // Simple Text Input Ex protocol functions
254 The Reset() function resets the input device hardware. As part
255 of initialization process, the firmware/device will make a quick
256 but reasonable attempt to verify that the device is functioning.
257 If the ExtendedVerification flag is TRUE the firmware may take
258 an extended amount of time to verify the device is operating on
259 reset. Otherwise the reset operation is to occur as quickly as
260 possible. The hardware verification process is not defined by
261 this specification and is left up to the platform firmware or
264 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
266 @param ExtendedVerification Indicates that the driver may
267 perform a more exhaustive
268 verification operation of the
272 @retval EFI_SUCCESS The device was reset.
274 @retval EFI_DEVICE_ERROR The device is not functioning
275 correctly and could not be reset.
280 EmuGopSimpleTextInExResetEx (
281 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
282 IN BOOLEAN ExtendedVerification
287 Reset the input device and optionaly run diagnostics
290 This - Protocol instance pointer.
291 ExtendedVerification - Driver may perform diagnostics on reset.
294 EFI_SUCCESS - The device was reset.
298 GOP_PRIVATE_DATA
*Private
;
300 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
308 The function reads the next keystroke from the input device. If
309 there is no pending keystroke the function returns
310 EFI_NOT_READY. If there is a pending keystroke, then
311 KeyData.Key.ScanCode is the EFI scan code defined in Error!
312 Reference source not found. The KeyData.Key.UnicodeChar is the
313 actual printable character or is zero if the key does not
314 represent a printable character (control key, function key,
315 etc.). The KeyData.KeyState is shift state for the character
316 reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
317 When interpreting the data from this function, it should be
318 noted that if a class of printable characters that are
319 normally adjusted by shift modifiers (e.g. Shift Key + "f"
320 key) would be presented solely as a KeyData.Key.UnicodeChar
321 without the associated shift state. So in the previous example
322 of a Shift Key + "f" key being pressed, the only pertinent
323 data returned would be KeyData.Key.UnicodeChar with the value
324 of "F". This of course would not typically be the case for
325 non-printable characters such as the pressing of the Right
326 Shift Key + F10 key since the corresponding returned data
327 would be reflected both in the KeyData.KeyState.KeyShiftState
328 and KeyData.Key.ScanCode values. UEFI drivers which implement
329 the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
330 KeyData.Key and KeyData.KeyState values. These drivers must
331 always return the most current state of
332 KeyData.KeyState.KeyShiftState and
333 KeyData.KeyState.KeyToggleState. It should also be noted that
334 certain input devices may not be able to produce shift or toggle
335 state information, and in those cases the high order bit in the
336 respective Toggle and Shift state fields should not be active.
339 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
341 @param KeyData A pointer to a buffer that is filled in with
342 the keystroke state data for the key that was
346 @retval EFI_SUCCESS The keystroke information was
349 @retval EFI_NOT_READY There was no keystroke data available.
350 EFI_DEVICE_ERROR The keystroke
351 information was not returned due to
358 EmuGopSimpleTextInExReadKeyStrokeEx (
359 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
360 OUT EFI_KEY_DATA
*KeyData
365 Reads the next keystroke from the input device. The WaitForKey Event can
366 be used to test for existance of a keystroke via WaitForEvent () call.
369 This - Protocol instance pointer.
370 KeyData - A pointer to a buffer that is filled in with the keystroke
371 state data for the key that was pressed.
374 EFI_SUCCESS - The keystroke information was returned.
375 EFI_NOT_READY - There was no keystroke data availiable.
376 EFI_DEVICE_ERROR - The keystroke information was not returned due to
378 EFI_INVALID_PARAMETER - KeyData is NULL.
383 GOP_PRIVATE_DATA
*Private
;
387 if (KeyData
== NULL
) {
388 return EFI_INVALID_PARAMETER
;
391 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
392 if (Private
->EmuGraphicsWindow
== NULL
) {
393 return EFI_NOT_READY
;
397 // Enter critical section
399 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
401 Status
= Private
->EmuGraphicsWindow
->GetKey(Private
->EmuGraphicsWindow
, KeyData
);
404 // Leave critical section and return
406 gBS
->RestoreTPL (OldTpl
);
414 The SetState() function allows the input device hardware to
415 have state settings adjusted.
417 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
419 @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
420 set the state for the input device.
423 @retval EFI_SUCCESS The device state was set appropriately.
425 @retval EFI_DEVICE_ERROR The device is not functioning
426 correctly and could not have the
429 @retval EFI_UNSUPPORTED The device does not support the
430 ability to have its state set.
435 EmuGopSimpleTextInExSetState (
436 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
437 IN EFI_KEY_TOGGLE_STATE
*KeyToggleState
440 GOP_PRIVATE_DATA
*Private
;
444 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
445 if (Private
->EmuGraphicsWindow
== NULL
) {
446 return EFI_NOT_READY
;
450 // Enter critical section
452 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
454 Status
= Private
->EmuGraphicsWindow
->KeySetState (Private
->EmuGraphicsWindow
, KeyToggleState
);
456 // Leave critical section and return
458 gBS
->RestoreTPL (OldTpl
);
465 SimpleTextIn and SimpleTextInEx Notify Wait Event
467 @param Event Event whose notification function is being invoked.
468 @param Context Pointer to GOP_PRIVATE_DATA.
473 EmuGopRegisterKeyCallback (
478 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*ExNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)Context
;
480 ExNotify
->KeyNotificationFn (&ExNotify
->KeyData
);
486 The RegisterKeystrokeNotify() function registers a function
487 which will be called when a specified keystroke will occur.
489 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
491 @param KeyData A pointer to a buffer that is filled in with
492 the keystroke information for the key that was
495 @param KeyNotificationFunction Points to the function to be
496 called when the key sequence
497 is typed specified by KeyData.
500 @param NotifyHandle Points to the unique handle assigned to
501 the registered notification.
503 @retval EFI_SUCCESS The device state was set
506 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary
512 EmuGopSimpleTextInExRegisterKeyNotify (
513 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
514 IN EFI_KEY_DATA
*KeyData
,
515 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction
,
516 OUT EFI_HANDLE
*NotifyHandle
520 GOP_PRIVATE_DATA
*Private
;
521 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
523 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*NewNotify
;
525 if (KeyData
== NULL
|| KeyNotificationFunction
== NULL
|| NotifyHandle
== NULL
) {
526 return EFI_INVALID_PARAMETER
;
529 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
532 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
534 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
537 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
539 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
541 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
542 if (CurrentNotify
->KeyNotificationFn
== KeyNotificationFunction
) {
543 *NotifyHandle
= CurrentNotify
->NotifyHandle
;
550 // Allocate resource to save the notification function
552 NewNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
));
553 if (NewNotify
== NULL
) {
554 return EFI_OUT_OF_RESOURCES
;
557 NewNotify
->Signature
= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
;
558 NewNotify
->KeyNotificationFn
= KeyNotificationFunction
;
559 NewNotify
->NotifyHandle
= (EFI_HANDLE
) NewNotify
;
560 CopyMem (&NewNotify
->KeyData
, KeyData
, sizeof (KeyData
));
561 InsertTailList (&Private
->NotifyList
, &NewNotify
->NotifyEntry
);
563 Status
= gBS
->CreateEvent (
566 EmuGopRegisterKeyCallback
,
570 ASSERT_EFI_ERROR (Status
);
573 *NotifyHandle
= NewNotify
->NotifyHandle
;
581 The UnregisterKeystrokeNotify() function removes the
582 notification which was previously registered.
584 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
586 @param NotificationHandle The handle of the notification
587 function being unregistered.
589 @retval EFI_SUCCESS The device state was set appropriately.
591 @retval EFI_INVALID_PARAMETER The NotificationHandle is
597 EmuGopSimpleTextInExUnregisterKeyNotify (
598 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
599 IN EFI_HANDLE NotificationHandle
604 Remove a registered notification function from a particular keystroke.
607 This - Protocol instance pointer.
608 NotificationHandle - The handle of the notification function being unregistered.
611 EFI_SUCCESS - The notification function was unregistered successfully.
612 EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
616 GOP_PRIVATE_DATA
*Private
;
618 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
620 if (NotificationHandle
== NULL
) {
621 return EFI_INVALID_PARAMETER
;
624 if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) NotificationHandle
)->Signature
!= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
) {
625 return EFI_INVALID_PARAMETER
;
628 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
630 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
633 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
635 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
637 if (CurrentNotify
->NotifyHandle
== NotificationHandle
) {
639 // Remove the notification function from NotifyList and free resources
641 RemoveEntryList (&CurrentNotify
->NotifyEntry
);
643 gBS
->CloseEvent (CurrentNotify
->Event
);
645 gBS
->FreePool (CurrentNotify
);
651 // Can not find the specified Notification Handle
653 return EFI_INVALID_PARAMETER
;
659 Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
662 @param Private Context structure to fill in.
664 @return EFI_SUCCESS Initialization was a success
668 EmuGopInitializeSimpleTextInForWindow (
669 IN GOP_PRIVATE_DATA
*Private
675 // Initialize Simple Text In protoocol
677 Private
->SimpleTextIn
.Reset
= EmuGopSimpleTextInReset
;
678 Private
->SimpleTextIn
.ReadKeyStroke
= EmuGopSimpleTextInReadKeyStroke
;
680 Status
= gBS
->CreateEvent (
683 EmuGopSimpleTextInWaitForKey
,
685 &Private
->SimpleTextIn
.WaitForKey
687 ASSERT_EFI_ERROR (Status
);
691 // Initialize Simple Text In Ex
694 Private
->SimpleTextInEx
.Reset
= EmuGopSimpleTextInExResetEx
;
695 Private
->SimpleTextInEx
.ReadKeyStrokeEx
= EmuGopSimpleTextInExReadKeyStrokeEx
;
696 Private
->SimpleTextInEx
.SetState
= EmuGopSimpleTextInExSetState
;
697 Private
->SimpleTextInEx
.RegisterKeyNotify
= EmuGopSimpleTextInExRegisterKeyNotify
;
698 Private
->SimpleTextInEx
.UnregisterKeyNotify
= EmuGopSimpleTextInExUnregisterKeyNotify
;
700 Private
->SimpleTextInEx
.Reset (&Private
->SimpleTextInEx
, FALSE
);
702 InitializeListHead (&Private
->NotifyList
);
704 Status
= gBS
->CreateEvent (
707 EmuGopSimpleTextInWaitForKey
,
709 &Private
->SimpleTextInEx
.WaitForKeyEx
711 ASSERT_EFI_ERROR (Status
);
724 // Simple Pointer implementation.
729 Resets the pointer device hardware.
731 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
733 @param ExtendedVerification Indicates that the driver may perform a more exhaustive
734 verification operation of the device during reset.
736 @retval EFI_SUCCESS The device was reset.
737 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset.
742 EmuGopSimplePointerReset (
743 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
744 IN BOOLEAN ExtendedVerification
747 GOP_PRIVATE_DATA
*Private
;
748 EFI_SIMPLE_POINTER_STATE State
;
751 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
752 if (Private
->EmuGraphicsWindow
== NULL
) {
757 // Enter critical section
759 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
762 // A reset is draining the Queue
764 while (Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, &State
) == EFI_SUCCESS
)
768 // Leave critical section and return
770 gBS
->RestoreTPL (OldTpl
);
776 Retrieves the current state of a pointer device.
778 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
780 @param State A pointer to the state information on the pointer device.
782 @retval EFI_SUCCESS The state of the pointer device was returned in State.
783 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to
785 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's
791 EmuGopSimplePointerGetState (
792 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
793 IN OUT EFI_SIMPLE_POINTER_STATE
*State
796 GOP_PRIVATE_DATA
*Private
;
800 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
801 if (Private
->EmuGraphicsWindow
== NULL
) {
802 return EFI_NOT_READY
;
806 // Enter critical section
808 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
810 Status
= Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, State
);
812 // Leave critical section and return
814 gBS
->RestoreTPL (OldTpl
);
821 SimplePointer Notify Wait Event
823 @param Event Event whose notification function is being invoked.
824 @param Context Pointer to GOP_PRIVATE_DATA.
829 EmuGopSimplePointerWaitForInput (
834 GOP_PRIVATE_DATA
*Private
;
838 Private
= (GOP_PRIVATE_DATA
*) Context
;
839 if (Private
->EmuGraphicsWindow
== NULL
) {
844 // Enter critical section
846 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
848 Status
= Private
->EmuGraphicsWindow
->CheckPointer (Private
->EmuGraphicsWindow
);
849 if (!EFI_ERROR (Status
)) {
851 // If the pointer state has changed, signal our event.
853 gBS
->SignalEvent (Event
);
856 // Leave critical section and return
858 gBS
->RestoreTPL (OldTpl
);
863 SimplePointer constructor
865 @param Private Context structure to fill in.
867 @retval EFI_SUCCESS Constructor had success
871 EmuGopInitializeSimplePointerForWindow (
872 IN GOP_PRIVATE_DATA
*Private
878 // Initialize Simple Pointer protoocol
880 Private
->PointerMode
.ResolutionX
= 1;
881 Private
->PointerMode
.ResolutionY
= 1;
882 Private
->PointerMode
.ResolutionZ
= 1;
883 Private
->PointerMode
.LeftButton
= TRUE
;
884 Private
->PointerMode
.RightButton
= TRUE
;
886 Private
->SimplePointer
.Reset
= EmuGopSimplePointerReset
;
887 Private
->SimplePointer
.GetState
= EmuGopSimplePointerGetState
;
888 Private
->SimplePointer
.Mode
= &Private
->PointerMode
;
890 Status
= gBS
->CreateEvent (
893 EmuGopSimplePointerWaitForInput
,
895 &Private
->SimplePointer
.WaitForInput