/*++ @file | |
Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR> | |
Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR> | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#include "Host.h" | |
#include <sys/ipc.h> | |
#include <sys/shm.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> | |
#define KEYSYM_LOWER 0 | |
#define KEYSYM_UPPER 1 | |
struct uga_drv_shift_mask { | |
unsigned char shift; | |
unsigned char size; | |
unsigned char csize; | |
}; | |
#define NBR_KEYS 32 | |
typedef struct { | |
EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsIo; | |
Display *display; | |
int screen; // values for window_size in main | |
Window win; | |
GC gc; | |
Visual *visual; | |
int depth; | |
unsigned int width; | |
unsigned int height; | |
unsigned int line_bytes; | |
unsigned int pixel_shift; | |
unsigned char *image_data; | |
struct uga_drv_shift_mask r, g, b; | |
int use_shm; | |
XShmSegmentInfo xshm_info; | |
XImage *image; | |
char *Title; | |
unsigned int key_rd; | |
unsigned int key_wr; | |
unsigned int key_count; | |
EFI_KEY_DATA keys[NBR_KEYS]; | |
EFI_KEY_STATE KeyState; | |
EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeRegisterdKeyCallback; | |
EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakRegisterdKeyCallback; | |
VOID *RegisterdKeyCallbackContext; | |
int previous_x; | |
int previous_y; | |
EFI_SIMPLE_POINTER_STATE pointer_state; | |
int pointer_state_changed; | |
} GRAPHICS_IO_PRIVATE; | |
void | |
HandleEvents( | |
IN GRAPHICS_IO_PRIVATE *Drv | |
); | |
void | |
fill_shift_mask ( | |
IN struct uga_drv_shift_mask *sm, | |
IN unsigned long mask | |
) | |
{ | |
sm->shift = 0; | |
sm->size = 0; | |
while ((mask & 1) == 0) { | |
mask >>= 1; | |
sm->shift++; | |
} | |
while (mask & 1) { | |
sm->size++; | |
mask >>= 1; | |
} | |
sm->csize = 8 - sm->size; | |
} | |
int | |
TryCreateShmImage ( | |
IN GRAPHICS_IO_PRIVATE *Drv | |
) | |
{ | |
Drv->image = XShmCreateImage ( | |
Drv->display, Drv->visual, | |
Drv->depth, ZPixmap, NULL, &Drv->xshm_info, | |
Drv->width, Drv->height | |
); | |
if (Drv->image == NULL) { | |
return 0; | |
} | |
switch (Drv->image->bitmap_unit) { | |
case 32: | |
Drv->pixel_shift = 2; | |
break; | |
case 16: | |
Drv->pixel_shift = 1; | |
break; | |
case 8: | |
Drv->pixel_shift = 0; | |
break; | |
} | |
Drv->xshm_info.shmid = shmget ( | |
IPC_PRIVATE, Drv->image->bytes_per_line * Drv->image->height, | |
IPC_CREAT | 0777 | |
); | |
if (Drv->xshm_info.shmid < 0) { | |
XDestroyImage(Drv->image); | |
return 0; | |
} | |
Drv->image_data = shmat (Drv->xshm_info.shmid, NULL, 0); | |
if(!Drv->image_data) { | |
shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL); | |
XDestroyImage(Drv->image); | |
return 0; | |
} | |
#ifndef __APPLE__ | |
// | |
// This closes shared memory in real time on OS X. Only closes after folks quit using | |
// it on Linux. | |
// | |
shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL); | |
#endif | |
Drv->xshm_info.shmaddr = (char*)Drv->image_data; | |
Drv->image->data = (char*)Drv->image_data; | |
if (!XShmAttach (Drv->display, &Drv->xshm_info)) { | |
shmdt (Drv->image_data); | |
XDestroyImage(Drv->image); | |
return 0; | |
} | |
return 1; | |
} | |
EFI_STATUS | |
X11Size ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, | |
IN UINT32 Width, | |
IN UINT32 Height | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
XSizeHints size_hints; | |
// Destroy current buffer if created. | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
if (Drv->image != NULL) { | |
// Before destroy buffer, need to make sure the buffer available for access. | |
XDestroyImage (Drv->image); | |
if (Drv->use_shm) { | |
shmdt (Drv->image_data); | |
} | |
Drv->image_data = NULL; | |
Drv->image = NULL; | |
} | |
Drv->width = Width; | |
Drv->height = Height; | |
XResizeWindow (Drv->display, Drv->win, Width, Height); | |
// Allocate image. | |
if (XShmQueryExtension(Drv->display) && TryCreateShmImage(Drv)) { | |
Drv->use_shm = 1; | |
} else { | |
Drv->use_shm = 0; | |
if (Drv->depth > 16) { | |
Drv->pixel_shift = 2; | |
} else if (Drv->depth > 8) { | |
Drv->pixel_shift = 1; | |
} else { | |
Drv->pixel_shift = 0; | |
} | |
Drv->image_data = malloc ((Drv->width * Drv->height) << Drv->pixel_shift); | |
Drv->image = XCreateImage ( | |
Drv->display, Drv->visual, Drv->depth, | |
ZPixmap, 0, (char *)Drv->image_data, | |
Drv->width, Drv->height, | |
8 << Drv->pixel_shift, 0 | |
); | |
} | |
Drv->line_bytes = Drv->image->bytes_per_line; | |
fill_shift_mask (&Drv->r, Drv->image->red_mask); | |
fill_shift_mask (&Drv->g, Drv->image->green_mask); | |
fill_shift_mask (&Drv->b, Drv->image->blue_mask); | |
// Set WM hints. | |
size_hints.flags = PSize | PMinSize | PMaxSize; | |
size_hints.min_width = size_hints.max_width = size_hints.base_width = Width; | |
size_hints.min_height = size_hints.max_height = size_hints.base_height = Height; | |
XSetWMNormalHints (Drv->display, Drv->win, &size_hints); | |
XMapWindow (Drv->display, Drv->win); | |
HandleEvents (Drv); | |
return EFI_SUCCESS; | |
} | |
void | |
handleKeyEvent ( | |
IN GRAPHICS_IO_PRIVATE *Drv, | |
IN XEvent *ev, | |
IN BOOLEAN Make | |
) | |
{ | |
KeySym *KeySym; | |
EFI_KEY_DATA KeyData; | |
int KeySymArraySize; | |
if (Make) { | |
if (Drv->key_count == NBR_KEYS) { | |
return; | |
} | |
} | |
// keycode is a physical key on the keyboard | |
// KeySym is a mapping of a physical key | |
// KeyboardMapping is the array of KeySym for a given keycode. key, shifted key, option key, command key, ... | |
// | |
// Returns an array of KeySymArraySize of KeySym for the keycode. [0] is lower case, [1] is upper case, | |
// [2] and [3] are based on option and command modifiers. The problem we have is command V | |
// could be mapped to a crazy Unicode character so the old scheme of returning a string. | |
// | |
KeySym = XGetKeyboardMapping (Drv->display, ev->xkey.keycode, 1, &KeySymArraySize); | |
KeyData.Key.ScanCode = 0; | |
KeyData.Key.UnicodeChar = 0; | |
KeyData.KeyState.KeyShiftState = 0; | |
// | |
// 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 { | |
if (Make) { | |
Drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE; | |
} | |
} | |
// Skipping EFI_MENU_KEY_PRESSED and EFI_SYS_REQ_PRESSED | |
switch (*KeySym) { | |
case XK_Control_R: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_CONTROL_PRESSED; | |
} | |
break; | |
case XK_Control_L: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_LEFT_CONTROL_PRESSED; | |
} | |
break; | |
case XK_Shift_R: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_SHIFT_PRESSED; | |
} | |
break; | |
case XK_Shift_L: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_LEFT_SHIFT_PRESSED; | |
} | |
break; | |
case XK_Mode_switch: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_LEFT_ALT_PRESSED; | |
} | |
break; | |
case XK_Meta_R: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_LOGO_PRESSED; | |
} | |
break; | |
case XK_Meta_L: | |
if (Make) { | |
Drv->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED; | |
} else { | |
Drv->KeyState.KeyShiftState &= ~EFI_LEFT_LOGO_PRESSED; | |
} | |
break; | |
case XK_KP_Home: | |
case XK_Home: KeyData.Key.ScanCode = SCAN_HOME; break; | |
case XK_KP_End: | |
case XK_End: KeyData.Key.ScanCode = SCAN_END; break; | |
case XK_KP_Left: | |
case XK_Left: KeyData.Key.ScanCode = SCAN_LEFT; break; | |
case XK_KP_Right: | |
case XK_Right: KeyData.Key.ScanCode = SCAN_RIGHT; break; | |
case XK_KP_Up: | |
case XK_Up: KeyData.Key.ScanCode = SCAN_UP; break; | |
case XK_KP_Down: | |
case XK_Down: KeyData.Key.ScanCode = SCAN_DOWN; break; | |
case XK_KP_Delete: | |
case XK_Delete: KeyData.Key.ScanCode = SCAN_DELETE; break; | |
case XK_KP_Insert: | |
case XK_Insert: KeyData.Key.ScanCode = SCAN_INSERT; break; | |
case XK_KP_Page_Up: | |
case XK_Page_Up: KeyData.Key.ScanCode = SCAN_PAGE_UP; break; | |
case XK_KP_Page_Down: | |
case XK_Page_Down: KeyData.Key.ScanCode = SCAN_PAGE_DOWN; break; | |
case XK_Escape: KeyData.Key.ScanCode = SCAN_ESC; break; | |
case XK_Pause: KeyData.Key.ScanCode = SCAN_PAUSE; break; | |
case XK_KP_F1: | |
case XK_F1: KeyData.Key.ScanCode = SCAN_F1; break; | |
case XK_KP_F2: | |
case XK_F2: KeyData.Key.ScanCode = SCAN_F2; break; | |
case XK_KP_F3: | |
case XK_F3: KeyData.Key.ScanCode = SCAN_F3; break; | |
case XK_KP_F4: | |
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; | |
// Don't map into X11 by default on a Mac | |
// System Preferences->Keyboard->Keyboard Shortcuts can be configured | |
// to not use higher function keys as shortcuts and the will show up | |
// in X11. | |
case XK_F8: KeyData.Key.ScanCode = SCAN_F8; break; | |
case XK_F9: KeyData.Key.ScanCode = SCAN_F9; break; | |
case XK_F10: KeyData.Key.ScanCode = SCAN_F10; break; | |
case XK_F11: KeyData.Key.ScanCode = SCAN_F11; break; | |
case XK_F12: KeyData.Key.ScanCode = SCAN_F12; break; | |
case XK_F13: KeyData.Key.ScanCode = SCAN_F13; break; | |
case XK_F14: KeyData.Key.ScanCode = SCAN_F14; break; | |
case XK_F15: KeyData.Key.ScanCode = SCAN_F15; break; | |
case XK_F16: KeyData.Key.ScanCode = SCAN_F16; break; | |
case XK_F17: KeyData.Key.ScanCode = SCAN_F17; break; | |
case XK_F18: KeyData.Key.ScanCode = SCAN_F18; break; | |
case XK_F19: KeyData.Key.ScanCode = SCAN_F19; break; | |
case XK_F20: KeyData.Key.ScanCode = SCAN_F20; break; | |
case XK_F21: KeyData.Key.ScanCode = SCAN_F21; break; | |
case XK_F22: KeyData.Key.ScanCode = SCAN_F22; break; | |
case XK_F23: KeyData.Key.ScanCode = SCAN_F23; break; | |
case XK_F24: KeyData.Key.ScanCode = SCAN_F24; break; | |
// No mapping in X11 | |
//case XK_: KeyData.Key.ScanCode = SCAN_MUTE; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_VOLUME_UP; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_VOLUME_DOWN; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_BRIGHTNESS_UP; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_BRIGHTNESS_DOWN; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_SUSPEND; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_HIBERNATE; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_TOGGLE_DISPLAY; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_RECOVERY; break; | |
//case XK_: KeyData.Key.ScanCode = SCAN_EJECT; break; | |
case XK_BackSpace: KeyData.Key.UnicodeChar = 0x0008; break; | |
case XK_KP_Tab: | |
case XK_Tab: KeyData.Key.UnicodeChar = 0x0009; break; | |
case XK_Linefeed: KeyData.Key.UnicodeChar = 0x000a; break; | |
case XK_KP_Enter: | |
case XK_Return: KeyData.Key.UnicodeChar = 0x000d; break; | |
case XK_KP_Equal : KeyData.Key.UnicodeChar = L'='; break; | |
case XK_KP_Multiply : KeyData.Key.UnicodeChar = L'*'; break; | |
case XK_KP_Add : KeyData.Key.UnicodeChar = L'+'; break; | |
case XK_KP_Separator : KeyData.Key.UnicodeChar = L'~'; break; | |
case XK_KP_Subtract : KeyData.Key.UnicodeChar = L'-'; break; | |
case XK_KP_Decimal : KeyData.Key.UnicodeChar = L'.'; break; | |
case XK_KP_Divide : KeyData.Key.UnicodeChar = L'/'; break; | |
case XK_KP_0 : KeyData.Key.UnicodeChar = L'0'; break; | |
case XK_KP_1 : KeyData.Key.UnicodeChar = L'1'; break; | |
case XK_KP_2 : KeyData.Key.UnicodeChar = L'2'; break; | |
case XK_KP_3 : KeyData.Key.UnicodeChar = L'3'; break; | |
case XK_KP_4 : KeyData.Key.UnicodeChar = L'4'; break; | |
case XK_KP_5 : KeyData.Key.UnicodeChar = L'5'; break; | |
case XK_KP_6 : KeyData.Key.UnicodeChar = L'6'; break; | |
case XK_KP_7 : KeyData.Key.UnicodeChar = L'7'; break; | |
case XK_KP_8 : KeyData.Key.UnicodeChar = L'8'; break; | |
case XK_KP_9 : KeyData.Key.UnicodeChar = L'9'; break; | |
default: | |
; | |
} | |
// The global state is our state | |
KeyData.KeyState.KeyShiftState = Drv->KeyState.KeyShiftState; | |
KeyData.KeyState.KeyToggleState = Drv->KeyState.KeyToggleState; | |
if (*KeySym < XK_BackSpace) { | |
if (((Drv->KeyState.KeyShiftState & (EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED)) != 0) || | |
((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) != 0) ) { | |
KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_UPPER]; | |
// Per UEFI spec since we converted the Unicode clear the shift bits we pass up | |
KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED); | |
} else { | |
KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_LOWER]; | |
} | |
} else { | |
// XK_BackSpace is the start of XK_MISCELLANY. These are the XK_? keys we process in this file | |
; | |
} | |
if (Make) { | |
memcpy (&Drv->keys[Drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA)); | |
Drv->key_wr = (Drv->key_wr + 1) % NBR_KEYS; | |
Drv->key_count++; | |
if (Drv->MakeRegisterdKeyCallback != NULL) { | |
ReverseGasketUint64Uint64 (Drv->MakeRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData); | |
} | |
} else { | |
if (Drv->BreakRegisterdKeyCallback != NULL) { | |
ReverseGasketUint64Uint64 (Drv->BreakRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData); | |
} | |
} | |
} | |
void | |
handleMouseMoved( | |
IN GRAPHICS_IO_PRIVATE *Drv, | |
IN 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 ( | |
IN GRAPHICS_IO_PRIVATE *Drv, | |
IN XEvent *ev, | |
IN 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 | |
Redraw ( | |
IN GRAPHICS_IO_PRIVATE *Drv, | |
IN UINTN X, | |
IN UINTN Y, | |
IN UINTN Width, | |
IN UINTN Height | |
) | |
{ | |
if (Drv->use_shm) { | |
XShmPutImage ( | |
Drv->display, Drv->win, Drv->gc, Drv->image, X, Y, X, Y, Width, Height, False | |
); | |
} else { | |
XPutImage ( | |
Drv->display, Drv->win, Drv->gc, Drv->image, X, Y, X, Y, Width, Height | |
); | |
} | |
XFlush(Drv->display); | |
} | |
void | |
HandleEvent(GRAPHICS_IO_PRIVATE *Drv, XEvent *ev) | |
{ | |
switch (ev->type) { | |
case Expose: | |
Redraw (Drv, ev->xexpose.x, ev->xexpose.y, | |
ev->xexpose.width, ev->xexpose.height); | |
break; | |
case GraphicsExpose: | |
Redraw (Drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y, | |
ev->xgraphicsexpose.width, ev->xgraphicsexpose.height); | |
break; | |
case KeyPress: | |
handleKeyEvent (Drv, ev, TRUE); | |
break; | |
case KeyRelease: | |
handleKeyEvent (Drv, ev, FALSE); | |
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); | |
exit (1); | |
break; | |
#endif | |
case NoExpose: | |
default: | |
break; | |
} | |
} | |
void | |
HandleEvents ( | |
IN GRAPHICS_IO_PRIVATE *Drv | |
) | |
{ | |
XEvent ev; | |
while (XPending (Drv->display) != 0) { | |
XNextEvent (Drv->display, &ev); | |
HandleEvent (Drv, &ev); | |
} | |
} | |
unsigned long | |
X11PixelToColor ( | |
IN GRAPHICS_IO_PRIVATE *Drv, | |
IN EFI_UGA_PIXEL pixel | |
) | |
{ | |
return ((pixel.Red >> Drv->r.csize) << Drv->r.shift) | |
| ((pixel.Green >> Drv->g.csize) << Drv->g.shift) | |
| ((pixel.Blue >> Drv->b.csize) << Drv->b.shift); | |
} | |
EFI_UGA_PIXEL | |
X11ColorToPixel ( | |
IN GRAPHICS_IO_PRIVATE *Drv, | |
IN unsigned long val | |
) | |
{ | |
EFI_UGA_PIXEL Pixel; | |
memset (&Pixel, 0, sizeof (EFI_UGA_PIXEL)); | |
// Truncation not an issue since X11 and EFI are both using 8 bits per color | |
Pixel.Red = (val >> Drv->r.shift) << Drv->r.csize; | |
Pixel.Green = (val >> Drv->g.shift) << Drv->g.csize; | |
Pixel.Blue = (val >> Drv->b.shift) << Drv->b.csize; | |
return Pixel; | |
} | |
EFI_STATUS | |
X11CheckKey ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
HandleEvents (Drv); | |
if (Drv->key_count != 0) { | |
return EFI_SUCCESS; | |
} | |
return EFI_NOT_READY; | |
} | |
EFI_STATUS | |
X11GetKey ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, | |
IN EFI_KEY_DATA *KeyData | |
) | |
{ | |
EFI_STATUS EfiStatus; | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
EfiStatus = X11CheckKey (GraphicsIo); | |
if (EFI_ERROR (EfiStatus)) { | |
return EfiStatus; | |
} | |
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 | |
X11KeySetState ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, | |
IN EFI_KEY_TOGGLE_STATE *KeyToggleState | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
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 | |
X11RegisterKeyNotify ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, | |
IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack, | |
IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack, | |
IN VOID *Context | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
Drv->MakeRegisterdKeyCallback = MakeCallBack; | |
Drv->BreakRegisterdKeyCallback = BreakCallBack; | |
Drv->RegisterdKeyCallbackContext = Context; | |
return EFI_SUCCESS; | |
} | |
EFI_STATUS | |
X11Blt ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, | |
IN EFI_UGA_PIXEL *BltBuffer OPTIONAL, | |
IN EFI_UGA_BLT_OPERATION BltOperation, | |
IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Private; | |
UINTN DstY; | |
UINTN SrcY; | |
UINTN DstX; | |
UINTN SrcX; | |
UINTN Index; | |
EFI_UGA_PIXEL *Blt; | |
UINT8 *Dst; | |
UINT8 *Src; | |
UINTN Nbr; | |
unsigned long Color; | |
XEvent ev; | |
Private = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
// | |
// Check bounds | |
// | |
if (BltOperation == EfiUgaVideoToBltBuffer | |
|| BltOperation == EfiUgaVideoToVideo) { | |
// | |
// Source is Video. | |
// | |
if (Args->SourceY + Args->Height > Private->height) { | |
return EFI_INVALID_PARAMETER; | |
} | |
if (Args->SourceX + Args->Width > Private->width) { | |
return EFI_INVALID_PARAMETER; | |
} | |
} | |
if (BltOperation == EfiUgaBltBufferToVideo | |
|| BltOperation == EfiUgaVideoToVideo | |
|| BltOperation == EfiUgaVideoFill) { | |
// | |
// Destination is Video | |
// | |
if (Args->DestinationY + Args->Height > Private->height) { | |
return EFI_INVALID_PARAMETER; | |
} | |
if (Args->DestinationX + Args->Width > Private->width) { | |
return EFI_INVALID_PARAMETER; | |
} | |
} | |
switch (BltOperation) { | |
case EfiUgaVideoToBltBuffer: | |
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++ = X11ColorToPixel (Private, XGetPixel (Private->image, SrcX, SrcY)); | |
} | |
Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta); | |
} | |
break; | |
case EfiUgaBltBufferToVideo: | |
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, X11PixelToColor(Private, *Blt)); | |
Blt++; | |
} | |
Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta); | |
} | |
break; | |
case EfiUgaVideoToVideo: | |
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 += (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. | |
// | |
memmove (Dst, Src, Nbr); | |
Dst -= Private->line_bytes; | |
Src -= Private->line_bytes; | |
} | |
} | |
break; | |
case EfiUgaVideoFill: | |
Color = X11PixelToColor(Private, *BltBuffer); | |
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); | |
} | |
} | |
break; | |
default: | |
return EFI_INVALID_PARAMETER; | |
} | |
// | |
// Refresh screen. | |
// | |
switch (BltOperation) { | |
case EfiUgaVideoToVideo: | |
XCopyArea( | |
Private->display, Private->win, Private->win, Private->gc, | |
Args->SourceX, Args->SourceY, Args->Width, Args->Height, | |
Args->DestinationX, Args->DestinationY | |
); | |
while (1) { | |
XNextEvent (Private->display, &ev); | |
HandleEvent (Private, &ev); | |
if (ev.type == NoExpose || ev.type == GraphicsExpose) { | |
break; | |
} | |
} | |
break; | |
case EfiUgaVideoFill: | |
Color = X11PixelToColor (Private, *BltBuffer); | |
XSetForeground (Private->display, Private->gc, Color); | |
XFillRectangle ( | |
Private->display, Private->win, Private->gc, | |
Args->DestinationX, Args->DestinationY, Args->Width, Args->Height | |
); | |
XFlush (Private->display); | |
break; | |
case EfiUgaBltBufferToVideo: | |
Redraw (Private, Args->DestinationX, Args->DestinationY, Args->Width, Args->Height); | |
break; | |
default: | |
break; | |
} | |
return EFI_SUCCESS; | |
} | |
EFI_STATUS | |
X11CheckPointer ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
HandleEvents (Drv); | |
if (Drv->pointer_state_changed != 0) { | |
return EFI_SUCCESS; | |
} | |
return EFI_NOT_READY; | |
} | |
EFI_STATUS | |
X11GetPointerState ( | |
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, | |
IN EFI_SIMPLE_POINTER_STATE *State | |
) | |
{ | |
EFI_STATUS EfiStatus; | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
EfiStatus = X11CheckPointer (GraphicsIo); | |
if (EfiStatus != EFI_SUCCESS) { | |
return EfiStatus; | |
} | |
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 | |
X11GraphicsWindowOpen ( | |
IN EMU_IO_THUNK_PROTOCOL *This | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
unsigned int border_width = 0; | |
char *display_name = NULL; | |
Drv = (GRAPHICS_IO_PRIVATE *)calloc (1, sizeof (GRAPHICS_IO_PRIVATE)); | |
if (Drv == NULL) { | |
return EFI_OUT_OF_RESOURCES; | |
} | |
Drv->GraphicsIo.Size = GasketX11Size; | |
Drv->GraphicsIo.CheckKey = GasketX11CheckKey; | |
Drv->GraphicsIo.GetKey = GasketX11GetKey; | |
Drv->GraphicsIo.KeySetState = GasketX11KeySetState; | |
Drv->GraphicsIo.RegisterKeyNotify = GasketX11RegisterKeyNotify; | |
Drv->GraphicsIo.Blt = GasketX11Blt; | |
Drv->GraphicsIo.CheckPointer = GasketX11CheckPointer; | |
Drv->GraphicsIo.GetPointerState = GasketX11GetPointerState; | |
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->MakeRegisterdKeyCallback = NULL; | |
Drv->BreakRegisterdKeyCallback = NULL; | |
Drv->RegisterdKeyCallbackContext = NULL; | |
Drv->display = XOpenDisplay (display_name); | |
if (Drv->display == NULL) { | |
fprintf (stderr, "uga: cannot connect to X server %s\n", XDisplayName (display_name)); | |
free (Drv); | |
return EFI_DEVICE_ERROR; | |
} | |
Drv->screen = DefaultScreen (Drv->display); | |
Drv->visual = DefaultVisual (Drv->display, Drv->screen); | |
Drv->win = XCreateSimpleWindow ( | |
Drv->display, RootWindow (Drv->display, Drv->screen), | |
0, 0, 4, 4, border_width, | |
WhitePixel (Drv->display, Drv->screen), | |
BlackPixel (Drv->display, Drv->screen) | |
); | |
Drv->depth = DefaultDepth (Drv->display, Drv->screen); | |
XDefineCursor (Drv->display, Drv->win, XCreateFontCursor (Drv->display, XC_pirate)); | |
Drv->Title = malloc (StrSize (This->ConfigString)); | |
UnicodeStrToAsciiStr (This->ConfigString, Drv->Title); | |
XStoreName (Drv->display, Drv->win, Drv->Title); | |
// XAutoRepeatOff (Drv->display); | |
XSelectInput ( | |
Drv->display, Drv->win, | |
ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask | |
); | |
Drv->gc = DefaultGC (Drv->display, Drv->screen); | |
This->Private = (VOID *)Drv; | |
This->Interface = (VOID *)Drv; | |
return EFI_SUCCESS; | |
} | |
EFI_STATUS | |
X11GraphicsWindowClose ( | |
IN EMU_IO_THUNK_PROTOCOL *This | |
) | |
{ | |
GRAPHICS_IO_PRIVATE *Drv; | |
Drv = (GRAPHICS_IO_PRIVATE *)This->Private; | |
if (Drv == NULL) { | |
return EFI_SUCCESS; | |
} | |
if (Drv->image != NULL) { | |
XDestroyImage(Drv->image); | |
if (Drv->use_shm) { | |
shmdt (Drv->image_data); | |
} | |
Drv->image_data = NULL; | |
Drv->image = NULL; | |
} | |
XDestroyWindow (Drv->display, Drv->win); | |
XCloseDisplay (Drv->display); | |
#ifdef __APPLE__ | |
// Free up the shared memory | |
shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL); | |
#endif | |
free (Drv); | |
return EFI_SUCCESS; | |
} | |
EMU_IO_THUNK_PROTOCOL gX11ThunkIo = { | |
&gEmuGraphicsWindowProtocolGuid, | |
NULL, | |
NULL, | |
0, | |
GasketX11GraphicsWindowOpen, | |
GasketX11GraphicsWindowClose, | |
NULL | |
}; | |