/*++
Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
-Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
--*/
+#include <Common/UnixInclude.h>
#include <sys/ipc.h>
#include <sys/shm.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "PiPei.h"
-#include "Protocol/UnixThunk.h"
-#include "Protocol/SimpleTextIn.h"
-#include "Protocol/UgaDraw.h"
-#include "Protocol/UnixUgaIo.h"
+
+#include <PiPei.h>
+#include <Protocol/SimplePointer.h>
+#include <Protocol/SimpleTextIn.h>
+#include <Protocol/SimpleTextInEx.h>
+#include <Protocol/UgaDraw.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/extensions/XShm.h>
#include <X11/keysym.h>
+#include <X11/cursorfont.h>
+
+#include <Protocol/UnixThunk.h>
+#include <Protocol/UnixUgaIo.h>
#include <Ppi/StatusCode.h>
#include <Library/PcdLib.h>
#include <Library/DebugLib.h>
+#include "Gasket.h"
+#include "SecMain.h"
+
+
extern void msSleep (unsigned long Milliseconds);
/* XQueryPointer */
-struct uga_drv_shift_mask
-{
+struct uga_drv_shift_mask {
unsigned char shift;
unsigned char size;
unsigned char csize;
};
#define NBR_KEYS 32
-typedef struct
-{
+typedef struct {
EFI_UNIX_UGA_IO_PROTOCOL UgaIo;
Display *display;
- int screen; /* values for window_size in main */
+ int screen; /* values for window_size in main */
Window win;
GC gc;
Visual *visual;
unsigned int key_rd;
unsigned int key_wr;
unsigned int key_count;
- EFI_INPUT_KEY keys[NBR_KEYS];
+ EFI_KEY_DATA keys[NBR_KEYS];
+
+ EFI_KEY_STATE KeyState;
+
+ UGA_REGISTER_KEY_NOTIFY_CALLBACK RegisterdKeyCallback;
+ VOID *RegisterdKeyCallbackContext;
+
+ int previous_x;
+ int previous_y;
+ EFI_SIMPLE_POINTER_STATE pointer_state;
+ int pointer_state_changed;
} UGA_IO_PRIVATE;
void
{
KeySym keysym;
char str[4];
- EFI_INPUT_KEY Key;
+ EFI_KEY_DATA KeyData;
int res;
if (drv->key_count == NBR_KEYS)
return;
res = XLookupString(&ev->xkey, str, sizeof(str), &keysym, NULL);
- Key.ScanCode = 0;
- Key.UnicodeChar = 0;
+ KeyData.Key.ScanCode = 0;
+ KeyData.Key.UnicodeChar = 0;
+ KeyData.KeyState.KeyShiftState = 0;
+
+ //
+ // KeyRelease is not supported (on Mac) so we can not easily implement Ex functions.
+ // If a modifier key is hit by its self we get a keysym. If a modfifier and key is hit
+ // we get the state bit set and keysym is the modified key.
+ //
+ // We use lack of state bits being set to clear ToggleState and KeyShiftState. We can
+ // also use the stat bits to set ToggleState and KeyShiftState.
+ // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs
+ //
+ if ((ev->xkey.state & LockMask) == 0) {
+ drv->KeyState.KeyToggleState &= ~EFI_CAPS_LOCK_ACTIVE;
+ } else {
+ drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
+ }
+
+ if ((ev->xkey.state & ControlMask) == 0) {
+ drv->KeyState.KeyShiftState &= ~(EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED);
+ } else if ((drv->KeyState.KeyShiftState & EFI_RIGHT_CONTROL_PRESSED) == 0) {
+ drv->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
+ }
+
+ if ((ev->xkey.state & ShiftMask) == 0) {
+ drv->KeyState.KeyShiftState &= ~(EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED);
+ } else if ((drv->KeyState.KeyShiftState & EFI_RIGHT_SHIFT_PRESSED) == 0) {
+ drv->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
+ }
+
+ if ((ev->xkey.state & Mod2Mask) == 0) {
+ drv->KeyState.KeyShiftState &= ~(EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED);
+ } else if ((drv->KeyState.KeyShiftState & EFI_RIGHT_LOGO_PRESSED) == 0) {
+ drv->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
+ }
+
+ if ((ev->xkey.state & 0x2000) == 0) {
+ drv->KeyState.KeyShiftState &= ~(EFI_LEFT_ALT_PRESSED);
+ } else {
+ drv->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;
+ }
+
+
switch (keysym) {
- case XK_Home: Key.ScanCode = SCAN_HOME; break;
- case XK_End: Key.ScanCode = SCAN_END; break;
- case XK_Left: Key.ScanCode = SCAN_LEFT; break;
- case XK_Right: Key.ScanCode = SCAN_RIGHT; break;
- case XK_Up: Key.ScanCode = SCAN_UP; break;
- case XK_Down: Key.ScanCode = SCAN_DOWN; break;
- case XK_Delete: Key.ScanCode = SCAN_DELETE; break;
- case XK_Insert: Key.ScanCode = SCAN_INSERT; break;
- case XK_Page_Up: Key.ScanCode = SCAN_PAGE_UP; break;
- case XK_Page_Down: Key.ScanCode = SCAN_PAGE_DOWN; break;
- case XK_Escape: Key.ScanCode = SCAN_ESC; break;
-
- case XK_F1: Key.ScanCode = SCAN_F1; break;
- case XK_F2: Key.ScanCode = SCAN_F2; break;
- case XK_F3: Key.ScanCode = SCAN_F3; break;
- case XK_F4: Key.ScanCode = SCAN_F4; break;
- case XK_F5: Key.ScanCode = SCAN_F5; break;
- case XK_F6: Key.ScanCode = SCAN_F6; break;
- case XK_F7: Key.ScanCode = SCAN_F7; break;
- case XK_F8: Key.ScanCode = SCAN_F8; break;
- case XK_F9: Key.ScanCode = SCAN_F9; break;
+ case XK_Control_R:
+ drv->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
+ break;
+ case XK_Control_L:
+ drv->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
+ break;
+
+ case XK_Shift_R:
+ drv->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
+ break;
+ case XK_Shift_L:
+ drv->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
+ break;
+
+ case XK_Mode_switch:
+ drv->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;
+ break;
+
+ case XK_Meta_R:
+ drv->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
+ break;
+ case XK_Meta_L:
+ drv->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
+ break;
+
+ case XK_Home: KeyData.Key.ScanCode = SCAN_HOME; break;
+ case XK_End: KeyData.Key.ScanCode = SCAN_END; break;
+ case XK_Left: KeyData.Key.ScanCode = SCAN_LEFT; break;
+ case XK_Right: KeyData.Key.ScanCode = SCAN_RIGHT; break;
+ case XK_Up: KeyData.Key.ScanCode = SCAN_UP; break;
+ case XK_Down: KeyData.Key.ScanCode = SCAN_DOWN; break;
+ case XK_Delete: KeyData.Key.ScanCode = SCAN_DELETE; break;
+ case XK_Insert: KeyData.Key.ScanCode = SCAN_INSERT; break;
+ case XK_Page_Up: KeyData.Key.ScanCode = SCAN_PAGE_UP; break;
+ case XK_Page_Down: KeyData.Key.ScanCode = SCAN_PAGE_DOWN; break;
+ case XK_Escape: KeyData.Key.ScanCode = SCAN_ESC; break;
+
+ case XK_F1: KeyData.Key.ScanCode = SCAN_F1; break;
+ case XK_F2: KeyData.Key.ScanCode = SCAN_F2; break;
+ case XK_F3: KeyData.Key.ScanCode = SCAN_F3; break;
+ case XK_F4: KeyData.Key.ScanCode = SCAN_F4; break;
+ case XK_F5: KeyData.Key.ScanCode = SCAN_F5; break;
+ case XK_F6: KeyData.Key.ScanCode = SCAN_F6; break;
+ case XK_F7: KeyData.Key.ScanCode = SCAN_F7; break;
+ case XK_F8: KeyData.Key.ScanCode = SCAN_F8; break;
+ case XK_F9: KeyData.Key.ScanCode = SCAN_F9; break;
default:
if (res == 1) {
- Key.UnicodeChar = str[0];
+ KeyData.Key.UnicodeChar = str[0];
} else {
return;
}
}
- drv->keys[drv->key_wr] = Key;
+ // The global state is our state
+ KeyData.KeyState.KeyShiftState = drv->KeyState.KeyShiftState;
+ KeyData.KeyState.KeyToggleState = drv->KeyState.KeyToggleState;
+
+ CopyMem (&drv->keys[drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA));
drv->key_wr = (drv->key_wr + 1) % NBR_KEYS;
drv->key_count++;
+
+
+#if defined(__APPLE__) || defined(MDE_CPU_X64)
+ ReverseGasketUint64Uint64 (drv->RegisterdKeyCallback ,drv->RegisterdKeyCallbackContext, &KeyData);
+#else
+ drv->RegisterdKeyCallback (drv->RegisterdKeyCallbackContext, &KeyData);
+#endif
+
+
+}
+
+
+void
+handleMouseMoved(UGA_IO_PRIVATE *drv, XEvent *ev)
+{
+ if ( ev->xmotion.x != drv->previous_x )
+ {
+ drv->pointer_state.RelativeMovementX += ( ev->xmotion.x - drv->previous_x );
+ drv->previous_x = ev->xmotion.x;
+ drv->pointer_state_changed = 1;
+ }
+
+ if ( ev->xmotion.y != drv->previous_y )
+ {
+ drv->pointer_state.RelativeMovementY += ( ev->xmotion.y - drv->previous_y );
+ drv->previous_y = ev->xmotion.y;
+ drv->pointer_state_changed = 1;
+ }
+
+ drv->pointer_state.RelativeMovementZ = 0;
+}
+
+void
+handleMouseDown(UGA_IO_PRIVATE *drv, XEvent *ev, BOOLEAN Pressed)
+{
+ if ( ev->xbutton.button == Button1 )
+ {
+ drv->pointer_state_changed = ( drv->pointer_state.LeftButton != Pressed );
+ drv->pointer_state.LeftButton = Pressed;
+ }
+ if ( ev->xbutton.button == Button2 )
+ {
+ drv->pointer_state_changed = ( drv->pointer_state.RightButton != Pressed );
+ drv->pointer_state.RightButton = Pressed;
+ }
}
void
case KeyPress:
handleKeyEvent(drv, ev);
break;
+ case KeyRelease:
+ break;
case MappingNotify:
XRefreshKeyboardMapping(&ev->xmapping);
break;
+ case MotionNotify:
+ handleMouseMoved(drv, ev);
+ break;
+ case ButtonPress:
+ handleMouseDown(drv, ev, TRUE);
+ break;
+ case ButtonRelease:
+ handleMouseDown(drv, ev, FALSE);
+ break;
#if 0
case DestroyNotify:
XCloseDisplay (drv->display);
return res;
}
-EFI_STATUS
-UgaCheckKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
+STATIC EFI_STATUS
+CheckKeyInternal( UGA_IO_PRIVATE *drv, BOOLEAN delay )
{
- UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
HandleEvents(drv);
-
- if (drv->key_count != 0) {
+ if (drv->key_count != 0)
return EFI_SUCCESS;
- } else {
- /* EFI is certainly polling. Be CPU-friendly. */
+ if ( delay )
+ /* EFI is polling. Be CPU-friendly. */
msSleep (20);
return EFI_NOT_READY;
}
+
+EFI_STATUS
+UgaCheckKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
+{
+ UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
+ return( CheckKeyInternal( drv, TRUE ) );
}
EFI_STATUS
-UgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_INPUT_KEY *key)
+EFIAPI
+UgaGetKey (
+ IN EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
+ IN EFI_KEY_DATA *KeyData
+ )
{
UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
EFI_STATUS status;
- status = UgaCheckKey(UgaIo);
+ status = CheckKeyInternal(drv, FALSE);
if (status != EFI_SUCCESS)
return status;
- *key = drv->keys[drv->key_rd];
+ CopyMem (KeyData, &drv->keys[drv->key_rd], sizeof (EFI_KEY_DATA));
drv->key_rd = (drv->key_rd + 1) % NBR_KEYS;
drv->key_count--;
return EFI_SUCCESS;
}
+
+EFI_STATUS
+EFIAPI
+UgaKeySetState (
+ IN EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
+ IN EFI_KEY_TOGGLE_STATE *KeyToggleState
+ )
+{
+ UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
+// XKeyEvent event;
+
+ if (*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) {
+ if ((drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == 0) {
+ //
+ // We could create an XKeyEvent and send a XK_Caps_Lock to
+ // the UGA/GOP Window
+ //
+ }
+ }
+
+ drv->KeyState.KeyToggleState = *KeyToggleState;
+ return EFI_SUCCESS;
+}
+
+
EFI_STATUS
-UgaBlt(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
- IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
- IN EFI_UGA_BLT_OPERATION BltOperation,
- IN UINTN SourceX,
- IN UINTN SourceY,
- IN UINTN DestinationX,
- IN UINTN DestinationY,
- IN UINTN Width,
- IN UINTN Height,
- IN UINTN Delta OPTIONAL
+EFIAPI
+UgaRegisterKeyNotify (
+ IN EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
+ IN UGA_REGISTER_KEY_NOTIFY_CALLBACK CallBack,
+ IN VOID *Context
+ )
+{
+ UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
+
+ drv->RegisterdKeyCallback = CallBack;
+ drv->RegisterdKeyCallbackContext = Context;
+
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+UgaBlt(
+ IN EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
+ IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
+ IN EFI_UGA_BLT_OPERATION BltOperation,
+ IN UGA_BLT_ARGS *Args
)
{
UGA_IO_PRIVATE *Private = (UGA_IO_PRIVATE *)UgaIo;
//
// Source is Video.
//
- if (SourceY + Height > Private->height) {
+ if (Args->SourceY + Args->Height > Private->height) {
return EFI_INVALID_PARAMETER;
}
- if (SourceX + Width > Private->width) {
+ if (Args->SourceX + Args->Width > Private->width) {
return EFI_INVALID_PARAMETER;
}
}
//
// Destination is Video
//
- if (DestinationY + Height > Private->height) {
+ if (Args->DestinationY + Args->Height > Private->height) {
return EFI_INVALID_PARAMETER;
}
- if (DestinationX + Width > Private->width) {
+ if (Args->DestinationX + Args->Width > Private->width) {
return EFI_INVALID_PARAMETER;
}
}
switch (BltOperation) {
case EfiUgaVideoToBltBuffer:
- Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (DestinationY * Delta) + DestinationX * sizeof (EFI_UGA_PIXEL));
- Delta -= Width * sizeof (EFI_UGA_PIXEL);
- for (SrcY = SourceY; SrcY < (Height + SourceY); SrcY++) {
- for (SrcX = SourceX; SrcX < (Width + SourceX); SrcX++) {
+ Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->DestinationY * Args->Delta) + Args->DestinationX * sizeof (EFI_UGA_PIXEL));
+ Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
+ for (SrcY = Args->SourceY; SrcY < (Args->Height + Args->SourceY); SrcY++) {
+ for (SrcX = Args->SourceX; SrcX < (Args->Width + Args->SourceX); SrcX++) {
*Blt++ = UgaColorToPixel(Private,
XGetPixel(Private->image, SrcX, SrcY));
}
- Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta);
+ Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
}
break;
case EfiUgaBltBufferToVideo:
- Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (SourceY * Delta) + SourceX * sizeof (EFI_UGA_PIXEL));
- Delta -= Width * sizeof (EFI_UGA_PIXEL);
- for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
- for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
+ Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->SourceY * Args->Delta) + Args->SourceX * sizeof (EFI_UGA_PIXEL));
+ Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
+ for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
+ for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
XPutPixel(Private->image, DstX, DstY, UgaPixelToColor(Private, *Blt));
Blt++;
}
- Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta);
+ Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
}
break;
case EfiUgaVideoToVideo:
- Dst = Private->image_data + (DestinationX << Private->pixel_shift)
- + DestinationY * Private->line_bytes;
- Src = Private->image_data + (SourceX << Private->pixel_shift)
- + SourceY * Private->line_bytes;
- Nbr = Width << Private->pixel_shift;
- if (DestinationY < SourceY) {
- for (Index = 0; Index < Height; Index++) {
+ Dst = Private->image_data + (Args->DestinationX << Private->pixel_shift)
+ + Args->DestinationY * Private->line_bytes;
+ Src = Private->image_data + (Args->SourceX << Private->pixel_shift)
+ + Args->SourceY * Private->line_bytes;
+ Nbr = Args->Width << Private->pixel_shift;
+ if (Args->DestinationY < Args->SourceY) {
+ for (Index = 0; Index < Args->Height; Index++) {
memcpy (Dst, Src, Nbr);
Dst += Private->line_bytes;
Src += Private->line_bytes;
}
}
else {
- Dst += (Height - 1) * Private->line_bytes;
- Src += (Height - 1) * Private->line_bytes;
- for (Index = 0; Index < Height; Index++) {
+ Dst += (Args->Height - 1) * Private->line_bytes;
+ Src += (Args->Height - 1) * Private->line_bytes;
+ for (Index = 0; Index < Args->Height; Index++) {
//
// Source and Destination Y may be equal, therefore Dst and Src may
// overlap.
break;
case EfiUgaVideoFill:
Color = UgaPixelToColor(Private, *BltBuffer);
- for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
- for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
+ for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
+ for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
XPutPixel(Private->image, DstX, DstY, Color);
}
}
switch (BltOperation) {
case EfiUgaVideoToVideo:
XCopyArea(Private->display, Private->win, Private->win, Private->gc,
- SourceX, SourceY, Width, Height, DestinationX, DestinationY);
+ Args->SourceX, Args->SourceY, Args->Width, Args->Height, Args->DestinationX, Args->DestinationY);
while (1) {
XEvent ev;
Color = UgaPixelToColor(Private, *BltBuffer);
XSetForeground(Private->display, Private->gc, Color);
XFillRectangle(Private->display, Private->win, Private->gc,
- DestinationX, DestinationY, Width, Height);
+ Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
XFlush(Private->display);
break;
case EfiUgaBltBufferToVideo:
- Redraw(Private, DestinationX, DestinationY, Width, Height);
+ Redraw(Private, Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
break;
default:
break;
return EFI_SUCCESS;
}
+STATIC EFI_STATUS
+CheckPointerInternal( UGA_IO_PRIVATE *drv, BOOLEAN delay )
+{
+ HandleEvents(drv);
+ if (drv->pointer_state_changed != 0)
+ return EFI_SUCCESS;
+ if ( delay )
+ /* EFI is polling. Be CPU-friendly. */
+ msSleep (20);
+ return EFI_NOT_READY;
+}
+
+EFI_STATUS
+UgaCheckPointer(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
+{
+ UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
+ return( CheckPointerInternal( drv, TRUE ) );
+}
+
+EFI_STATUS
+UgaGetPointerState (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_SIMPLE_POINTER_STATE *state)
+{
+ UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
+ EFI_STATUS status;
+
+ status = CheckPointerInternal( drv, FALSE );
+ if (status != EFI_SUCCESS)
+ return status;
+
+ memcpy( state, &drv->pointer_state, sizeof( EFI_SIMPLE_POINTER_STATE ) );
+
+ drv->pointer_state.RelativeMovementX = 0;
+ drv->pointer_state.RelativeMovementY = 0;
+ drv->pointer_state.RelativeMovementZ = 0;
+ drv->pointer_state_changed = 0;
+ return EFI_SUCCESS;
+}
+
EFI_STATUS
UgaCreate (EFI_UNIX_UGA_IO_PROTOCOL **Uga, CONST CHAR16 *Title)
{
if (drv == NULL)
return EFI_OUT_OF_RESOURCES;
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(MDE_CPU_X64)
//
//
//
-EFI_STATUS EFIAPI GasketUgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo);
-EFI_STATUS EFIAPI GasketUgaSize (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height);
-EFI_STATUS EFIAPI GasketUgaCheckKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo);
-EFI_STATUS EFIAPI GasketUgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_INPUT_KEY *key);
-EFI_STATUS EFIAPI GasketUgaBlt (
- EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
- IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
- IN EFI_UGA_BLT_OPERATION BltOperation,
- IN UINTN SourceX,
- IN UINTN SourceY,
- IN UINTN DestinationX,
- IN UINTN DestinationY,
- IN UINTN Width,
- IN UINTN Height,
- IN UINTN Delta OPTIONAL
- );
-
drv->UgaIo.UgaClose = GasketUgaClose;
drv->UgaIo.UgaSize = GasketUgaSize;
drv->UgaIo.UgaCheckKey = GasketUgaCheckKey;
drv->UgaIo.UgaGetKey = GasketUgaGetKey;
+ drv->UgaIo.UgaKeySetState = GasketUgaKeySetState;
+ drv->UgaIo.UgaRegisterKeyNotify = GasketUgaRegisterKeyNotify;
drv->UgaIo.UgaBlt = GasketUgaBlt;
+ drv->UgaIo.UgaCheckPointer = GasketUgaCheckPointer;
+ drv->UgaIo.UgaGetPointerState = GasketUgaGetPointerState;
#else
drv->UgaIo.UgaClose = UgaClose;
drv->UgaIo.UgaSize = UgaSize;
drv->UgaIo.UgaCheckKey = UgaCheckKey;
drv->UgaIo.UgaGetKey = UgaGetKey;
+ drv->UgaIo.UgaKeySetState = UgaKeySetState;
+ drv->UgaIo.UgaRegisterKeyNotify = UgaRegisterKeyNotify;
drv->UgaIo.UgaBlt = UgaBlt;
+ drv->UgaIo.UgaCheckPointer = UgaCheckPointer;
+ drv->UgaIo.UgaGetPointerState = UgaGetPointerState;
#endif
drv->key_count = 0;
drv->key_rd = 0;
drv->key_wr = 0;
+ drv->KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID;
+ drv->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;
+ drv->RegisterdKeyCallback = NULL;
+ drv->RegisterdKeyCallbackContext = NULL;
+
+
drv->display = XOpenDisplay (display_name);
if (drv->display == NULL)
{
BlackPixel (drv->display, drv->screen));
drv->depth = DefaultDepth (drv->display, drv->screen);
+ XDefineCursor (drv->display, drv->win, XCreateFontCursor (drv->display, XC_pirate));
/* Compute title len and convert to Ascii. */
for (title_len = 0; Title[title_len] != 0; title_len++)
XStoreName (drv->display, drv->win, title);
}
- XSelectInput (drv->display, drv->win, ExposureMask | KeyPressMask);
-
+ XSelectInput (drv->display, drv->win,
+ ExposureMask | KeyPressMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask );
drv->gc = DefaultGC (drv->display, drv->screen);
*Uga = (EFI_UNIX_UGA_IO_PROTOCOL *)drv;
projects / mirror_edk2.git / blobdiff