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