3 Copyright (c) 2006 - 2011, 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 KeyMapBreak (KeyData
);
107 // Simple Text In implementation.
111 Reset the input device and optionally run diagnostics
113 @param This Protocol instance pointer.
114 @param ExtendedVerification Driver may perform diagnostics on reset.
116 @retval EFI_SUCCESS The device was reset.
117 @retval EFI_DEVICE_ERROR The device is not functioning properly and could not be reset.
122 EmuGopSimpleTextInReset (
123 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
124 IN BOOLEAN ExtendedVerification
127 GOP_PRIVATE_DATA
*Private
;
128 EFI_KEY_DATA KeyData
;
131 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
132 if (Private
->EmuGraphicsWindow
== NULL
) {
137 // Enter critical section
139 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
142 // A reset is draining the Queue
144 while (Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
) == EFI_SUCCESS
)
148 // Leave critical section and return
150 gBS
->RestoreTPL (OldTpl
);
156 Reads the next keystroke from the input device. The WaitForKey Event can
157 be used to test for existence of a keystroke via WaitForEvent () call.
159 @param This Protocol instance pointer.
160 @param Key A pointer to a buffer that is filled in with the keystroke
161 information for the key that was pressed.
163 @retval EFI_SUCCESS The keystroke information was returned.
164 @retval EFI_NOT_READY There was no keystroke data available.
165 @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
171 EmuGopSimpleTextInReadKeyStroke (
172 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
173 OUT EFI_INPUT_KEY
*Key
176 GOP_PRIVATE_DATA
*Private
;
179 EFI_KEY_DATA KeyData
;
181 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
182 if (Private
->EmuGraphicsWindow
== NULL
) {
183 return EFI_NOT_READY
;
187 // Enter critical section
189 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
191 Status
= Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
);
192 if (!EFI_ERROR (Status
)) {
193 if ((KeyData
.Key
.ScanCode
== 0) && (KeyData
.Key
.UnicodeChar
== 0)) {
194 // Modifier key was pressed
195 Status
= EFI_NOT_READY
;
197 CopyMem (Key
, &KeyData
.Key
, sizeof (EFI_INPUT_KEY
));
202 // Leave critical section and return
204 gBS
->RestoreTPL (OldTpl
);
212 SimpleTextIn and SimpleTextInEx Notify Wait Event
214 @param Event Event whose notification function is being invoked.
215 @param Context Pointer to GOP_PRIVATE_DATA.
220 EmuGopSimpleTextInWaitForKey (
225 GOP_PRIVATE_DATA
*Private
;
229 Private
= (GOP_PRIVATE_DATA
*) Context
;
230 if (Private
->EmuGraphicsWindow
== NULL
) {
235 // Enter critical section
237 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
239 Status
= Private
->EmuGraphicsWindow
->CheckKey (Private
->EmuGraphicsWindow
);
240 if (!EFI_ERROR (Status
)) {
242 // If a there is a key in the queue signal our event.
244 gBS
->SignalEvent (Event
);
247 // Leave critical section and return
249 gBS
->RestoreTPL (OldTpl
);
254 // Simple Text Input Ex protocol functions
259 The Reset() function resets the input device hardware. As part
260 of initialization process, the firmware/device will make a quick
261 but reasonable attempt to verify that the device is functioning.
262 If the ExtendedVerification flag is TRUE the firmware may take
263 an extended amount of time to verify the device is operating on
264 reset. Otherwise the reset operation is to occur as quickly as
265 possible. The hardware verification process is not defined by
266 this specification and is left up to the platform firmware or
269 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
271 @param ExtendedVerification Indicates that the driver may
272 perform a more exhaustive
273 verification operation of the
277 @retval EFI_SUCCESS The device was reset.
279 @retval EFI_DEVICE_ERROR The device is not functioning
280 correctly and could not be reset.
285 EmuGopSimpleTextInExResetEx (
286 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
287 IN BOOLEAN ExtendedVerification
292 Reset the input device and optionaly run diagnostics
295 This - Protocol instance pointer.
296 ExtendedVerification - Driver may perform diagnostics on reset.
299 EFI_SUCCESS - The device was reset.
309 The function reads the next keystroke from the input device. If
310 there is no pending keystroke the function returns
311 EFI_NOT_READY. If there is a pending keystroke, then
312 KeyData.Key.ScanCode is the EFI scan code defined in Error!
313 Reference source not found. The KeyData.Key.UnicodeChar is the
314 actual printable character or is zero if the key does not
315 represent a printable character (control key, function key,
316 etc.). The KeyData.KeyState is shift state for the character
317 reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
318 When interpreting the data from this function, it should be
319 noted that if a class of printable characters that are
320 normally adjusted by shift modifiers (e.g. Shift Key + "f"
321 key) would be presented solely as a KeyData.Key.UnicodeChar
322 without the associated shift state. So in the previous example
323 of a Shift Key + "f" key being pressed, the only pertinent
324 data returned would be KeyData.Key.UnicodeChar with the value
325 of "F". This of course would not typically be the case for
326 non-printable characters such as the pressing of the Right
327 Shift Key + F10 key since the corresponding returned data
328 would be reflected both in the KeyData.KeyState.KeyShiftState
329 and KeyData.Key.ScanCode values. UEFI drivers which implement
330 the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
331 KeyData.Key and KeyData.KeyState values. These drivers must
332 always return the most current state of
333 KeyData.KeyState.KeyShiftState and
334 KeyData.KeyState.KeyToggleState. It should also be noted that
335 certain input devices may not be able to produce shift or toggle
336 state information, and in those cases the high order bit in the
337 respective Toggle and Shift state fields should not be active.
340 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
342 @param KeyData A pointer to a buffer that is filled in with
343 the keystroke state data for the key that was
347 @retval EFI_SUCCESS The keystroke information was
350 @retval EFI_NOT_READY There was no keystroke data available.
351 EFI_DEVICE_ERROR The keystroke
352 information was not returned due to
359 EmuGopSimpleTextInExReadKeyStrokeEx (
360 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
361 OUT EFI_KEY_DATA
*KeyData
366 Reads the next keystroke from the input device. The WaitForKey Event can
367 be used to test for existance of a keystroke via WaitForEvent () call.
370 This - Protocol instance pointer.
371 KeyData - A pointer to a buffer that is filled in with the keystroke
372 state data for the key that was pressed.
375 EFI_SUCCESS - The keystroke information was returned.
376 EFI_NOT_READY - There was no keystroke data availiable.
377 EFI_DEVICE_ERROR - The keystroke information was not returned due to
379 EFI_INVALID_PARAMETER - KeyData is NULL.
384 GOP_PRIVATE_DATA
*Private
;
388 if (KeyData
== NULL
) {
389 return EFI_INVALID_PARAMETER
;
392 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
393 if (Private
->EmuGraphicsWindow
== NULL
) {
394 return EFI_NOT_READY
;
398 // Enter critical section
400 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
402 Status
= Private
->EmuGraphicsWindow
->GetKey(Private
->EmuGraphicsWindow
, KeyData
);
405 // Leave critical section and return
407 gBS
->RestoreTPL (OldTpl
);
415 The SetState() function allows the input device hardware to
416 have state settings adjusted.
418 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
420 @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
421 set the state for the input device.
424 @retval EFI_SUCCESS The device state was set appropriately.
426 @retval EFI_DEVICE_ERROR The device is not functioning
427 correctly and could not have the
430 @retval EFI_UNSUPPORTED The device does not support the
431 ability to have its state set.
436 EmuGopSimpleTextInExSetState (
437 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
438 IN EFI_KEY_TOGGLE_STATE
*KeyToggleState
441 GOP_PRIVATE_DATA
*Private
;
445 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
446 if (Private
->EmuGraphicsWindow
== NULL
) {
447 return EFI_NOT_READY
;
451 // Enter critical section
453 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
455 Status
= Private
->EmuGraphicsWindow
->KeySetState (Private
->EmuGraphicsWindow
, KeyToggleState
);
457 // Leave critical section and return
459 gBS
->RestoreTPL (OldTpl
);
466 SimpleTextIn and SimpleTextInEx Notify Wait Event
468 @param Event Event whose notification function is being invoked.
469 @param Context Pointer to GOP_PRIVATE_DATA.
474 EmuGopRegisterKeyCallback (
479 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*ExNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)Context
;
481 ExNotify
->KeyNotificationFn (&ExNotify
->KeyData
);
487 The RegisterKeystrokeNotify() function registers a function
488 which will be called when a specified keystroke will occur.
490 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
492 @param KeyData A pointer to a buffer that is filled in with
493 the keystroke information for the key that was
496 @param KeyNotificationFunction Points to the function to be
497 called when the key sequence
498 is typed specified by KeyData.
501 @param NotifyHandle Points to the unique handle assigned to
502 the registered notification.
504 @retval EFI_SUCCESS The device state was set
507 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary
513 EmuGopSimpleTextInExRegisterKeyNotify (
514 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
515 IN EFI_KEY_DATA
*KeyData
,
516 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction
,
517 OUT EFI_HANDLE
*NotifyHandle
521 GOP_PRIVATE_DATA
*Private
;
522 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
524 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*NewNotify
;
526 if (KeyData
== NULL
|| KeyNotificationFunction
== NULL
|| NotifyHandle
== NULL
) {
527 return EFI_INVALID_PARAMETER
;
530 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
533 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
535 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
538 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
540 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
542 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
543 if (CurrentNotify
->KeyNotificationFn
== KeyNotificationFunction
) {
544 *NotifyHandle
= CurrentNotify
->NotifyHandle
;
551 // Allocate resource to save the notification function
553 NewNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
));
554 if (NewNotify
== NULL
) {
555 return EFI_OUT_OF_RESOURCES
;
558 NewNotify
->Signature
= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
;
559 NewNotify
->KeyNotificationFn
= KeyNotificationFunction
;
560 NewNotify
->NotifyHandle
= (EFI_HANDLE
) NewNotify
;
561 CopyMem (&NewNotify
->KeyData
, KeyData
, sizeof (KeyData
));
562 InsertTailList (&Private
->NotifyList
, &NewNotify
->NotifyEntry
);
564 Status
= gBS
->CreateEvent (
567 EmuGopRegisterKeyCallback
,
571 ASSERT_EFI_ERROR (Status
);
574 *NotifyHandle
= NewNotify
->NotifyHandle
;
582 The UnregisterKeystrokeNotify() function removes the
583 notification which was previously registered.
585 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
587 @param NotificationHandle The handle of the notification
588 function being unregistered.
590 @retval EFI_SUCCESS The device state was set appropriately.
592 @retval EFI_INVALID_PARAMETER The NotificationHandle is
598 EmuGopSimpleTextInExUnregisterKeyNotify (
599 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
600 IN EFI_HANDLE NotificationHandle
605 Remove a registered notification function from a particular keystroke.
608 This - Protocol instance pointer.
609 NotificationHandle - The handle of the notification function being unregistered.
612 EFI_SUCCESS - The notification function was unregistered successfully.
613 EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
617 GOP_PRIVATE_DATA
*Private
;
619 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
621 if (NotificationHandle
== NULL
) {
622 return EFI_INVALID_PARAMETER
;
625 if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) NotificationHandle
)->Signature
!= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
) {
626 return EFI_INVALID_PARAMETER
;
629 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
631 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
634 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
636 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
638 if (CurrentNotify
->NotifyHandle
== NotificationHandle
) {
640 // Remove the notification function from NotifyList and free resources
642 RemoveEntryList (&CurrentNotify
->NotifyEntry
);
644 gBS
->CloseEvent (CurrentNotify
->Event
);
646 gBS
->FreePool (CurrentNotify
);
652 // Can not find the specified Notification Handle
654 return EFI_INVALID_PARAMETER
;
660 Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
663 @param Private Context structure to fill in.
665 @return EFI_SUCCESS Initialization was a success
669 EmuGopInitializeSimpleTextInForWindow (
670 IN GOP_PRIVATE_DATA
*Private
676 // Initialize Simple Text In protoocol
678 Private
->SimpleTextIn
.Reset
= EmuGopSimpleTextInReset
;
679 Private
->SimpleTextIn
.ReadKeyStroke
= EmuGopSimpleTextInReadKeyStroke
;
681 Status
= gBS
->CreateEvent (
684 EmuGopSimpleTextInWaitForKey
,
686 &Private
->SimpleTextIn
.WaitForKey
688 ASSERT_EFI_ERROR (Status
);
692 // Initialize Simple Text In Ex
695 Private
->SimpleTextInEx
.Reset
= EmuGopSimpleTextInExResetEx
;
696 Private
->SimpleTextInEx
.ReadKeyStrokeEx
= EmuGopSimpleTextInExReadKeyStrokeEx
;
697 Private
->SimpleTextInEx
.SetState
= EmuGopSimpleTextInExSetState
;
698 Private
->SimpleTextInEx
.RegisterKeyNotify
= EmuGopSimpleTextInExRegisterKeyNotify
;
699 Private
->SimpleTextInEx
.UnregisterKeyNotify
= EmuGopSimpleTextInExUnregisterKeyNotify
;
701 Private
->SimpleTextInEx
.Reset (&Private
->SimpleTextInEx
, FALSE
);
703 InitializeListHead (&Private
->NotifyList
);
705 Status
= gBS
->CreateEvent (
708 EmuGopSimpleTextInWaitForKey
,
710 &Private
->SimpleTextInEx
.WaitForKeyEx
712 ASSERT_EFI_ERROR (Status
);
725 // Simple Pointer implementation.
730 Resets the pointer device hardware.
732 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
734 @param ExtendedVerification Indicates that the driver may perform a more exhaustive
735 verification operation of the device during reset.
737 @retval EFI_SUCCESS The device was reset.
738 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset.
743 EmuGopSimplePointerReset (
744 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
745 IN BOOLEAN ExtendedVerification
748 GOP_PRIVATE_DATA
*Private
;
749 EFI_SIMPLE_POINTER_STATE State
;
752 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
753 if (Private
->EmuGraphicsWindow
== NULL
) {
758 // Enter critical section
760 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
763 // A reset is draining the Queue
765 while (Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, &State
) == EFI_SUCCESS
)
769 // Leave critical section and return
771 gBS
->RestoreTPL (OldTpl
);
777 Retrieves the current state of a pointer device.
779 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
781 @param State A pointer to the state information on the pointer device.
783 @retval EFI_SUCCESS The state of the pointer device was returned in State.
784 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to
786 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's
792 EmuGopSimplePointerGetState (
793 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
794 IN OUT EFI_SIMPLE_POINTER_STATE
*State
797 GOP_PRIVATE_DATA
*Private
;
801 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
802 if (Private
->EmuGraphicsWindow
== NULL
) {
803 return EFI_NOT_READY
;
807 // Enter critical section
809 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
811 Status
= Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, State
);
813 // Leave critical section and return
815 gBS
->RestoreTPL (OldTpl
);
822 SimplePointer Notify Wait Event
824 @param Event Event whose notification function is being invoked.
825 @param Context Pointer to GOP_PRIVATE_DATA.
830 EmuGopSimplePointerWaitForInput (
835 GOP_PRIVATE_DATA
*Private
;
839 Private
= (GOP_PRIVATE_DATA
*) Context
;
840 if (Private
->EmuGraphicsWindow
== NULL
) {
845 // Enter critical section
847 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
849 Status
= Private
->EmuGraphicsWindow
->CheckPointer (Private
->EmuGraphicsWindow
);
850 if (!EFI_ERROR (Status
)) {
852 // If the pointer state has changed, signal our event.
854 gBS
->SignalEvent (Event
);
857 // Leave critical section and return
859 gBS
->RestoreTPL (OldTpl
);
864 SimplePointer constructor
866 @param Private Context structure to fill in.
868 @retval EFI_SUCCESS Constructor had success
872 EmuGopInitializeSimplePointerForWindow (
873 IN GOP_PRIVATE_DATA
*Private
879 // Initialize Simple Pointer protoocol
881 Private
->PointerMode
.ResolutionX
= 1;
882 Private
->PointerMode
.ResolutionY
= 1;
883 Private
->PointerMode
.ResolutionZ
= 1;
884 Private
->PointerMode
.LeftButton
= TRUE
;
885 Private
->PointerMode
.RightButton
= TRUE
;
887 Private
->SimplePointer
.Reset
= EmuGopSimplePointerReset
;
888 Private
->SimplePointer
.GetState
= EmuGopSimplePointerGetState
;
889 Private
->SimplePointer
.Mode
= &Private
->PointerMode
;
891 Status
= gBS
->CreateEvent (
894 EmuGopSimplePointerWaitForInput
,
896 &Private
->SimplePointer
.WaitForInput