EmulatorPkg/Unix/Host/X11GraphicsWindow.c

   1 /*++ @file
   2
   3 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
   4 Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
   5
   6 SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include "Host.h"
  11
  12 #include <sys/ipc.h>
  13 #include <sys/shm.h>
  14
  15 #include <X11/Xlib.h>
  16 #include <X11/Xutil.h>
  17 #include <X11/Xos.h>
  18 #include <X11/extensions/XShm.h>
  19 #include <X11/keysym.h>
  20 #include <X11/cursorfont.h>
  21
  22 #define KEYSYM_LOWER  0
  23 #define KEYSYM_UPPER  1
  24
  25
  26 struct uga_drv_shift_mask {
  27   unsigned char shift;
  28   unsigned char size;
  29   unsigned char csize;
  30 };
  31
  32 #define NBR_KEYS 32
  33 typedef struct {
  34   EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsIo;
  35
  36   Display     *display;
  37   int         screen;      // values for window_size in main
  38   Window      win;
  39   GC          gc;
  40   Visual      *visual;
  41
  42   int           depth;
  43   unsigned int  width;
  44   unsigned int  height;
  45   unsigned int  line_bytes;
  46   unsigned int  pixel_shift;
  47   unsigned char *image_data;
  48
  49   struct uga_drv_shift_mask r, g, b;
  50
  51   int             use_shm;
  52   XShmSegmentInfo xshm_info;
  53   XImage          *image;
  54   char            *Title;
  55
  56   unsigned int key_rd;
  57   unsigned int key_wr;
  58   unsigned int key_count;
  59   EFI_KEY_DATA keys[NBR_KEYS];
  60
  61   EFI_KEY_STATE KeyState;
  62
  63   EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    MakeRegisterdKeyCallback;
  64   EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    BreakRegisterdKeyCallback;
  65   VOID                                                *RegisterdKeyCallbackContext;
  66
  67   int                        previous_x;
  68   int                        previous_y;
  69   EFI_SIMPLE_POINTER_STATE   pointer_state;
  70   int                        pointer_state_changed;
  71 } GRAPHICS_IO_PRIVATE;
  72
  73 void
  74 HandleEvents(
  75   IN GRAPHICS_IO_PRIVATE *Drv
  76   );
  77
  78 void
  79 fill_shift_mask (
  80   IN  struct uga_drv_shift_mask *sm,
  81   IN  unsigned long             mask
  82   )
  83 {
  84   sm->shift = 0;
  85   sm->size = 0;
  86   while ((mask & 1) == 0) {
  87     mask >>= 1;
  88     sm->shift++;
  89   }
  90   while (mask & 1) {
  91     sm->size++;
  92     mask >>= 1;
  93   }
  94   sm->csize = 8 - sm->size;
  95 }
  96
  97 int
  98 TryCreateShmImage (
  99   IN  GRAPHICS_IO_PRIVATE *Drv
 100   )
 101 {
 102   Drv->image = XShmCreateImage (
 103                  Drv->display, Drv->visual,
 104                  Drv->depth, ZPixmap, NULL, &Drv->xshm_info,
 105                  Drv->width, Drv->height
 106                  );
 107   if (Drv->image == NULL) {
 108     return 0;
 109   }
 110
 111   switch (Drv->image->bitmap_unit) {
 112   case 32:
 113     Drv->pixel_shift = 2;
 114     break;
 115   case 16:
 116     Drv->pixel_shift = 1;
 117     break;
 118   case 8:
 119     Drv->pixel_shift = 0;
 120     break;
 121   }
 122
 123   Drv->xshm_info.shmid = shmget (
 124                           IPC_PRIVATE, Drv->image->bytes_per_line * Drv->image->height,
 125                           IPC_CREAT | 0777
 126                           );
 127   if (Drv->xshm_info.shmid < 0) {
 128     XDestroyImage(Drv->image);
 129     return 0;
 130   }
 131
 132   Drv->image_data = shmat (Drv->xshm_info.shmid, NULL, 0);
 133   if(!Drv->image_data) {
 134     shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
 135     XDestroyImage(Drv->image);
 136     return 0;
 137   }
 138
 139 #ifndef __APPLE__
 140   //
 141   // This closes shared memory in real time on OS X. Only closes after folks quit using
 142   // it on Linux.
 143   //
 144   shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
 145 #endif
 146
 147   Drv->xshm_info.shmaddr = (char*)Drv->image_data;
 148   Drv->image->data = (char*)Drv->image_data;
 149
 150   if (!XShmAttach (Drv->display, &Drv->xshm_info)) {
 151     shmdt (Drv->image_data);
 152     XDestroyImage(Drv->image);
 153     return 0;
 154   }
 155   return 1;
 156 }
 157
 158
 159 EFI_STATUS
 160 X11Size (
 161   IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo,
 162   IN  UINT32                        Width,
 163   IN  UINT32                        Height
 164   )
 165 {
 166   GRAPHICS_IO_PRIVATE *Drv;
 167   XSizeHints          size_hints;
 168
 169   // Destroy current buffer if created.
 170   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 171   if (Drv->image != NULL) {
 172     // Before destroy buffer, need to make sure the buffer available for access.
 173     XDestroyImage (Drv->image);
 174
 175     if (Drv->use_shm) {
 176       shmdt (Drv->image_data);
 177     }
 178
 179     Drv->image_data = NULL;
 180     Drv->image = NULL;
 181   }
 182
 183   Drv->width = Width;
 184   Drv->height = Height;
 185   XResizeWindow (Drv->display, Drv->win, Width, Height);
 186
 187   // Allocate image.
 188   if (XShmQueryExtension(Drv->display) && TryCreateShmImage(Drv)) {
 189     Drv->use_shm = 1;
 190   } else {
 191     Drv->use_shm = 0;
 192     if (Drv->depth > 16) {
 193       Drv->pixel_shift = 2;
 194     } else if (Drv->depth > 8) {
 195       Drv->pixel_shift = 1;
 196     } else {
 197       Drv->pixel_shift = 0;
 198     }
 199
 200     Drv->image_data = malloc ((Drv->width * Drv->height) << Drv->pixel_shift);
 201     Drv->image = XCreateImage (
 202                     Drv->display, Drv->visual, Drv->depth,
 203                     ZPixmap, 0, (char *)Drv->image_data,
 204                     Drv->width, Drv->height,
 205                     8 << Drv->pixel_shift, 0
 206                     );
 207   }
 208
 209   Drv->line_bytes = Drv->image->bytes_per_line;
 210
 211   fill_shift_mask (&Drv->r, Drv->image->red_mask);
 212   fill_shift_mask (&Drv->g, Drv->image->green_mask);
 213   fill_shift_mask (&Drv->b, Drv->image->blue_mask);
 214
 215   // Set WM hints.
 216   size_hints.flags = PSize | PMinSize | PMaxSize;
 217   size_hints.min_width = size_hints.max_width = size_hints.base_width = Width;
 218   size_hints.min_height = size_hints.max_height = size_hints.base_height = Height;
 219   XSetWMNormalHints (Drv->display, Drv->win, &size_hints);
 220
 221   XMapWindow (Drv->display, Drv->win);
 222   HandleEvents (Drv);
 223   return EFI_SUCCESS;
 224 }
 225
 226 void
 227 handleKeyEvent (
 228   IN  GRAPHICS_IO_PRIVATE *Drv,
 229   IN  XEvent              *ev,
 230   IN  BOOLEAN             Make
 231   )
 232 {
 233   KeySym        *KeySym;
 234   EFI_KEY_DATA  KeyData;
 235   int           KeySymArraySize;
 236
 237   if (Make) {
 238     if (Drv->key_count == NBR_KEYS) {
 239       return;
 240     }
 241   }
 242
 243   // keycode is a physical key on the keyboard
 244   // KeySym is a mapping of a physical key
 245   // KeyboardMapping is the array of KeySym for a given keycode. key, shifted key, option key, command key, ...
 246   //
 247   // Returns an array of KeySymArraySize of KeySym for the keycode. [0] is lower case, [1] is upper case,
 248   // [2] and [3] are based on option and command modifiers. The problem we have is command V
 249   // could be mapped to a crazy Unicode character so the old scheme of returning a string.
 250   //
 251   KeySym = XGetKeyboardMapping (Drv->display, ev->xkey.keycode, 1, &KeySymArraySize);
 252
 253   KeyData.Key.ScanCode = 0;
 254   KeyData.Key.UnicodeChar = 0;
 255   KeyData.KeyState.KeyShiftState = 0;
 256
 257   //
 258   // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs
 259   //
 260   if ((ev->xkey.state & LockMask) == 0) {
 261     Drv->KeyState.KeyToggleState &= ~EFI_CAPS_LOCK_ACTIVE;
 262   } else {
 263     if (Make) {
 264       Drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
 265     }
 266   }
 267
 268   // Skipping EFI_MENU_KEY_PRESSED and EFI_SYS_REQ_PRESSED
 269
 270   switch (*KeySym) {
 271   case XK_Control_R:
 272     if (Make) {
 273       Drv->KeyState.KeyShiftState |=  EFI_RIGHT_CONTROL_PRESSED;
 274     } else {
 275       Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_CONTROL_PRESSED;
 276     }
 277    break;
 278   case XK_Control_L:
 279     if (Make) {
 280       Drv->KeyState.KeyShiftState |=  EFI_LEFT_CONTROL_PRESSED;
 281     } else {
 282       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_CONTROL_PRESSED;
 283     }
 284     break;
 285
 286   case XK_Shift_R:
 287     if (Make) {
 288       Drv->KeyState.KeyShiftState |=  EFI_RIGHT_SHIFT_PRESSED;
 289     } else {
 290       Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_SHIFT_PRESSED;
 291     }
 292     break;
 293   case XK_Shift_L:
 294     if (Make) {
 295       Drv->KeyState.KeyShiftState |=  EFI_LEFT_SHIFT_PRESSED;
 296     } else {
 297       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_SHIFT_PRESSED;
 298     }
 299     break;
 300
 301   case XK_Mode_switch:
 302     if (Make) {
 303       Drv->KeyState.KeyShiftState |=  EFI_LEFT_ALT_PRESSED;
 304     } else {
 305       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_ALT_PRESSED;
 306     }
 307     break;
 308
 309   case XK_Meta_R:
 310     if (Make) {
 311       Drv->KeyState.KeyShiftState |=  EFI_RIGHT_LOGO_PRESSED;
 312     } else {
 313       Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_LOGO_PRESSED;
 314     }
 315     break;
 316   case XK_Meta_L:
 317     if (Make) {
 318       Drv->KeyState.KeyShiftState |=  EFI_LEFT_LOGO_PRESSED;
 319     } else {
 320       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_LOGO_PRESSED;
 321     }
 322     break;
 323
 324   case XK_KP_Home:
 325   case XK_Home:       KeyData.Key.ScanCode = SCAN_HOME;       break;
 326
 327   case XK_KP_End:
 328   case XK_End:        KeyData.Key.ScanCode = SCAN_END;        break;
 329
 330   case XK_KP_Left:
 331   case XK_Left:       KeyData.Key.ScanCode = SCAN_LEFT;       break;
 332
 333   case XK_KP_Right:
 334   case XK_Right:      KeyData.Key.ScanCode = SCAN_RIGHT;      break;
 335
 336   case XK_KP_Up:
 337   case XK_Up:         KeyData.Key.ScanCode = SCAN_UP;         break;
 338
 339   case XK_KP_Down:
 340   case XK_Down:       KeyData.Key.ScanCode = SCAN_DOWN;       break;
 341
 342   case XK_KP_Delete:
 343   case XK_Delete:       KeyData.Key.ScanCode = SCAN_DELETE;     break;
 344
 345   case XK_KP_Insert:
 346   case XK_Insert:     KeyData.Key.ScanCode = SCAN_INSERT;     break;
 347
 348   case XK_KP_Page_Up:
 349   case XK_Page_Up:    KeyData.Key.ScanCode = SCAN_PAGE_UP;    break;
 350
 351   case XK_KP_Page_Down:
 352   case XK_Page_Down:  KeyData.Key.ScanCode = SCAN_PAGE_DOWN;  break;
 353
 354   case XK_Escape:     KeyData.Key.ScanCode = SCAN_ESC;        break;
 355
 356   case XK_Pause:      KeyData.Key.ScanCode = SCAN_PAUSE;      break;
 357
 358   case XK_KP_F1:
 359   case XK_F1:   KeyData.Key.ScanCode = SCAN_F1;   break;
 360
 361   case XK_KP_F2:
 362   case XK_F2:   KeyData.Key.ScanCode = SCAN_F2;   break;
 363
 364   case XK_KP_F3:
 365   case XK_F3:   KeyData.Key.ScanCode = SCAN_F3;   break;
 366
 367   case XK_KP_F4:
 368   case XK_F4:   KeyData.Key.ScanCode = SCAN_F4;   break;
 369
 370   case XK_F5:   KeyData.Key.ScanCode = SCAN_F5;   break;
 371   case XK_F6:   KeyData.Key.ScanCode = SCAN_F6;   break;
 372   case XK_F7:   KeyData.Key.ScanCode = SCAN_F7;   break;
 373
 374   // Don't map into X11 by default on a Mac
 375   // System Preferences->Keyboard->Keyboard Shortcuts can be configured
 376   // to not use higher function keys as shortcuts and the will show up
 377   // in X11.
 378   case XK_F8:   KeyData.Key.ScanCode = SCAN_F8;   break;
 379   case XK_F9:   KeyData.Key.ScanCode = SCAN_F9;   break;
 380   case XK_F10:  KeyData.Key.ScanCode = SCAN_F10;  break;
 381
 382   case XK_F11:  KeyData.Key.ScanCode = SCAN_F11;  break;
 383   case XK_F12:  KeyData.Key.ScanCode = SCAN_F12;  break;
 384
 385   case XK_F13:  KeyData.Key.ScanCode = SCAN_F13;  break;
 386   case XK_F14:  KeyData.Key.ScanCode = SCAN_F14;  break;
 387   case XK_F15:  KeyData.Key.ScanCode = SCAN_F15;  break;
 388   case XK_F16:  KeyData.Key.ScanCode = SCAN_F16;  break;
 389   case XK_F17:  KeyData.Key.ScanCode = SCAN_F17;  break;
 390   case XK_F18:  KeyData.Key.ScanCode = SCAN_F18;  break;
 391   case XK_F19:  KeyData.Key.ScanCode = SCAN_F19;  break;
 392   case XK_F20:  KeyData.Key.ScanCode = SCAN_F20;  break;
 393   case XK_F21:  KeyData.Key.ScanCode = SCAN_F21;  break;
 394   case XK_F22:  KeyData.Key.ScanCode = SCAN_F22;  break;
 395   case XK_F23:  KeyData.Key.ScanCode = SCAN_F23;  break;
 396   case XK_F24:  KeyData.Key.ScanCode = SCAN_F24;  break;
 397
 398   // No mapping in X11
 399   //case XK_:   KeyData.Key.ScanCode = SCAN_MUTE;            break;
 400   //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_UP;       break;
 401   //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_DOWN;     break;
 402   //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_UP;   break;
 403   //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_DOWN; break;
 404   //case XK_:   KeyData.Key.ScanCode = SCAN_SUSPEND;         break;
 405   //case XK_:   KeyData.Key.ScanCode = SCAN_HIBERNATE;       break;
 406   //case XK_:   KeyData.Key.ScanCode = SCAN_TOGGLE_DISPLAY;  break;
 407   //case XK_:   KeyData.Key.ScanCode = SCAN_RECOVERY;        break;
 408   //case XK_:   KeyData.Key.ScanCode = SCAN_EJECT;           break;
 409
 410   case XK_BackSpace:  KeyData.Key.UnicodeChar = 0x0008; break;
 411
 412   case XK_KP_Tab:
 413   case XK_Tab:        KeyData.Key.UnicodeChar = 0x0009; break;
 414
 415   case XK_Linefeed:   KeyData.Key.UnicodeChar = 0x000a; break;
 416
 417   case XK_KP_Enter:
 418   case XK_Return:     KeyData.Key.UnicodeChar = 0x000d; break;
 419
 420   case XK_KP_Equal      : KeyData.Key.UnicodeChar = L'='; break;
 421   case XK_KP_Multiply   : KeyData.Key.UnicodeChar = L'*'; break;
 422   case XK_KP_Add        : KeyData.Key.UnicodeChar = L'+'; break;
 423   case XK_KP_Separator  : KeyData.Key.UnicodeChar = L'~'; break;
 424   case XK_KP_Subtract   : KeyData.Key.UnicodeChar = L'-'; break;
 425   case XK_KP_Decimal    : KeyData.Key.UnicodeChar = L'.'; break;
 426   case XK_KP_Divide     : KeyData.Key.UnicodeChar = L'/'; break;
 427
 428   case XK_KP_0    : KeyData.Key.UnicodeChar = L'0'; break;
 429   case XK_KP_1    : KeyData.Key.UnicodeChar = L'1'; break;
 430   case XK_KP_2    : KeyData.Key.UnicodeChar = L'2'; break;
 431   case XK_KP_3    : KeyData.Key.UnicodeChar = L'3'; break;
 432   case XK_KP_4    : KeyData.Key.UnicodeChar = L'4'; break;
 433   case XK_KP_5    : KeyData.Key.UnicodeChar = L'5'; break;
 434   case XK_KP_6    : KeyData.Key.UnicodeChar = L'6'; break;
 435   case XK_KP_7    : KeyData.Key.UnicodeChar = L'7'; break;
 436   case XK_KP_8    : KeyData.Key.UnicodeChar = L'8'; break;
 437   case XK_KP_9    : KeyData.Key.UnicodeChar = L'9'; break;
 438
 439   default:
 440     ;
 441   }
 442
 443   // The global state is our state
 444   KeyData.KeyState.KeyShiftState = Drv->KeyState.KeyShiftState;
 445   KeyData.KeyState.KeyToggleState = Drv->KeyState.KeyToggleState;
 446
 447   if (*KeySym < XK_BackSpace) {
 448     if (((Drv->KeyState.KeyShiftState & (EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED)) != 0) ||
 449         ((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) != 0) ) {
 450
 451       KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_UPPER];
 452
 453       // Per UEFI spec since we converted the Unicode clear the shift bits we pass up
 454       KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED);
 455     } else {
 456       KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_LOWER];
 457     }
 458   } else {
 459     // XK_BackSpace is the start of XK_MISCELLANY. These are the XK_? keys we process in this file
 460     ;
 461   }
 462
 463   if (Make) {
 464     memcpy (&Drv->keys[Drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA));
 465     Drv->key_wr = (Drv->key_wr + 1) % NBR_KEYS;
 466     Drv->key_count++;
 467     if (Drv->MakeRegisterdKeyCallback != NULL) {
 468       ReverseGasketUint64Uint64 (Drv->MakeRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData);
 469     }
 470   } else {
 471     if (Drv->BreakRegisterdKeyCallback != NULL) {
 472       ReverseGasketUint64Uint64 (Drv->BreakRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData);
 473     }
 474   }
 475 }
 476
 477
 478 void
 479 handleMouseMoved(
 480   IN  GRAPHICS_IO_PRIVATE   *Drv,
 481   IN  XEvent                *ev
 482   )
 483 {
 484   if (ev->xmotion.x != Drv->previous_x) {
 485     Drv->pointer_state.RelativeMovementX += ( ev->xmotion.x - Drv->previous_x );
 486     Drv->previous_x = ev->xmotion.x;
 487     Drv->pointer_state_changed = 1;
 488   }
 489
 490   if (ev->xmotion.y != Drv->previous_y) {
 491     Drv->pointer_state.RelativeMovementY += ( ev->xmotion.y - Drv->previous_y );
 492     Drv->previous_y = ev->xmotion.y;
 493     Drv->pointer_state_changed = 1;
 494   }
 495
 496   Drv->pointer_state.RelativeMovementZ = 0;
 497 }
 498
 499 void
 500 handleMouseDown (
 501   IN  GRAPHICS_IO_PRIVATE *Drv,
 502   IN  XEvent              *ev,
 503   IN  BOOLEAN             Pressed
 504   )
 505 {
 506   if (ev->xbutton.button == Button1) {
 507     Drv->pointer_state_changed = (Drv->pointer_state.LeftButton != Pressed);
 508     Drv->pointer_state.LeftButton = Pressed;
 509   }
 510   if ( ev->xbutton.button == Button2 ) {
 511     Drv->pointer_state_changed = (Drv->pointer_state.RightButton != Pressed);
 512     Drv->pointer_state.RightButton = Pressed;
 513   }
 514 }
 515
 516 void
 517 Redraw (
 518   IN  GRAPHICS_IO_PRIVATE *Drv,
 519   IN  UINTN               X,
 520   IN  UINTN               Y,
 521   IN  UINTN               Width,
 522   IN  UINTN               Height
 523   )
 524 {
 525   if (Drv->use_shm) {
 526     XShmPutImage (
 527       Drv->display, Drv->win, Drv->gc, Drv->image, X, Y, X, Y, Width, Height, False
 528       );
 529   } else {
 530     XPutImage (
 531       Drv->display, Drv->win, Drv->gc, Drv->image, X, Y, X, Y, Width, Height
 532       );
 533   }
 534   XFlush(Drv->display);
 535 }
 536
 537 void
 538 HandleEvent(GRAPHICS_IO_PRIVATE *Drv, XEvent *ev)
 539 {
 540   switch (ev->type) {
 541   case Expose:
 542     Redraw (Drv, ev->xexpose.x, ev->xexpose.y,
 543       ev->xexpose.width, ev->xexpose.height);
 544     break;
 545   case GraphicsExpose:
 546     Redraw (Drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y,
 547       ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
 548     break;
 549   case KeyPress:
 550     handleKeyEvent (Drv, ev, TRUE);
 551     break;
 552   case KeyRelease:
 553     handleKeyEvent (Drv, ev, FALSE);
 554     break;
 555   case MappingNotify:
 556     XRefreshKeyboardMapping (&ev->xmapping);
 557     break;
 558   case MotionNotify:
 559     handleMouseMoved (Drv, ev);
 560     break;
 561   case ButtonPress:
 562     handleMouseDown (Drv, ev, TRUE);
 563   break;
 564   case ButtonRelease:
 565     handleMouseDown (Drv, ev, FALSE);
 566   break;
 567 #if 0
 568   case DestroyNotify:
 569     XCloseDisplay (Drv->display);
 570     exit (1);
 571     break;
 572 #endif
 573   case NoExpose:
 574   default:
 575     break;
 576   }
 577 }
 578
 579 void
 580 HandleEvents (
 581   IN  GRAPHICS_IO_PRIVATE *Drv
 582   )
 583 {
 584   XEvent ev;
 585
 586   while (XPending (Drv->display) != 0) {
 587     XNextEvent (Drv->display, &ev);
 588     HandleEvent (Drv, &ev);
 589   }
 590 }
 591
 592 unsigned long
 593 X11PixelToColor (
 594   IN  GRAPHICS_IO_PRIVATE *Drv,
 595   IN  EFI_UGA_PIXEL       pixel
 596   )
 597 {
 598   return ((pixel.Red   >> Drv->r.csize) << Drv->r.shift)
 599        | ((pixel.Green >> Drv->g.csize) << Drv->g.shift)
 600        | ((pixel.Blue  >> Drv->b.csize) << Drv->b.shift);
 601 }
 602
 603 EFI_UGA_PIXEL
 604 X11ColorToPixel (
 605   IN  GRAPHICS_IO_PRIVATE *Drv,
 606   IN  unsigned long       val
 607   )
 608 {
 609   EFI_UGA_PIXEL Pixel;
 610
 611   memset (&Pixel, 0, sizeof (EFI_UGA_PIXEL));
 612
 613   // Truncation not an issue since X11 and EFI are both using 8 bits per color
 614   Pixel.Red =   (val >> Drv->r.shift) << Drv->r.csize;
 615   Pixel.Green = (val >> Drv->g.shift) << Drv->g.csize;
 616   Pixel.Blue =  (val >> Drv->b.shift) << Drv->b.csize;
 617
 618   return Pixel;
 619 }
 620
 621
 622 EFI_STATUS
 623 X11CheckKey (
 624   IN  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
 625   )
 626 {
 627   GRAPHICS_IO_PRIVATE  *Drv;
 628
 629   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 630
 631   HandleEvents (Drv);
 632
 633   if (Drv->key_count != 0) {
 634     return EFI_SUCCESS;
 635   }
 636
 637   return EFI_NOT_READY;
 638 }
 639
 640 EFI_STATUS
 641 X11GetKey (
 642   IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo,
 643   IN  EFI_KEY_DATA                  *KeyData
 644   )
 645 {
 646   EFI_STATUS          EfiStatus;
 647   GRAPHICS_IO_PRIVATE *Drv;
 648
 649   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 650
 651   EfiStatus = X11CheckKey (GraphicsIo);
 652   if (EFI_ERROR (EfiStatus)) {
 653     return EfiStatus;
 654   }
 655
 656   CopyMem (KeyData, &Drv->keys[Drv->key_rd], sizeof (EFI_KEY_DATA));
 657   Drv->key_rd = (Drv->key_rd + 1) % NBR_KEYS;
 658   Drv->key_count--;
 659
 660   return EFI_SUCCESS;
 661 }
 662
 663
 664 EFI_STATUS
 665 X11KeySetState (
 666   IN EMU_GRAPHICS_WINDOW_PROTOCOL   *GraphicsIo,
 667   IN EFI_KEY_TOGGLE_STATE           *KeyToggleState
 668   )
 669 {
 670   GRAPHICS_IO_PRIVATE  *Drv;
 671
 672   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 673
 674   if (*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) {
 675     if ((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == 0) {
 676       //
 677       // We could create an XKeyEvent and send a XK_Caps_Lock to
 678       // the UGA/GOP Window
 679       //
 680     }
 681   }
 682
 683   Drv->KeyState.KeyToggleState = *KeyToggleState;
 684   return EFI_SUCCESS;
 685 }
 686
 687
 688 EFI_STATUS
 689 X11RegisterKeyNotify (
 690   IN EMU_GRAPHICS_WINDOW_PROTOCOL                        *GraphicsIo,
 691   IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    MakeCallBack,
 692   IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    BreakCallBack,
 693   IN VOID                                                *Context
 694   )
 695 {
 696   GRAPHICS_IO_PRIVATE  *Drv;
 697
 698   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 699
 700   Drv->MakeRegisterdKeyCallback    = MakeCallBack;
 701   Drv->BreakRegisterdKeyCallback   = BreakCallBack;
 702   Drv->RegisterdKeyCallbackContext = Context;
 703
 704   return EFI_SUCCESS;
 705 }
 706
 707
 708 EFI_STATUS
 709 X11Blt (
 710   IN EMU_GRAPHICS_WINDOW_PROTOCOL             *GraphicsIo,
 711   IN  EFI_UGA_PIXEL                           *BltBuffer OPTIONAL,
 712   IN  EFI_UGA_BLT_OPERATION                   BltOperation,
 713   IN  EMU_GRAPHICS_WINDOWS__BLT_ARGS          *Args
 714   )
 715 {
 716   GRAPHICS_IO_PRIVATE *Private;
 717   UINTN             DstY;
 718   UINTN             SrcY;
 719   UINTN             DstX;
 720   UINTN             SrcX;
 721   UINTN             Index;
 722   EFI_UGA_PIXEL     *Blt;
 723   UINT8             *Dst;
 724   UINT8             *Src;
 725   UINTN             Nbr;
 726   unsigned long     Color;
 727   XEvent            ev;
 728
 729   Private = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 730
 731
 732   //
 733   //  Check bounds
 734   //
 735   if (BltOperation == EfiUgaVideoToBltBuffer
 736       || BltOperation == EfiUgaVideoToVideo) {
 737     //
 738     // Source is Video.
 739     //
 740     if (Args->SourceY + Args->Height > Private->height) {
 741       return EFI_INVALID_PARAMETER;
 742     }
 743
 744     if (Args->SourceX + Args->Width > Private->width) {
 745       return EFI_INVALID_PARAMETER;
 746     }
 747   }
 748
 749   if (BltOperation == EfiUgaBltBufferToVideo
 750       || BltOperation == EfiUgaVideoToVideo
 751       || BltOperation == EfiUgaVideoFill) {
 752     //
 753     // Destination is Video
 754     //
 755     if (Args->DestinationY + Args->Height > Private->height) {
 756       return EFI_INVALID_PARAMETER;
 757     }
 758
 759     if (Args->DestinationX + Args->Width > Private->width) {
 760       return EFI_INVALID_PARAMETER;
 761     }
 762   }
 763
 764   switch (BltOperation) {
 765   case EfiUgaVideoToBltBuffer:
 766     Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->DestinationY * Args->Delta) + Args->DestinationX * sizeof (EFI_UGA_PIXEL));
 767     Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
 768     for (SrcY = Args->SourceY; SrcY < (Args->Height + Args->SourceY); SrcY++) {
 769       for (SrcX = Args->SourceX; SrcX < (Args->Width + Args->SourceX); SrcX++) {
 770         *Blt++ = X11ColorToPixel (Private, XGetPixel (Private->image, SrcX, SrcY));
 771       }
 772       Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
 773     }
 774     break;
 775   case EfiUgaBltBufferToVideo:
 776     Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->SourceY * Args->Delta) + Args->SourceX * sizeof (EFI_UGA_PIXEL));
 777     Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
 778     for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
 779       for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
 780         XPutPixel(Private->image, DstX, DstY, X11PixelToColor(Private, *Blt));
 781         Blt++;
 782       }
 783       Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
 784     }
 785     break;
 786   case EfiUgaVideoToVideo:
 787     Dst = Private->image_data + (Args->DestinationX << Private->pixel_shift)
 788           + Args->DestinationY * Private->line_bytes;
 789     Src = Private->image_data + (Args->SourceX << Private->pixel_shift)
 790           + Args->SourceY * Private->line_bytes;
 791     Nbr = Args->Width << Private->pixel_shift;
 792     if (Args->DestinationY < Args->SourceY) {
 793       for (Index = 0; Index < Args->Height; Index++) {
 794         memcpy (Dst, Src, Nbr);
 795         Dst += Private->line_bytes;
 796         Src += Private->line_bytes;
 797       }
 798     } else {
 799       Dst += (Args->Height - 1) * Private->line_bytes;
 800       Src += (Args->Height - 1) * Private->line_bytes;
 801       for (Index = 0; Index < Args->Height; Index++) {
 802       //
 803       // Source and Destination Y may be equal, therefore Dst and Src may
 804       // overlap.
 805       //
 806       memmove (Dst, Src, Nbr);
 807       Dst -= Private->line_bytes;
 808       Src -= Private->line_bytes;
 809       }
 810     }
 811     break;
 812   case EfiUgaVideoFill:
 813     Color = X11PixelToColor(Private, *BltBuffer);
 814     for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
 815       for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
 816         XPutPixel(Private->image, DstX, DstY, Color);
 817       }
 818     }
 819     break;
 820   default:
 821     return EFI_INVALID_PARAMETER;
 822   }
 823
 824   //
 825   //  Refresh screen.
 826   //
 827   switch (BltOperation) {
 828   case EfiUgaVideoToVideo:
 829     XCopyArea(
 830       Private->display, Private->win, Private->win, Private->gc,
 831       Args->SourceX, Args->SourceY, Args->Width, Args->Height,
 832       Args->DestinationX, Args->DestinationY
 833       );
 834
 835     while (1) {
 836       XNextEvent (Private->display, &ev);
 837       HandleEvent (Private, &ev);
 838       if (ev.type == NoExpose || ev.type == GraphicsExpose) {
 839         break;
 840       }
 841     }
 842     break;
 843   case EfiUgaVideoFill:
 844     Color = X11PixelToColor (Private, *BltBuffer);
 845     XSetForeground (Private->display, Private->gc, Color);
 846     XFillRectangle (
 847       Private->display, Private->win, Private->gc,
 848       Args->DestinationX, Args->DestinationY, Args->Width, Args->Height
 849       );
 850     XFlush (Private->display);
 851     break;
 852   case EfiUgaBltBufferToVideo:
 853     Redraw (Private, Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
 854     break;
 855   default:
 856     break;
 857   }
 858   return EFI_SUCCESS;
 859 }
 860
 861
 862 EFI_STATUS
 863 X11CheckPointer (
 864   IN  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
 865   )
 866 {
 867   GRAPHICS_IO_PRIVATE  *Drv;
 868
 869   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 870
 871   HandleEvents (Drv);
 872   if (Drv->pointer_state_changed != 0) {
 873     return EFI_SUCCESS;
 874   }
 875
 876   return EFI_NOT_READY;
 877 }
 878
 879
 880 EFI_STATUS
 881 X11GetPointerState (
 882   IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo,
 883   IN  EFI_SIMPLE_POINTER_STATE      *State
 884   )
 885 {
 886   EFI_STATUS          EfiStatus;
 887   GRAPHICS_IO_PRIVATE *Drv;
 888
 889   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 890
 891   EfiStatus = X11CheckPointer (GraphicsIo);
 892   if (EfiStatus != EFI_SUCCESS) {
 893     return EfiStatus;
 894   }
 895
 896   memcpy (State, &Drv->pointer_state, sizeof (EFI_SIMPLE_POINTER_STATE));
 897
 898   Drv->pointer_state.RelativeMovementX = 0;
 899   Drv->pointer_state.RelativeMovementY = 0;
 900   Drv->pointer_state.RelativeMovementZ = 0;
 901   Drv->pointer_state_changed = 0;
 902   return EFI_SUCCESS;
 903 }
 904
 905
 906
 907 EFI_STATUS
 908 X11GraphicsWindowOpen (
 909   IN  EMU_IO_THUNK_PROTOCOL   *This
 910   )
 911 {
 912   GRAPHICS_IO_PRIVATE *Drv;
 913   unsigned int        border_width = 0;
 914   char                *display_name = NULL;
 915
 916   Drv = (GRAPHICS_IO_PRIVATE *)calloc (1, sizeof (GRAPHICS_IO_PRIVATE));
 917   if (Drv == NULL) {
 918     return EFI_OUT_OF_RESOURCES;
 919   }
 920
 921   Drv->GraphicsIo.Size                = GasketX11Size;
 922   Drv->GraphicsIo.CheckKey            = GasketX11CheckKey;
 923   Drv->GraphicsIo.GetKey              = GasketX11GetKey;
 924   Drv->GraphicsIo.KeySetState         = GasketX11KeySetState;
 925   Drv->GraphicsIo.RegisterKeyNotify   = GasketX11RegisterKeyNotify;
 926   Drv->GraphicsIo.Blt                 = GasketX11Blt;
 927   Drv->GraphicsIo.CheckPointer        = GasketX11CheckPointer;
 928   Drv->GraphicsIo.GetPointerState     = GasketX11GetPointerState;
 929
 930
 931   Drv->key_count = 0;
 932   Drv->key_rd = 0;
 933   Drv->key_wr = 0;
 934   Drv->KeyState.KeyShiftState      = EFI_SHIFT_STATE_VALID;
 935   Drv->KeyState.KeyToggleState     = EFI_TOGGLE_STATE_VALID;
 936   Drv->MakeRegisterdKeyCallback    = NULL;
 937   Drv->BreakRegisterdKeyCallback   = NULL;
 938   Drv->RegisterdKeyCallbackContext = NULL;
 939
 940
 941   Drv->display = XOpenDisplay (display_name);
 942   if (Drv->display == NULL) {
 943     fprintf (stderr, "uga: cannot connect to X server %s\n", XDisplayName (display_name));
 944     free (Drv);
 945     return EFI_DEVICE_ERROR;
 946   }
 947   Drv->screen = DefaultScreen (Drv->display);
 948   Drv->visual = DefaultVisual (Drv->display, Drv->screen);
 949   Drv->win = XCreateSimpleWindow (
 950                 Drv->display, RootWindow (Drv->display, Drv->screen),
 951                 0, 0, 4, 4, border_width,
 952                 WhitePixel (Drv->display, Drv->screen),
 953                 BlackPixel (Drv->display, Drv->screen)
 954                 );
 955
 956   Drv->depth = DefaultDepth (Drv->display, Drv->screen);
 957   XDefineCursor (Drv->display, Drv->win, XCreateFontCursor (Drv->display, XC_pirate));
 958
 959   Drv->Title = malloc (StrSize (This->ConfigString));
 960   UnicodeStrToAsciiStr (This->ConfigString, Drv->Title);
 961   XStoreName (Drv->display, Drv->win, Drv->Title);
 962
 963 //  XAutoRepeatOff (Drv->display);
 964   XSelectInput (
 965     Drv->display, Drv->win,
 966     ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask
 967     );
 968   Drv->gc = DefaultGC (Drv->display, Drv->screen);
 969
 970   This->Private   = (VOID *)Drv;
 971   This->Interface = (VOID *)Drv;
 972   return EFI_SUCCESS;
 973 }
 974
 975
 976 EFI_STATUS
 977 X11GraphicsWindowClose (
 978   IN  EMU_IO_THUNK_PROTOCOL   *This
 979   )
 980 {
 981   GRAPHICS_IO_PRIVATE *Drv;
 982
 983   Drv = (GRAPHICS_IO_PRIVATE *)This->Private;
 984
 985   if (Drv == NULL) {
 986     return EFI_SUCCESS;
 987   }
 988
 989   if (Drv->image != NULL) {
 990     XDestroyImage(Drv->image);
 991
 992     if (Drv->use_shm) {
 993       shmdt (Drv->image_data);
 994     }
 995
 996     Drv->image_data = NULL;
 997     Drv->image = NULL;
 998   }
 999   XDestroyWindow (Drv->display, Drv->win);
1000   XCloseDisplay (Drv->display);
1001
1002 #ifdef __APPLE__
1003   // Free up the shared memory
1004   shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
1005 #endif
1006
1007   free (Drv);
1008   return EFI_SUCCESS;
1009 }
1010
1011
1012 EMU_IO_THUNK_PROTOCOL gX11ThunkIo = {
1013   &gEmuGraphicsWindowProtocolGuid,
1014   NULL,
1015   NULL,
1016   0,
1017   GasketX11GraphicsWindowOpen,
1018   GasketX11GraphicsWindowClose,
1019   NULL
1020 };
1021
1022