[mirror_edk2.git] / EmulatorPkg / Unix / Host / X11GraphicsWindow.c

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