3 Copyright (c) 2006 - 2018, 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_EX_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 if (KeyToggleState
== NULL
) {
446 return EFI_INVALID_PARAMETER
;
449 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
450 if (Private
->EmuGraphicsWindow
== NULL
) {
451 return EFI_NOT_READY
;
454 if (((Private
->KeyState
.KeyToggleState
& EFI_TOGGLE_STATE_VALID
) != EFI_TOGGLE_STATE_VALID
) ||
455 ((*KeyToggleState
& EFI_TOGGLE_STATE_VALID
) != EFI_TOGGLE_STATE_VALID
)) {
456 return EFI_UNSUPPORTED
;
460 // Enter critical section
462 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
464 Status
= Private
->EmuGraphicsWindow
->KeySetState (Private
->EmuGraphicsWindow
, KeyToggleState
);
466 // Leave critical section and return
468 gBS
->RestoreTPL (OldTpl
);
475 SimpleTextIn and SimpleTextInEx Notify Wait Event
477 @param Event Event whose notification function is being invoked.
478 @param Context Pointer to GOP_PRIVATE_DATA.
483 EmuGopRegisterKeyCallback (
488 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*ExNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)Context
;
490 ExNotify
->KeyNotificationFn (&ExNotify
->KeyData
);
496 The RegisterKeystrokeNotify() function registers a function
497 which will be called when a specified keystroke will occur.
499 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
501 @param KeyData A pointer to a buffer that is filled in with
502 the keystroke information for the key that was
505 @param KeyNotificationFunction Points to the function to be
506 called when the key sequence
507 is typed specified by KeyData.
510 @param NotifyHandle Points to the unique handle assigned to
511 the registered notification.
513 @retval EFI_SUCCESS The device state was set
516 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary
522 EmuGopSimpleTextInExRegisterKeyNotify (
523 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
524 IN EFI_KEY_DATA
*KeyData
,
525 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction
,
526 OUT EFI_HANDLE
*NotifyHandle
530 GOP_PRIVATE_DATA
*Private
;
531 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
533 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*NewNotify
;
535 if (KeyData
== NULL
|| KeyNotificationFunction
== NULL
|| NotifyHandle
== NULL
) {
536 return EFI_INVALID_PARAMETER
;
539 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
542 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
544 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
547 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
549 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
551 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
552 if (CurrentNotify
->KeyNotificationFn
== KeyNotificationFunction
) {
553 *NotifyHandle
= CurrentNotify
->NotifyHandle
;
560 // Allocate resource to save the notification function
562 NewNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
));
563 if (NewNotify
== NULL
) {
564 return EFI_OUT_OF_RESOURCES
;
567 NewNotify
->Signature
= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
;
568 NewNotify
->KeyNotificationFn
= KeyNotificationFunction
;
569 NewNotify
->NotifyHandle
= (EFI_HANDLE
) NewNotify
;
570 CopyMem (&NewNotify
->KeyData
, KeyData
, sizeof (KeyData
));
571 InsertTailList (&Private
->NotifyList
, &NewNotify
->NotifyEntry
);
573 Status
= gBS
->CreateEvent (
576 EmuGopRegisterKeyCallback
,
580 ASSERT_EFI_ERROR (Status
);
583 *NotifyHandle
= NewNotify
->NotifyHandle
;
591 The UnregisterKeystrokeNotify() function removes the
592 notification which was previously registered.
594 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
596 @param NotificationHandle The handle of the notification
597 function being unregistered.
599 @retval EFI_SUCCESS The device state was set appropriately.
601 @retval EFI_INVALID_PARAMETER The NotificationHandle is
607 EmuGopSimpleTextInExUnregisterKeyNotify (
608 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
609 IN EFI_HANDLE NotificationHandle
614 Remove a registered notification function from a particular keystroke.
617 This - Protocol instance pointer.
618 NotificationHandle - The handle of the notification function being unregistered.
621 EFI_SUCCESS - The notification function was unregistered successfully.
622 EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
626 GOP_PRIVATE_DATA
*Private
;
628 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
630 if (NotificationHandle
== NULL
) {
631 return EFI_INVALID_PARAMETER
;
634 if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) NotificationHandle
)->Signature
!= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
) {
635 return EFI_INVALID_PARAMETER
;
638 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
640 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
643 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
645 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
647 if (CurrentNotify
->NotifyHandle
== NotificationHandle
) {
649 // Remove the notification function from NotifyList and free resources
651 RemoveEntryList (&CurrentNotify
->NotifyEntry
);
653 gBS
->CloseEvent (CurrentNotify
->Event
);
655 gBS
->FreePool (CurrentNotify
);
661 // Can not find the specified Notification Handle
663 return EFI_INVALID_PARAMETER
;
669 Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
672 @param Private Context structure to fill in.
674 @return EFI_SUCCESS Initialization was a success
678 EmuGopInitializeSimpleTextInForWindow (
679 IN GOP_PRIVATE_DATA
*Private
685 // Initialize Simple Text In protoocol
687 Private
->SimpleTextIn
.Reset
= EmuGopSimpleTextInReset
;
688 Private
->SimpleTextIn
.ReadKeyStroke
= EmuGopSimpleTextInReadKeyStroke
;
690 Status
= gBS
->CreateEvent (
693 EmuGopSimpleTextInWaitForKey
,
695 &Private
->SimpleTextIn
.WaitForKey
697 ASSERT_EFI_ERROR (Status
);
701 // Initialize Simple Text In Ex
704 Private
->SimpleTextInEx
.Reset
= EmuGopSimpleTextInExResetEx
;
705 Private
->SimpleTextInEx
.ReadKeyStrokeEx
= EmuGopSimpleTextInExReadKeyStrokeEx
;
706 Private
->SimpleTextInEx
.SetState
= EmuGopSimpleTextInExSetState
;
707 Private
->SimpleTextInEx
.RegisterKeyNotify
= EmuGopSimpleTextInExRegisterKeyNotify
;
708 Private
->SimpleTextInEx
.UnregisterKeyNotify
= EmuGopSimpleTextInExUnregisterKeyNotify
;
710 Private
->SimpleTextInEx
.Reset (&Private
->SimpleTextInEx
, FALSE
);
712 InitializeListHead (&Private
->NotifyList
);
714 Status
= gBS
->CreateEvent (
717 EmuGopSimpleTextInWaitForKey
,
719 &Private
->SimpleTextInEx
.WaitForKeyEx
721 ASSERT_EFI_ERROR (Status
);
734 // Simple Pointer implementation.
739 Resets the pointer device hardware.
741 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
743 @param ExtendedVerification Indicates that the driver may perform a more exhaustive
744 verification operation of the device during reset.
746 @retval EFI_SUCCESS The device was reset.
747 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset.
752 EmuGopSimplePointerReset (
753 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
754 IN BOOLEAN ExtendedVerification
757 GOP_PRIVATE_DATA
*Private
;
758 EFI_SIMPLE_POINTER_STATE State
;
761 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
762 if (Private
->EmuGraphicsWindow
== NULL
) {
767 // Enter critical section
769 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
772 // A reset is draining the Queue
774 while (Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, &State
) == EFI_SUCCESS
)
778 // Leave critical section and return
780 gBS
->RestoreTPL (OldTpl
);
786 Retrieves the current state of a pointer device.
788 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
790 @param State A pointer to the state information on the pointer device.
792 @retval EFI_SUCCESS The state of the pointer device was returned in State.
793 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to
795 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's
801 EmuGopSimplePointerGetState (
802 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
803 IN OUT EFI_SIMPLE_POINTER_STATE
*State
806 GOP_PRIVATE_DATA
*Private
;
810 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
811 if (Private
->EmuGraphicsWindow
== NULL
) {
812 return EFI_NOT_READY
;
816 // Enter critical section
818 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
820 Status
= Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, State
);
822 // Leave critical section and return
824 gBS
->RestoreTPL (OldTpl
);
831 SimplePointer Notify Wait Event
833 @param Event Event whose notification function is being invoked.
834 @param Context Pointer to GOP_PRIVATE_DATA.
839 EmuGopSimplePointerWaitForInput (
844 GOP_PRIVATE_DATA
*Private
;
848 Private
= (GOP_PRIVATE_DATA
*) Context
;
849 if (Private
->EmuGraphicsWindow
== NULL
) {
854 // Enter critical section
856 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
858 Status
= Private
->EmuGraphicsWindow
->CheckPointer (Private
->EmuGraphicsWindow
);
859 if (!EFI_ERROR (Status
)) {
861 // If the pointer state has changed, signal our event.
863 gBS
->SignalEvent (Event
);
866 // Leave critical section and return
868 gBS
->RestoreTPL (OldTpl
);
873 SimplePointer constructor
875 @param Private Context structure to fill in.
877 @retval EFI_SUCCESS Constructor had success
881 EmuGopInitializeSimplePointerForWindow (
882 IN GOP_PRIVATE_DATA
*Private
888 // Initialize Simple Pointer protoocol
890 Private
->PointerMode
.ResolutionX
= 1;
891 Private
->PointerMode
.ResolutionY
= 1;
892 Private
->PointerMode
.ResolutionZ
= 1;
893 Private
->PointerMode
.LeftButton
= TRUE
;
894 Private
->PointerMode
.RightButton
= TRUE
;
896 Private
->SimplePointer
.Reset
= EmuGopSimplePointerReset
;
897 Private
->SimplePointer
.GetState
= EmuGopSimplePointerGetState
;
898 Private
->SimplePointer
.Mode
= &Private
->PointerMode
;
900 Status
= gBS
->CreateEvent (
903 EmuGopSimplePointerWaitForInput
,
905 &Private
->SimplePointer
.WaitForInput