| /*++ @file | |
| Copyright (c) 2004 - 2019, 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_GRAPHICS_OUTPUT_BLT_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_GRAPHICS_OUTPUT_BLT_PIXEL | |
| X11ColorToPixel ( | |
| IN GRAPHICS_IO_PRIVATE *Drv, | |
| IN unsigned long val | |
| ) | |
| { | |
| EFI_GRAPHICS_OUTPUT_BLT_PIXEL Pixel; | |
| memset (&Pixel, 0, sizeof (EFI_GRAPHICS_OUTPUT_BLT_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 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_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer OPTIONAL, | |
| IN EFI_GRAPHICS_OUTPUT_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_GRAPHICS_OUTPUT_BLT_PIXEL *Blt; | |
| UINT8 *Dst; | |
| UINT8 *Src; | |
| UINTN Nbr; | |
| unsigned long Color; | |
| XEvent ev; | |
| Private = (GRAPHICS_IO_PRIVATE *)GraphicsIo; | |
| // | |
| // Check bounds | |
| // | |
| if ( (BltOperation == EfiBltVideoToBltBuffer) | |
| || (BltOperation == EfiBltVideoToVideo)) | |
| { | |
| // | |
| // 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 == EfiBltBufferToVideo) | |
| || (BltOperation == EfiBltVideoToVideo) | |
| || (BltOperation == EfiBltVideoFill)) | |
| { | |
| // | |
| // 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 EfiBltVideoToBltBuffer: | |
| Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)((UINT8 *)BltBuffer + (Args->DestinationY * Args->Delta) + Args->DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); | |
| Args->Delta -= Args->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_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_GRAPHICS_OUTPUT_BLT_PIXEL *)((UINT8 *)Blt + Args->Delta); | |
| } | |
| break; | |
| case EfiBltBufferToVideo: | |
| Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)((UINT8 *)BltBuffer + (Args->SourceY * Args->Delta) + Args->SourceX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); | |
| Args->Delta -= Args->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_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_GRAPHICS_OUTPUT_BLT_PIXEL *)((UINT8 *)Blt + Args->Delta); | |
| } | |
| break; | |
| case EfiBltVideoToVideo: | |
| 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 EfiBltVideoFill: | |
| 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 EfiBltVideoToVideo: | |
| 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 EfiBltVideoFill: | |
| 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 EfiBltBufferToVideo: | |
| 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, "GOP: 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)); | |
| UnicodeStrToAsciiStrS (This->ConfigString, Drv->Title, StrSize (This->ConfigString)); | |
| 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 | |
| }; |