1 /* 2 * Xephyr - A kdrive X server thats runs in a host X window. 3 * Authored by Matthew Allum <mallum (at) o-hand.com> 4 * 5 * Copyright 2004 Nokia 6 * 7 * Permission to use, copy, modify, distribute, and sell this software and its 8 * documentation for any purpose is hereby granted without fee, provided that 9 * the above copyright notice appear in all copies and that both that 10 * copyright notice and this permission notice appear in supporting 11 * documentation, and that the name of Nokia not be used in 12 * advertising or publicity pertaining to distribution of the software without 13 * specific, written prior permission. Nokia makes no 14 * representations about the suitability of this software for any purpose. It 15 * is provided "as is" without express or implied warranty. 16 * 17 * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 18 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 19 * EVENT SHALL NOKIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR 20 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 22 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 23 * PERFORMANCE OF THIS SOFTWARE. 24 */ 25 26 #ifdef HAVE_CONFIG_H 27 #include <kdrive-config.h> 28 #endif 29 30 /* 31 * including some server headers (like kdrive-config.h) 32 * might define the macro _XSERVER64 33 * on 64 bits machines. That macro must _NOT_ be defined for Xlib 34 * client code, otherwise bad things happen. 35 * So let's undef that macro if necessary. 36 */ 37 #ifdef _XSERVER64 38 #undef _XSERVER64 39 #endif 40 41 42 #include "hostx.h" 43 44 #include <stdlib.h> 45 #include <stdio.h> 46 #include <unistd.h> 47 #include <string.h> /* for memset */ 48 #include <time.h> 49 50 #include <sys/ipc.h> 51 #include <sys/shm.h> 52 #include <sys/time.h> 53 54 #include <X11/Xlib.h> 55 #include <X11/Xutil.h> 56 #include <X11/Xatom.h> 57 #include <X11/keysym.h> 58 #include <X11/extensions/XShm.h> 59 #include <X11/extensions/shape.h> 60 #ifdef XF86DRI 61 #include <GL/glx.h> 62 #endif /* XF86DRI */ 63 #include "ephyrlog.h" 64 65 #ifdef XF86DRI 66 extern Bool XF86DRIQueryExtension (Display *dpy, 67 int *event_basep, 68 int *error_basep); 69 #endif 70 71 /* 72 * All xlib calls go here, which gets built as its own .a . 73 * Mixing kdrive and xlib headers causes all sorts of types 74 * to get clobbered. 75 */ 76 77 struct EphyrHostScreen 78 { 79 Window win; 80 Window win_pre_existing; /* Set via -parent option like xnest */ 81 Window peer_win; /* Used for GL; should be at most one */ 82 XImage *ximg; 83 int win_width, win_height; 84 int server_depth; 85 unsigned char *fb_data; /* only used when host bpp != server bpp */ 86 XShmSegmentInfo shminfo; 87 88 void *info; /* Pointer to the screen this is associated with */ 89 int mynum; /* Screen number */ 90 }; 91 92 struct EphyrHostXVars 93 { 94 char *server_dpy_name; 95 Display *dpy; 96 int screen; 97 Visual *visual; 98 Window winroot; 99 GC gc; 100 int depth; 101 Bool use_host_cursor; 102 Bool use_fullscreen; 103 Bool have_shm; 104 105 int n_screens; 106 struct EphyrHostScreen *screens; 107 108 long damage_debug_msec; 109 110 unsigned long cmap[256]; 111 }; 112 113 /* memset ( missing> ) instead of below */ 114 /*static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};*/ 115 static EphyrHostXVars HostX; 116 117 static int HostXWantDamageDebug = 0; 118 119 extern EphyrKeySyms ephyrKeySyms; 120 121 extern int monitorResolution; 122 123 char *ephyrResName = NULL; 124 int ephyrResNameFromCmd = 0; 125 char *ephyrTitle = NULL; 126 127 static void 128 hostx_set_fullscreen_hint(void); 129 130 /* X Error traps */ 131 132 static int trapped_error_code = 0; 133 static int (*old_error_handler) (Display *d, XErrorEvent *e); 134 135 #define host_depth_matches_server(_vars) (HostX.depth == (_vars)->server_depth) 136 137 static struct EphyrHostScreen * 138 host_screen_from_screen_info (EphyrScreenInfo *screen) 139 { 140 int i; 141 142 for (i = 0 ; i < HostX.n_screens ; i++) 143 { 144 if ( HostX.screens[i].info == screen) 145 { 146 return &HostX.screens[i]; 147 } 148 } 149 return NULL; 150 } 151 152 static int 153 error_handler(Display *display, 154 XErrorEvent *error) 155 { 156 trapped_error_code = error->error_code; 157 return 0; 158 } 159 160 static void 161 hostx_errors_trap(void) 162 { 163 trapped_error_code = 0; 164 old_error_handler = XSetErrorHandler(error_handler); 165 } 166 167 static int 168 hostx_errors_untrap(void) 169 { 170 XSetErrorHandler(old_error_handler); 171 return trapped_error_code; 172 } 173 174 int 175 hostx_want_screen_size (EphyrScreenInfo screen, int *width, int *height ) 176 { 177 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 178 179 if (host_screen && 180 (host_screen->win_pre_existing != None || 181 HostX.use_fullscreen == True)) 182 { 183 *width = host_screen->win_width; 184 *height = host_screen->win_height; 185 return 1; 186 } 187 188 return 0; 189 } 190 191 void 192 hostx_add_screen (EphyrScreenInfo screen, 193 unsigned long win_id, 194 int screen_num) 195 { 196 int index = HostX.n_screens; 197 198 HostX.n_screens += 1; 199 HostX.screens = realloc (HostX.screens, 200 HostX.n_screens * sizeof(struct EphyrHostScreen)); 201 memset (&HostX.screens[index], 0, sizeof (struct EphyrHostScreen)); 202 203 HostX.screens[index].info = screen; 204 HostX.screens[index].win_pre_existing = win_id; 205 } 206 207 208 void 209 hostx_set_display_name (char *name) 210 { 211 HostX.server_dpy_name = strdup (name); 212 } 213 214 void 215 hostx_set_screen_number(EphyrScreenInfo screen, int number) 216 { 217 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 218 if (host_screen) { 219 host_screen->mynum = number; 220 hostx_set_win_title (host_screen->info, "") ; 221 }} 222 223 void 224 hostx_set_win_title (EphyrScreenInfo screen, char *extra_text) 225 { 226 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 227 228 if (!host_screen) 229 return; 230 231 if (ephyrTitle) { 232 XStoreName(HostX.dpy, host_screen->win, ephyrTitle); 233 } else { 234 #define BUF_LEN 256 235 char buf[BUF_LEN+1]; 236 237 memset (buf, 0, BUF_LEN+1) ; 238 snprintf (buf, BUF_LEN, "Xephyr on %s.%d %s", 239 HostX.server_dpy_name, 240 host_screen->mynum, 241 (extra_text != NULL) ? extra_text : ""); 242 243 XStoreName (HostX.dpy, host_screen->win, buf); 244 } 245 } 246 247 int 248 hostx_want_host_cursor (void) 249 { 250 return HostX.use_host_cursor; 251 } 252 253 void 254 hostx_use_host_cursor (void) 255 { 256 HostX.use_host_cursor = True; 257 } 258 259 int 260 hostx_want_preexisting_window (EphyrScreenInfo screen) 261 { 262 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 263 264 if (host_screen && host_screen->win_pre_existing) 265 { 266 return 1; 267 } 268 else 269 { 270 return 0; 271 } 272 } 273 274 void 275 hostx_use_fullscreen (void) 276 { 277 HostX.use_fullscreen = True; 278 } 279 280 int 281 hostx_want_fullscreen (void) 282 { 283 return HostX.use_fullscreen; 284 } 285 286 static void 287 hostx_set_fullscreen_hint (void) 288 { 289 Atom atom_WINDOW_STATE, atom_WINDOW_STATE_FULLSCREEN; 290 int index; 291 292 atom_WINDOW_STATE 293 = XInternAtom(HostX.dpy, "_NET_WM_STATE", False); 294 atom_WINDOW_STATE_FULLSCREEN 295 = XInternAtom(HostX.dpy, "_NET_WM_STATE_FULLSCREEN",False); 296 297 for (index = 0 ; index < HostX.n_screens ; index++) 298 { 299 XChangeProperty (HostX.dpy, HostX.screens[index].win, 300 atom_WINDOW_STATE, XA_ATOM, 32, 301 PropModeReplace, 302 (unsigned char *)&atom_WINDOW_STATE_FULLSCREEN, 1); 303 } 304 } 305 306 307 static void 308 hostx_toggle_damage_debug (void) 309 { 310 HostXWantDamageDebug ^= 1; 311 } 312 313 void 314 hostx_handle_signal (int signum) 315 { 316 hostx_toggle_damage_debug(); 317 EPHYR_DBG ("Signal caught. Damage Debug:%i\n", 318 HostXWantDamageDebug); 319 } 320 321 void 322 hostx_use_resname (char *name, int fromcmd) 323 { 324 ephyrResName = name; 325 ephyrResNameFromCmd = fromcmd; 326 } 327 328 void 329 hostx_set_title (char *title) 330 { 331 ephyrTitle = title; 332 } 333 334 int 335 hostx_init (void) 336 { 337 XSetWindowAttributes attr; 338 Cursor empty_cursor; 339 Pixmap cursor_pxm; 340 XColor col; 341 int index; 342 char *tmpstr; 343 XClassHint *class_hint; 344 345 attr.event_mask = 346 ButtonPressMask 347 |ButtonReleaseMask 348 |PointerMotionMask 349 |KeyPressMask 350 |KeyReleaseMask 351 |ExposureMask; 352 353 EPHYR_DBG("mark"); 354 355 if ((HostX.dpy = XOpenDisplay(getenv("DISPLAY"))) == NULL) 356 { 357 fprintf(stderr, "\nXephyr cannot open host display. Is DISPLAY set?\n"); 358 exit(1); 359 } 360 361 HostX.screen = DefaultScreen(HostX.dpy); 362 HostX.winroot = RootWindow(HostX.dpy, HostX.screen); 363 HostX.gc = XCreateGC(HostX.dpy, HostX.winroot, 0, NULL); 364 HostX.depth = DefaultDepth(HostX.dpy, HostX.screen); 365 HostX.visual = DefaultVisual(HostX.dpy, HostX.screen); 366 367 class_hint = XAllocClassHint(); 368 369 for (index = 0 ; index < HostX.n_screens ; index++) 370 { 371 struct EphyrHostScreen *host_screen = &HostX.screens[index]; 372 373 host_screen->server_depth = HostX.depth; 374 if (host_screen->win_pre_existing != None) 375 { 376 Status result; 377 XWindowAttributes prewin_attr; 378 379 /* Get screen size from existing window */ 380 381 hostx_errors_trap(); 382 383 result = XGetWindowAttributes (HostX.dpy, 384 host_screen->win_pre_existing, 385 &prewin_attr); 386 387 388 if (hostx_errors_untrap() || !result) 389 { 390 fprintf (stderr, "\nXephyr -parent window' does not exist!\n"); 391 exit (1); 392 } 393 394 host_screen->win_width = prewin_attr.width; 395 host_screen->win_height = prewin_attr.height; 396 397 host_screen->win = XCreateWindow (HostX.dpy, 398 host_screen->win_pre_existing, 399 0,0, 400 host_screen->win_width, 401 host_screen->win_height, 402 0, 403 CopyFromParent, 404 CopyFromParent, 405 CopyFromParent, 406 CWEventMask, 407 &attr); 408 } 409 else 410 { 411 host_screen->win = XCreateWindow (HostX.dpy, 412 HostX.winroot, 413 0,0,100,100, /* will resize */ 414 0, 415 CopyFromParent, 416 CopyFromParent, 417 CopyFromParent, 418 CWEventMask, 419 &attr); 420 421 hostx_set_win_title (host_screen->info, 422 "(ctrl+shift grabs mouse and keyboard)"); 423 424 if (HostX.use_fullscreen) 425 { 426 host_screen->win_width = DisplayWidth(HostX.dpy, HostX.screen); 427 host_screen->win_height = DisplayHeight(HostX.dpy, HostX.screen); 428 429 hostx_set_fullscreen_hint(); 430 } 431 432 if (class_hint) 433 { 434 tmpstr = getenv("RESOURCE_NAME"); 435 if (tmpstr && (!ephyrResNameFromCmd)) 436 ephyrResName = tmpstr; 437 class_hint->res_name = ephyrResName; 438 class_hint->res_class = "Xephyr"; 439 XSetClassHint(hostx_get_display(), host_screen->win, class_hint); 440 441 } 442 443 } 444 } 445 446 if (class_hint) 447 XFree(class_hint); 448 449 XParseColor (HostX.dpy, DefaultColormap (HostX.dpy,HostX.screen), 450 "red", &col); 451 XAllocColor (HostX.dpy, DefaultColormap (HostX.dpy, HostX.screen), 452 &col); 453 XSetForeground (HostX.dpy, HostX.gc, col.pixel); 454 455 if (!hostx_want_host_cursor ()) 456 { 457 /* Ditch the cursor, we provide our 'own' */ 458 cursor_pxm = XCreatePixmap (HostX.dpy, HostX.winroot, 1, 1, 1); 459 memset (&col, 0, sizeof (col)); 460 empty_cursor = XCreatePixmapCursor (HostX.dpy, 461 cursor_pxm, cursor_pxm, 462 &col, &col, 1, 1); 463 for ( index = 0 ; index < HostX.n_screens ; index++ ) 464 { 465 XDefineCursor (HostX.dpy, 466 HostX.screens[index].win, 467 empty_cursor); 468 } 469 XFreePixmap (HostX.dpy, cursor_pxm); 470 } 471 472 for (index = 0 ; index < HostX.n_screens ; index++) 473 { 474 HostX.screens[index].ximg = NULL; 475 } 476 /* Try to get share memory ximages for a little bit more speed */ 477 478 if (!XShmQueryExtension(HostX.dpy) || getenv("XEPHYR_NO_SHM")) 479 { 480 fprintf(stderr, "\nXephyr unable to use SHM XImages\n"); 481 HostX.have_shm = False; 482 } 483 else 484 { 485 /* Really really check we have shm - better way ?*/ 486 XShmSegmentInfo shminfo; 487 488 HostX.have_shm = True; 489 490 shminfo.shmid=shmget(IPC_PRIVATE, 1, IPC_CREAT|0777); 491 shminfo.shmaddr=shmat(shminfo.shmid,0,0); 492 shminfo.readOnly=True; 493 494 hostx_errors_trap(); 495 496 XShmAttach(HostX.dpy, &shminfo); 497 XSync(HostX.dpy, False); 498 499 if (hostx_errors_untrap()) 500 { 501 fprintf(stderr, "\nXephyr unable to use SHM XImages\n"); 502 HostX.have_shm = False; 503 } 504 505 shmdt(shminfo.shmaddr); 506 shmctl(shminfo.shmid, IPC_RMID, 0); 507 } 508 509 XFlush(HostX.dpy); 510 511 /* Setup the pause time between paints when debugging updates */ 512 513 HostX.damage_debug_msec = 20000; /* 1/50 th of a second */ 514 515 if (getenv ("XEPHYR_PAUSE")) 516 { 517 HostX.damage_debug_msec = strtol (getenv ("XEPHYR_PAUSE"), NULL, 0); 518 EPHYR_DBG ("pause is %li\n", HostX.damage_debug_msec); 519 } 520 521 return 1; 522 } 523 524 int 525 hostx_get_depth (void) 526 { 527 return HostX.depth; 528 } 529 530 int 531 hostx_get_server_depth (EphyrScreenInfo screen) 532 { 533 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 534 535 return host_screen ? host_screen->server_depth : 0; 536 } 537 538 void 539 hostx_set_server_depth (EphyrScreenInfo screen, int depth) 540 { 541 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 542 543 if (host_screen) 544 host_screen->server_depth = depth; 545 } 546 547 int 548 hostx_get_bpp (EphyrScreenInfo screen) 549 { 550 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 551 552 if (!host_screen) 553 return 0; 554 555 if (host_depth_matches_server (host_screen)) 556 return HostX.visual->bits_per_rgb; 557 else 558 return host_screen->server_depth; /*XXX correct ?*/ 559 } 560 561 void 562 hostx_get_visual_masks (EphyrScreenInfo screen, 563 CARD32 *rmsk, 564 CARD32 *gmsk, 565 CARD32 *bmsk) 566 { 567 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 568 569 if (!host_screen) 570 return; 571 572 if (host_depth_matches_server(host_screen)) 573 { 574 *rmsk = HostX.visual->red_mask; 575 *gmsk = HostX.visual->green_mask; 576 *bmsk = HostX.visual->blue_mask; 577 } 578 else if (host_screen->server_depth == 16) 579 { 580 /* Assume 16bpp 565 */ 581 *rmsk = 0xf800; 582 *gmsk = 0x07e0; 583 *bmsk = 0x001f; 584 } 585 else 586 { 587 *rmsk = 0x0; 588 *gmsk = 0x0; 589 *bmsk = 0x0; 590 } 591 } 592 593 static int 594 hostx_calculate_color_shift(unsigned long mask) 595 { 596 int shift = 1; 597 /* count # of bits in mask */ 598 while ((mask = (mask >> 1))) shift++; 599 /* cmap entry is an unsigned char so adjust it by size of that */ 600 shift = shift - sizeof(unsigned char) * 8; 601 if (shift < 0) shift = 0; 602 return shift; 603 } 604 605 void 606 hostx_set_cmap_entry(unsigned char idx, 607 unsigned char r, 608 unsigned char g, 609 unsigned char b) 610 { 611 /* need to calculate the shifts for RGB because server could be BGR. */ 612 /* XXX Not sure if this is correct for 8 on 16, but this works for 8 on 24.*/ 613 static int rshift, bshift, gshift = 0; 614 static int first_time = 1; 615 if (first_time) { 616 first_time = 0; 617 rshift = hostx_calculate_color_shift(HostX.visual->red_mask); 618 gshift = hostx_calculate_color_shift(HostX.visual->green_mask); 619 bshift = hostx_calculate_color_shift(HostX.visual->blue_mask); 620 } 621 HostX.cmap[idx] = ((r << rshift) & HostX.visual->red_mask) | 622 ((g << gshift) & HostX.visual->green_mask) | 623 ((b << bshift) & HostX.visual->blue_mask); 624 } 625 626 /** 627 * hostx_screen_init creates the XImage that will contain the front buffer of 628 * the ephyr screen, and possibly offscreen memory. 629 * 630 * @param width width of the screen 631 * @param height height of the screen 632 * @param buffer_height height of the rectangle to be allocated. 633 * 634 * hostx_screen_init() creates an XImage, using MIT-SHM if it's available. 635 * buffer_height can be used to create a larger offscreen buffer, which is used 636 * by fakexa for storing offscreen pixmap data. 637 */ 638 void* 639 hostx_screen_init (EphyrScreenInfo screen, 640 int width, int height, 641 int buffer_height) 642 { 643 int bitmap_pad; 644 Bool shm_success = False; 645 XSizeHints *size_hints; 646 647 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 648 if (!host_screen) 649 { 650 fprintf (stderr, "%s: Error in accessing hostx data\n", __func__ ); 651 exit(1); 652 } 653 654 EPHYR_DBG ("host_screen=%p wxh=%dx%d, buffer_height=%d", 655 host_screen, width, height, buffer_height); 656 657 if (host_screen->ximg != NULL) 658 { 659 /* Free up the image data if previously used 660 * i.ie called by server reset 661 */ 662 663 if (HostX.have_shm) 664 { 665 XShmDetach(HostX.dpy, &host_screen->shminfo); 666 XDestroyImage (host_screen->ximg); 667 shmdt(host_screen->shminfo.shmaddr); 668 shmctl(host_screen->shminfo.shmid, IPC_RMID, 0); 669 } 670 else 671 { 672 free(host_screen->ximg->data); 673 host_screen->ximg->data = NULL; 674 675 XDestroyImage(host_screen->ximg); 676 } 677 } 678 679 if (HostX.have_shm) 680 { 681 host_screen->ximg = XShmCreateImage (HostX.dpy, HostX.visual, HostX.depth, 682 ZPixmap, NULL, &host_screen->shminfo, 683 width, buffer_height ); 684 685 host_screen->shminfo.shmid = 686 shmget(IPC_PRIVATE, 687 host_screen->ximg->bytes_per_line * buffer_height, 688 IPC_CREAT|0777); 689 host_screen->ximg->data = shmat(host_screen->shminfo.shmid, 0, 0); 690 host_screen->shminfo.shmaddr = host_screen->ximg->data; 691 692 if (host_screen->ximg->data == (char *)-1) 693 { 694 EPHYR_DBG("Can't attach SHM Segment, falling back to plain XImages"); 695 HostX.have_shm = False; 696 XDestroyImage(host_screen->ximg); 697 shmctl(host_screen->shminfo.shmid, IPC_RMID, 0); 698 } 699 else 700 { 701 EPHYR_DBG("SHM segment attached %p", host_screen->shminfo.shmaddr); 702 host_screen->shminfo.readOnly = False; 703 XShmAttach(HostX.dpy, &host_screen->shminfo); 704 shm_success = True; 705 } 706 } 707 708 if (!shm_success) 709 { 710 bitmap_pad = ( HostX.depth > 16 )? 32 : (( HostX.depth > 8 )? 16 : 8 ); 711 712 EPHYR_DBG("Creating image %dx%d for screen host_screen=%p\n", 713 width, buffer_height, host_screen ); 714 host_screen->ximg = XCreateImage (HostX.dpy, 715 HostX.visual, 716 HostX.depth, 717 ZPixmap, 0, 0, 718 width, 719 buffer_height, 720 bitmap_pad, 721 0); 722 723 host_screen->ximg->data = 724 malloc (host_screen->ximg->bytes_per_line * buffer_height); 725 } 726 727 XResizeWindow (HostX.dpy, host_screen->win, width, height); 728 729 /* Ask the WM to keep our size static */ 730 size_hints = XAllocSizeHints(); 731 size_hints->max_width = size_hints->min_width = width; 732 size_hints->max_height = size_hints->min_height = height; 733 size_hints->flags = PMinSize|PMaxSize; 734 XSetWMNormalHints(HostX.dpy, host_screen->win, size_hints); 735 XFree(size_hints); 736 737 XMapWindow(HostX.dpy, host_screen->win); 738 739 XSync(HostX.dpy, False); 740 741 host_screen->win_width = width; 742 host_screen->win_height = height; 743 744 if (host_depth_matches_server(host_screen)) 745 { 746 EPHYR_DBG("Host matches server"); 747 return host_screen->ximg->data; 748 } 749 else 750 { 751 EPHYR_DBG("server bpp %i", host_screen->server_depth>>3); 752 host_screen->fb_data = malloc(width*buffer_height*(host_screen->server_depth>>3)); 753 return host_screen->fb_data; 754 } 755 } 756 757 static void hostx_paint_debug_rect (struct EphyrHostScreen *host_screen, 758 int x, int y, 759 int width, int height); 760 761 void 762 hostx_paint_rect (EphyrScreenInfo screen, 763 int sx, int sy, 764 int dx, int dy, 765 int width, int height) 766 { 767 struct EphyrHostScreen *host_screen = host_screen_from_screen_info (screen); 768 769 EPHYR_DBG ("painting in screen %d\n", host_screen->mynum) ; 770 771 /* 772 * Copy the image data updated by the shadow layer 773 * on to the window 774 */ 775 776 if (HostXWantDamageDebug) 777 { 778 hostx_paint_debug_rect(host_screen, dx, dy, width, height); 779 } 780 781 /* 782 * If the depth of the ephyr server is less than that of the host, 783 * the kdrive fb does not point to the ximage data but to a buffer 784 * ( fb_data ), we shift the various bits from this onto the XImage 785 * so they match the host. 786 * 787 * Note, This code is pretty new ( and simple ) so may break on 788 * endian issues, 32 bpp host etc. 789 * Not sure if 8bpp case is right either. 790 * ... and it will be slower than the matching depth case. 791 */ 792 793 if (!host_depth_matches_server(host_screen)) 794 { 795 int x,y,idx, bytes_per_pixel = (host_screen->server_depth>>3); 796 unsigned char r,g,b; 797 unsigned long host_pixel; 798 799 EPHYR_DBG("Unmatched host depth host_screen=%p\n", host_screen); 800 for (y=sy; y<sy+height; y++) 801 for (x=sx; x<sx+width; x++) 802 { 803 idx = (host_screen->win_width*y*bytes_per_pixel)+(x*bytes_per_pixel); 804 805 switch (host_screen->server_depth) 806 { 807 case 16: 808 { 809 unsigned short pixel = *(unsigned short*)(host_screen->fb_data+idx); 810 811 r = ((pixel & 0xf800) >> 8); 812 g = ((pixel & 0x07e0) >> 3); 813 b = ((pixel & 0x001f) << 3); 814 815 host_pixel = (r << 16) | (g << 8) | (b); 816 817 XPutPixel(host_screen->ximg, x, y, host_pixel); 818 break; 819 } 820 case 8: 821 { 822 unsigned char pixel = *(unsigned char*)(host_screen->fb_data+idx); 823 XPutPixel(host_screen->ximg, x, y, HostX.cmap[pixel]); 824 break; 825 } 826 default: 827 break; 828 } 829 } 830 } 831 832 if (HostX.have_shm) 833 { 834 XShmPutImage (HostX.dpy, host_screen->win, 835 HostX.gc, host_screen->ximg, 836 sx, sy, dx, dy, width, height, False); 837 } 838 else 839 { 840 XPutImage (HostX.dpy, host_screen->win, HostX.gc, host_screen->ximg, 841 sx, sy, dx, dy, width, height); 842 } 843 844 XSync (HostX.dpy, False); 845 } 846 847 static void 848 hostx_paint_debug_rect (struct EphyrHostScreen *host_screen, 849 int x, int y, 850 int width, int height) 851 { 852 struct timespec tspec; 853 854 tspec.tv_sec = HostX.damage_debug_msec / (1000000); 855 tspec.tv_nsec = (HostX.damage_debug_msec % 1000000) * 1000; 856 857 EPHYR_DBG("msec: %li tv_sec %li, tv_msec %li", 858 HostX.damage_debug_msec, tspec.tv_sec, tspec.tv_nsec); 859 860 /* fprintf(stderr, "Xephyr updating: %i+%i %ix%i\n", x, y, width, height); */ 861 862 XFillRectangle (HostX.dpy, host_screen->win, HostX.gc, x, y, width,height); 863 XSync (HostX.dpy, False); 864 865 /* nanosleep seems to work better than usleep for me... */ 866 nanosleep(&tspec, NULL); 867 } 868 869 void 870 hostx_load_keymap(void) 871 { 872 XID *keymap; 873 int host_width, min_keycode, max_keycode, width; 874 int i,j; 875 876 XDisplayKeycodes (HostX.dpy, &min_keycode, &max_keycode); 877 878 EPHYR_DBG ("min: %d, max: %d", min_keycode, max_keycode); 879 880 keymap = XGetKeyboardMapping (HostX.dpy, 881 min_keycode, 882 max_keycode - min_keycode + 1, 883 &host_width); 884 885 /* Try and copy the hosts keymap into our keymap to avoid loads 886 * of messing around. 887 * 888 * kdrive cannot can have more than 4 keysyms per keycode 889 * so we only copy at most the first 4 ( xorg has 6 per keycode, XVNC 2 ) 890 */ 891 width = (host_width > 4) ? 4 : host_width; 892 893 ephyrKeySyms.map = (CARD32 *)calloc(sizeof(CARD32), 894 (max_keycode - min_keycode + 1) * 895 width); 896 if (!ephyrKeySyms.map) 897 return; 898 899 for (i=0; i<(max_keycode - min_keycode+1); i++) 900 for (j=0; j<width; j++) 901 ephyrKeySyms.map[(i*width)+j] = (CARD32) keymap[(i*host_width) + j]; 902 903 EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width); 904 905 ephyrKeySyms.minKeyCode = min_keycode; 906 ephyrKeySyms.maxKeyCode = max_keycode; 907 ephyrKeySyms.mapWidth = width; 908 909 XFree(keymap); 910 } 911 912 static struct EphyrHostScreen * 913 host_screen_from_window (Window w) 914 { 915 int index = 0; 916 struct EphyrHostScreen *result = NULL; 917 918 for (index = 0 ; index < HostX.n_screens ; index++) 919 { 920 if (HostX.screens[index].win == w || HostX.screens[index].peer_win == w) 921 { 922 result = &HostX.screens[index]; 923 goto out; 924 } 925 } 926 927 out: 928 return result; 929 } 930 931 int 932 hostx_get_event(EphyrHostXEvent *ev) 933 { 934 XEvent xev; 935 static int grabbed_screen = -1; 936 937 if (XPending(HostX.dpy)) 938 { 939 XNextEvent(HostX.dpy, &xev); 940 941 switch (xev.type) 942 { 943 case Expose: 944 /* Not so great event compression, but works ok */ 945 while (XCheckTypedWindowEvent(HostX.dpy, xev.xexpose.window, 946 Expose, &xev)); 947 { 948 struct EphyrHostScreen *host_screen = 949 host_screen_from_window (xev.xexpose.window); 950 if (host_screen) 951 { 952 hostx_paint_rect (host_screen->info, 0, 0, 0, 0, 953 host_screen->win_width, 954 host_screen->win_height); 955 } 956 else 957 { 958 EPHYR_LOG_ERROR ("failed to get host screen\n"); 959 ev->type = EPHYR_EV_EXPOSE; 960 ev->data.expose.window = xev.xexpose.window; 961 return 1; 962 } 963 } 964 return 0; 965 966 case MotionNotify: 967 { 968 struct EphyrHostScreen *host_screen = 969 host_screen_from_window (xev.xmotion.window); 970 971 ev->type = EPHYR_EV_MOUSE_MOTION; 972 ev->data.mouse_motion.x = xev.xmotion.x; 973 ev->data.mouse_motion.y = xev.xmotion.y; 974 ev->data.mouse_motion.window = xev.xmotion.window; 975 ev->data.mouse_motion.screen = (host_screen ? host_screen->mynum : -1); 976 } 977 return 1; 978 979 case ButtonPress: 980 ev->type = EPHYR_EV_MOUSE_PRESS; 981 ev->key_state = xev.xkey.state; 982 /* 983 * This is a bit hacky. will break for button 5 ( defined as 0x10 ) 984 * Check KD_BUTTON defines in kdrive.h 985 */ 986 ev->data.mouse_down.button_num = 1<<(xev.xbutton.button-1); 987 return 1; 988 989 case ButtonRelease: 990 ev->type = EPHYR_EV_MOUSE_RELEASE; 991 ev->key_state = xev.xkey.state; 992 ev->data.mouse_up.button_num = 1<<(xev.xbutton.button-1); 993 return 1; 994 995 case KeyPress: 996 { 997 ev->type = EPHYR_EV_KEY_PRESS; 998 ev->key_state = xev.xkey.state; 999 ev->data.key_down.scancode = xev.xkey.keycode; 1000 return 1; 1001 } 1002 case KeyRelease: 1003 1004 if ((XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_L 1005 || XKeycodeToKeysym(HostX.dpy,xev.xkey.keycode,0) == XK_Shift_R) 1006 && (xev.xkey.state & ControlMask)) 1007 { 1008 struct EphyrHostScreen *host_screen = 1009 host_screen_from_window (xev.xexpose.window); 1010 1011 if (grabbed_screen != -1) 1012 { 1013 XUngrabKeyboard (HostX.dpy, CurrentTime); 1014 XUngrabPointer (HostX.dpy, CurrentTime); 1015 grabbed_screen = -1; 1016 hostx_set_win_title (host_screen->info, 1017 "(ctrl+shift grabs mouse and keyboard)"); 1018 } 1019 else 1020 { 1021 /* Attempt grab */ 1022 if (XGrabKeyboard (HostX.dpy, host_screen->win, True, 1023 GrabModeAsync, 1024 GrabModeAsync, 1025 CurrentTime) == 0) 1026 { 1027 if (XGrabPointer (HostX.dpy, host_screen->win, True, 1028 NoEventMask, 1029 GrabModeAsync, 1030 GrabModeAsync, 1031 host_screen->win, None, CurrentTime) == 0) 1032 { 1033 grabbed_screen = host_screen->mynum; 1034 hostx_set_win_title 1035 (host_screen->info, 1036 "(ctrl+shift releases mouse and keyboard)"); 1037 } 1038 else /* Failed pointer grabm ungrab keyboard */ 1039 XUngrabKeyboard (HostX.dpy, CurrentTime); 1040 } 1041 } 1042 } 1043 1044 /* Still send the release event even if above has happened 1045 * server will get confused with just an up event. 1046 * Maybe it would be better to just block shift+ctrls getting to 1047 * kdrive all togeather. 1048 */ 1049 ev->type = EPHYR_EV_KEY_RELEASE; 1050 ev->key_state = xev.xkey.state; 1051 ev->data.key_up.scancode = xev.xkey.keycode; 1052 return 1; 1053 1054 default: 1055 break; 1056 1057 } 1058 } 1059 return 0; 1060 } 1061 1062 void* 1063 hostx_get_display(void) 1064 { 1065 return HostX.dpy ; 1066 } 1067 1068 int 1069 hostx_get_window (int a_screen_number) 1070 { 1071 if (a_screen_number < 0 || a_screen_number >= HostX.n_screens) { 1072 EPHYR_LOG_ERROR ("bad screen number:%d\n", a_screen_number) ; 1073 return 0; 1074 } 1075 return HostX.screens[a_screen_number].win ; 1076 } 1077 1078 int 1079 hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attrs) 1080 { 1081 XWindowAttributes attrs ; 1082 1083 memset (&attrs, 0, sizeof (attrs)) ; 1084 1085 if (!XGetWindowAttributes (hostx_get_display (), 1086 a_window, 1087 &attrs)) { 1088 return FALSE ; 1089 } 1090 a_attrs->x = attrs.x ; 1091 a_attrs->y = attrs.y ; 1092 a_attrs->width = attrs.width ; 1093 a_attrs->height = attrs.height ; 1094 if (attrs.visual) 1095 a_attrs->visualid = attrs.visual->visualid ; 1096 return TRUE ; 1097 } 1098 1099 int 1100 hostx_get_extension_info (const char *a_ext_name, 1101 int *a_major_opcode, 1102 int *a_first_event, 1103 int *a_first_error) 1104 { 1105 if (!a_ext_name || !a_major_opcode || !a_first_event || !a_first_error) 1106 return 0 ; 1107 if (!XQueryExtension (HostX.dpy, 1108 a_ext_name, 1109 a_major_opcode, 1110 a_first_event, 1111 a_first_error)) 1112 { 1113 return 0 ; 1114 } 1115 return 1 ; 1116 } 1117 1118 int 1119 hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals, 1120 int *a_num_entries) 1121 { 1122 Display *dpy=hostx_get_display () ; 1123 Bool is_ok=False ; 1124 XVisualInfo templ, *visuals=NULL; 1125 EphyrHostVisualInfo *host_visuals=NULL ; 1126 int nb_items=0, i=0; 1127 1128 EPHYR_RETURN_VAL_IF_FAIL (a_visuals && a_num_entries && dpy, 1129 False) ; 1130 EPHYR_LOG ("enter\n") ; 1131 memset (&templ, 0, sizeof (templ)) ; 1132 visuals = XGetVisualInfo (dpy, VisualNoMask, &templ, &nb_items) ; 1133 if (!visuals) { 1134 EPHYR_LOG_ERROR ("host does not advertise any visual\n") ; 1135 goto out ; 1136 } 1137 EPHYR_LOG ("host advertises %d visuals\n", nb_items) ; 1138 host_visuals = calloc (nb_items, sizeof (EphyrHostVisualInfo)) ; 1139 for (i=0; i<nb_items; i++) { 1140 host_visuals[i].visualid = visuals[i].visualid ; 1141 host_visuals[i].screen = visuals[i].screen ; 1142 host_visuals[i].depth = visuals[i].depth ; 1143 host_visuals[i].class = visuals[i].class ; 1144 host_visuals[i].red_mask = visuals[i].red_mask ; 1145 host_visuals[i].green_mask = visuals[i].green_mask ; 1146 host_visuals[i].blue_mask = visuals[i].blue_mask ; 1147 host_visuals[i].colormap_size = visuals[i].colormap_size ; 1148 host_visuals[i].bits_per_rgb = visuals[i].bits_per_rgb ; 1149 } 1150 *a_visuals = host_visuals ; 1151 *a_num_entries = nb_items; 1152 host_visuals=NULL; 1153 1154 is_ok = TRUE; 1155 out: 1156 if (visuals) { 1157 XFree (visuals) ; 1158 visuals = NULL; 1159 } 1160 free(host_visuals); 1161 host_visuals = NULL; 1162 EPHYR_LOG ("leave\n") ; 1163 return is_ok ; 1164 1165 } 1166 1167 int 1168 hostx_create_window (int a_screen_number, 1169 EphyrBox *a_geometry, 1170 int a_visual_id, 1171 int *a_host_peer /*out parameter*/) 1172 { 1173 Bool is_ok=FALSE ; 1174 Display *dpy=hostx_get_display () ; 1175 XVisualInfo *visual_info=NULL, visual_info_templ; 1176 int visual_mask=VisualIDMask ; 1177 Window win=None ; 1178 int nb_visuals=0, winmask=0; 1179 XSetWindowAttributes attrs; 1180 1181 EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geometry, FALSE) ; 1182 1183 EPHYR_LOG ("enter\n") ; 1184 1185 /*get visual*/ 1186 memset (&visual_info, 0, sizeof (visual_info)) ; 1187 visual_info_templ.visualid = a_visual_id ; 1188 visual_info = XGetVisualInfo (dpy, visual_mask, 1189 &visual_info_templ, 1190 &nb_visuals) ; 1191 if (!visual_info) { 1192 EPHYR_LOG_ERROR ("argh, could not find a remote visual with id:%d\n", 1193 a_visual_id) ; 1194 goto out ; 1195 } 1196 memset (&attrs, 0, sizeof (attrs)) ; 1197 attrs.colormap = XCreateColormap (dpy, 1198 RootWindow (dpy, 1199 visual_info->screen), 1200 visual_info->visual, 1201 AllocNone) ; 1202 attrs.event_mask = ButtonPressMask 1203 |ButtonReleaseMask 1204 |PointerMotionMask 1205 |KeyPressMask 1206 |KeyReleaseMask 1207 |ExposureMask; 1208 winmask = CWColormap|CWEventMask; 1209 1210 win = XCreateWindow (dpy, hostx_get_window (a_screen_number), 1211 a_geometry->x, a_geometry->y, 1212 a_geometry->width, a_geometry->height, 0, 1213 visual_info->depth, CopyFromParent, 1214 visual_info->visual, winmask, &attrs) ; 1215 if (win == None) { 1216 EPHYR_LOG_ERROR ("failed to create peer window\n") ; 1217 goto out ; 1218 } 1219 if (HostX.screens[a_screen_number].peer_win == None) { 1220 HostX.screens[a_screen_number].peer_win = win; 1221 } else { 1222 EPHYR_LOG_ERROR ("multiple peer windows created for same screen\n") ; 1223 } 1224 XFlush (dpy) ; 1225 XMapWindow (dpy, win) ; 1226 *a_host_peer = win ; 1227 is_ok = TRUE ; 1228 out: 1229 EPHYR_LOG ("leave\n") ; 1230 return is_ok ; 1231 } 1232 1233 int 1234 hostx_destroy_window (int a_win) 1235 { 1236 Display *dpy=hostx_get_display () ; 1237 1238 EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ; 1239 XDestroyWindow (dpy, a_win) ; 1240 XFlush (dpy) ; 1241 return TRUE ; 1242 } 1243 1244 int 1245 hostx_set_window_geometry (int a_win, EphyrBox *a_geo) 1246 { 1247 Display *dpy=hostx_get_display (); 1248 1249 EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geo, FALSE) ; 1250 1251 EPHYR_LOG ("enter. x,y,w,h:(%d,%d,%d,%d)\n", 1252 a_geo->x, a_geo->y, 1253 a_geo->width, a_geo->height) ; 1254 1255 XMoveWindow (dpy, a_win, a_geo->x, a_geo->y) ; 1256 XResizeWindow (dpy, a_win, a_geo->width, a_geo->height) ; 1257 EPHYR_LOG ("leave\n") ; 1258 return TRUE; 1259 } 1260 1261 int 1262 hostx_set_window_bounding_rectangles (int a_window, 1263 EphyrRect *a_rects, 1264 int a_num_rects) 1265 { 1266 Bool is_ok=FALSE; 1267 Display *dpy=hostx_get_display () ; 1268 int i=0 ; 1269 XRectangle *rects=NULL ; 1270 1271 EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ; 1272 1273 EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ; 1274 1275 rects = calloc (a_num_rects, sizeof (XRectangle)) ; 1276 for (i=0; i<a_num_rects; i++) { 1277 rects[i].x = a_rects[i].x1 ; 1278 rects[i].y = a_rects[i].y1 ; 1279 rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1); 1280 rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ; 1281 EPHYR_LOG ("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n", 1282 rects[i].x, rects[i].y, 1283 rects[i].width, rects[i].height) ; 1284 } 1285 /*this aways returns 1*/ 1286 XShapeCombineRectangles (dpy, a_window, ShapeBounding, 0, 0, 1287 rects, a_num_rects, ShapeSet, YXBanded) ; 1288 is_ok = TRUE ; 1289 1290 free(rects); 1291 rects = NULL; 1292 EPHYR_LOG ("leave\n") ; 1293 return is_ok; 1294 } 1295 1296 int 1297 hostx_set_window_clipping_rectangles (int a_window, 1298 EphyrRect *a_rects, 1299 int a_num_rects) 1300 { 1301 Bool is_ok=FALSE; 1302 Display *dpy=hostx_get_display () ; 1303 int i=0 ; 1304 XRectangle *rects=NULL ; 1305 1306 EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ; 1307 1308 EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ; 1309 1310 rects = calloc (a_num_rects, sizeof (XRectangle)) ; 1311 for (i=0; i<a_num_rects; i++) { 1312 rects[i].x = a_rects[i].x1 ; 1313 rects[i].y = a_rects[i].y1 ; 1314 rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1); 1315 rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ; 1316 EPHYR_LOG ("clipped to rect[x:%d,y:%d,w:%d,h:%d]\n", 1317 rects[i].x, rects[i].y, 1318 rects[i].width, rects[i].height) ; 1319 } 1320 /*this aways returns 1*/ 1321 XShapeCombineRectangles (dpy, a_window, ShapeClip, 0, 0, 1322 rects, a_num_rects, ShapeSet, YXBanded) ; 1323 is_ok = TRUE ; 1324 1325 free(rects); 1326 rects = NULL; 1327 EPHYR_LOG ("leave\n") ; 1328 return is_ok; 1329 } 1330 1331 int 1332 hostx_has_xshape (void) 1333 { 1334 int event_base=0, error_base=0 ; 1335 Display *dpy=hostx_get_display () ; 1336 if (!XShapeQueryExtension (dpy, 1337 &event_base, 1338 &error_base)) { 1339 return FALSE ; 1340 } 1341 return TRUE; 1342 } 1343 1344 #ifdef XF86DRI 1345 typedef struct { 1346 int is_valid ; 1347 int local_id ; 1348 int remote_id ; 1349 } ResourcePair ; 1350 1351 #define RESOURCE_PEERS_SIZE 1024*10 1352 static ResourcePair resource_peers[RESOURCE_PEERS_SIZE] ; 1353 1354 1355 int 1356 hostx_allocate_resource_id_peer (int a_local_resource_id, 1357 int *a_remote_resource_id) 1358 { 1359 int i=0 ; 1360 ResourcePair *peer=NULL ; 1361 Display *dpy=hostx_get_display (); 1362 1363 /* 1364 * first make sure a resource peer 1365 * does not exist already for 1366 * a_local_resource_id 1367 */ 1368 for (i=0; i<RESOURCE_PEERS_SIZE; i++) { 1369 if (resource_peers[i].is_valid 1370 && resource_peers[i].local_id == a_local_resource_id) { 1371 peer = &resource_peers[i] ; 1372 break ; 1373 } 1374 } 1375 /* 1376 * find one free peer entry, an feed it with 1377 */ 1378 if (!peer) { 1379 for (i=0; i<RESOURCE_PEERS_SIZE; i++) { 1380 if (!resource_peers[i].is_valid) { 1381 peer = &resource_peers[i] ; 1382 break ; 1383 } 1384 } 1385 if (peer) { 1386 peer->remote_id = XAllocID (dpy); 1387 peer->local_id = a_local_resource_id ; 1388 peer->is_valid = TRUE ; 1389 } 1390 } 1391 if (peer) { 1392 *a_remote_resource_id = peer->remote_id ; 1393 return TRUE ; 1394 } 1395 return FALSE ; 1396 } 1397 1398 int 1399 hostx_get_resource_id_peer (int a_local_resource_id, 1400 int *a_remote_resource_id) 1401 { 1402 int i=0 ; 1403 ResourcePair *peer=NULL ; 1404 for (i=0; i<RESOURCE_PEERS_SIZE; i++) { 1405 if (resource_peers[i].is_valid 1406 && resource_peers[i].local_id == a_local_resource_id) { 1407 peer = &resource_peers[i] ; 1408 break ; 1409 } 1410 } 1411 if (peer) { 1412 *a_remote_resource_id = peer->remote_id ; 1413 return TRUE ; 1414 } 1415 return FALSE ; 1416 } 1417 1418 int 1419 hostx_has_dri (void) 1420 { 1421 int event_base=0, error_base=0 ; 1422 Display *dpy=hostx_get_display () ; 1423 1424 if (!dpy) 1425 return FALSE ; 1426 1427 if (!XF86DRIQueryExtension (dpy, 1428 &event_base, 1429 &error_base)) { 1430 return FALSE ; 1431 } 1432 return TRUE ; 1433 } 1434 1435 int 1436 hostx_has_glx (void) 1437 { 1438 Display *dpy=hostx_get_display () ; 1439 int event_base=0, error_base=0 ; 1440 1441 if (!glXQueryExtension (dpy, &event_base, &error_base)) { 1442 return FALSE ; 1443 } 1444 return TRUE ; 1445 } 1446 1447 #endif /* XF86DRI */ 1448
Indexes created Sun Aug 16 00:25:19 UTC 2026