arch/all-hosted/hidd/x11/x11gfx_onbitmap.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Bitmap class for X11 hidd.
   6     Lang: English.
   7 */
   8
   9 #include "x11_debug.h"
  10
  11 #include <hidd/gfx.h>
  12 #include <proto/utility.h>
  13
  14 #include "x11_types.h"
  15 #include "x11.h"
  16 #include "x11_hostlib.h"
  17 #include "x11gfx_bitmap.h"
  18
  19 /****************************************************************************************/
  20
  21 #if ADJUST_XWIN_SIZE
  22 #define MASTERWIN(data) (data)->masterxwindow
  23 #define ROOTWIN(data) (data)->masterxwindow
  24 #else
  25 #define MASTERWIN WINDRAWABLE
  26 #define ROOTWIN(data) rootwin
  27 #endif
  28
  29 /****************************************************************************************/
  30
  31 static Pixmap init_icon(Display *d, Window w, Colormap cm, LONG depth,
  32         struct x11_staticdata *xsd);
  33
  34 /****************************************************************************************/
  35
  36 BOOL X11BM_InitFB(OOP_Class *cl, OOP_Object *o, struct TagItem *attrList)
  37 {
  38     Window rootwin;
  39     OOP_Object *sync, *pixfmt;
  40     HIDDT_ModeID modeid;
  41     IPTR depth;
  42     XSetWindowAttributes winattr;
  43     int visualclass;
  44     unsigned long valuemask;
  45     struct bitmap_data *data = OOP_INST_DATA(cl, o);
  46     struct x11_staticdata *xsd = XSD(cl);
  47
  48     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
  49
  50     /* stegerg */
  51     visualclass = GetTagData(aHidd_BitMap_X11_VisualClass, TrueColor, attrList);
  52     if (visualclass == PseudoColor)
  53     {
  54         Colormap cm;
  55
  56         HostLib_Lock();
  57         cm = XCALL(XCreateColormap, GetSysDisplay(), RootWindow(GetSysDisplay(), GetSysScreen()),
  58                 xsd->vi->visual, AllocAll);
  59         HostLib_Unlock();
  60
  61         if (cm)
  62         {
  63             data->colmap = cm;
  64             data->flags |= BMDF_COLORMAP_ALLOCED;
  65         }
  66     }
  67     /* end stegerg */
  68
  69     /*
  70      * Get window size from our ModeID.
  71      * We can't support scrolling in framebuffer mode.
  72      */
  73     OOP_GetAttr(o, aHidd_BitMap_ModeID, &modeid);
  74     OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (IPTR *) &data->gfxhidd);
  75     D(bug("[X11OnBm] ModeID 0x%08X, driver @ 0x%p\n", modeid, data->gfxhidd));
  76
  77     HIDD_Gfx_GetMode(data->gfxhidd, modeid, &sync, &pixfmt);
  78
  79     OOP_GetAttr(sync, aHidd_Sync_HDisp, &data->width);
  80     OOP_GetAttr(sync, aHidd_Sync_VDisp, &data->height);
  81     depth = DefaultDepth(GetSysDisplay(), GetSysScreen());
  82
  83     /* Open an X window to be used for viewing */
  84     D(bug("[X11OnBm] Framebuffer window size %ldx%ldx%d\n", data->width, data->height, depth));
  85
  86     /* Listen for all sorts of events */
  87     winattr.event_mask = ButtonPressMask | ButtonReleaseMask | PointerMotionMask
  88             | KeyPressMask | KeyReleaseMask | StructureNotifyMask
  89             | SubstructureNotifyMask | FocusChangeMask | ExposureMask;
  90
  91     if (XSD(cl)->options & OPTION_BACKINGSTORE)
  92     {
  93         /* Framebuffer needs backing store. (Uses lots of mem) */
  94         winattr.backing_store = Always;
  95         winattr.save_under = True;
  96     }
  97
  98     winattr.cursor = GetSysCursor();
  99     winattr.background_pixel = BlackPixel(GetSysDisplay(), GetSysScreen());
 100
 101     rootwin = DefaultRootWindow(GetSysDisplay());
 102     D(bug("Creating XWindow: root win=%p\n", rootwin));
 103
 104     valuemask = CWCursor | CWEventMask | CWBackPixel;
 105
 106     if (XSD(cl)->options & OPTION_BACKINGSTORE)
 107         valuemask |= CWBackingStore | CWSaveUnder;
 108
 109     if (data->flags & BMDF_COLORMAP_ALLOCED)
 110     {
 111         winattr.colormap = data->colmap;
 112         valuemask |= CWColormap;
 113     }
 114
 115     HostLib_Lock();
 116
 117 #if ADJUST_XWIN_SIZE
 118     {
 119         XSetWindowAttributes rootattr;
 120         unsigned long rootmask = 0;
 121
 122         rootattr.event_mask = FocusChangeMask;
 123         rootmask |= CWEventMask;
 124
 125         if (XSD(cl)->options & OPTION_FULLSCREEN)
 126         {
 127             rootattr.override_redirect = True;
 128             rootmask |= CWOverrideRedirect;
 129         }
 130
 131         if (data->flags & BMDF_COLORMAP_ALLOCED)
 132         {
 133             rootattr.colormap = data->colmap;
 134             rootmask |= CWColormap;
 135         }
 136
 137         MASTERWIN(data) = XCALL(XCreateWindow, GetSysDisplay(), rootwin,
 138                 0, /* leftedge     */
 139                 0, /* topedge    */
 140                 data->width,
 141                 data->height,
 142                 0, /* BorderWidth    */
 143                 depth,
 144                 InputOutput,
 145                 DefaultVisual(GetSysDisplay(), GetSysScreen()),
 146                 rootmask,
 147                 &rootattr);
 148     }
 149
 150     if (MASTERWIN(data))
 151 #endif
 152     {
 153         WINDRAWABLE(data) = XCALL(XCreateWindow, GetSysDisplay(),
 154                 ROOTWIN(data),
 155                 0, /* leftedge     */
 156                 0, /* topedge    */
 157                 data->width,
 158                 data->height,
 159                 0, /* BorderWidth    */
 160                 depth,
 161                 InputOutput,
 162                 DefaultVisual(GetSysDisplay(), GetSysScreen()),
 163                 valuemask,
 164                 &winattr);
 165     }
 166     HostLib_Unlock();
 167
 168     D(bug("[X11OnBm] X Window @ 0x%p\n", WINDRAWABLE(data)));
 169
 170     if (WINDRAWABLE(data))
 171     {
 172         Pixmap icon;
 173 #if !ADJUST_XWIN_SIZE
 174         XSizeHints sizehint;
 175 #endif
 176         XClassHint *classhint;
 177
 178         HostLib_Lock();
 179
 180         classhint = XCALL(XAllocClassHint);
 181         classhint->res_name = "AROS";
 182         classhint->res_class = "AROS";
 183         XCALL(XSetClassHint, GetSysDisplay(), MASTERWIN(data), classhint);
 184
 185         XCALL(XStoreName, GetSysDisplay(), MASTERWIN(data), "AROS");
 186         XCALL(XSetIconName, GetSysDisplay(), MASTERWIN(data), "AROS Screen");
 187
 188 #if !ADJUST_XWIN_SIZE
 189         sizehint.flags = PMinSize | PMaxSize;
 190         sizehint.min_width = data->width;
 191         sizehint.min_height = data->height;
 192         sizehint.max_width = data->width;
 193         sizehint.max_height = data->height;
 194
 195         XCALL(XSetWMNormalHints, GetSysDisplay(), MASTERWIN(data), &sizehint);
 196 #endif
 197
 198         XCALL(XSetWMProtocols,
 199                 GetSysDisplay(), MASTERWIN(data), &XSD(cl)->delete_win_atom, 1);
 200
 201         icon = init_icon(GetSysDisplay(), MASTERWIN(data),
 202                 DefaultColormap(GetSysDisplay(), GetSysScreen()), depth, xsd);
 203
 204         if (icon)
 205         {
 206             XWMHints hints;
 207
 208             hints.icon_pixmap = icon;
 209             hints.flags = IconPixmapHint;
 210
 211             XCALL(XSetWMHints, GetSysDisplay(), MASTERWIN(data), &hints);
 212         }
 213
 214         if (XSD(cl)->options & OPTION_BACKINGSTORE)
 215         {
 216             DRAWABLE(data) = WINDRAWABLE(data);
 217             data->flags |= BMDF_BACKINGSTORE;
 218         }
 219         else
 220         {
 221             DRAWABLE(data) = XCALL(XCreatePixmap, data->display, WINDRAWABLE(data), data->width, data->height, depth);
 222         }
 223
 224         /*
 225          * stegerg: XMapRaised is now called inside the X11 task when getting
 226          *          the NOTY_MAPWINDOW message, otherwise the X11 task can
 227          *        get a "dead" MapNotify event:
 228          *
 229          *       XCreateWindow is called here on the app task context.
 230          *       If we also call XMapRaised here then the X11 task might
 231          *       get the MapNotify event before he got the NOTY_WINCREATE
 232          *       message sent from here (see below). So the X11 task
 233          *       would not know about our window and therefore ignore
 234          *       the MapNotify event from X.
 235          *
 236          *       This caused the freezes which sometimes happened during
 237          *       startup when the Workbench screen was opened.
 238          *
 239          *    XCALL(XMapRaised, GetSysDisplay(), DRAWABLE(data));
 240          */
 241
 242         HostLib_Unlock();
 243
 244         return TRUE;
 245     } /* if WINDRAWABLE(data) */
 246
 247     return FALSE;
 248 }
 249
 250 /****************************************************************************************/
 251
 252 BOOL X11BM_NotifyFB(OOP_Class *cl, OOP_Object *o)
 253 {
 254     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 255     struct x11_staticdata *xsd = XSD(cl);
 256     struct MsgPort *port;
 257
 258     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
 259
 260     /*
 261      * Now we need to get some message from the X11 task about when
 262      * the window has been mapped (i.e. MapWindow event).
 263      * This is because we cannot render into the window until
 264      * it has been mapped.
 265      */
 266
 267     port = CreateMsgPort();
 268
 269     if (NULL != port)
 270     {
 271         /* Send a message to the x11 task that the window has been created */
 272         struct notify_msg msg;
 273
 274         msg.notify_type = NOTY_WINCREATE;
 275         msg.xdisplay = GetSysDisplay();
 276         msg.xwindow = WINDRAWABLE(data);
 277         msg.masterxwindow = MASTERWIN(data);
 278         msg.bmobj = o;
 279         msg.execmsg.mn_ReplyPort = port;
 280
 281         HostLib_Lock();
 282         XCALL(XSync, GetSysDisplay(), FALSE);
 283         HostLib_Unlock();
 284
 285         D(bug("[X11] %s: notifying port @ 0x%p\n", __PRETTY_FUNCTION__,
 286             xsd->x11task_notify_port));
 287         X11DoNotify(xsd, &msg);
 288
 289         if (!(XSD(cl)->options & OPTION_DELAYXWINMAPPING))
 290         {
 291             D(bug("[X11OnBm] %s: notifying x11 task to map window...\n",
 292                 __PRETTY_FUNCTION__));
 293             /*
 294              * Send a message to the X11 task to ask when the window has
 295              * been mapped. We change only notify_type; other fields are
 296              * already set.
 297              */
 298             msg.notify_type = NOTY_MAPWINDOW;
 299
 300             HostLib_Lock();
 301             XCALL(XSync, GetSysDisplay(), FALSE);
 302             HostLib_Unlock();
 303
 304             D(bug("[X11] %s: notifying port @ 0x%p\n", __PRETTY_FUNCTION__,
 305                 xsd->x11task_notify_port));
 306             X11DoNotify(xsd, &msg);
 307         }
 308
 309         DeleteMsgPort(port);
 310
 311         return TRUE;
 312     }
 313
 314     return FALSE;
 315 }
 316
 317 /****************************************************************************************/
 318
 319 VOID X11BM_DisposeFB(struct bitmap_data *data, struct x11_staticdata *xsd)
 320 {
 321     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
 322
 323     if (WINDRAWABLE(data))
 324     {
 325         struct MsgPort *port;
 326         struct notify_msg msg;
 327
 328         port = CreateMsgPort();
 329
 330         if (NULL == port)
 331         {
 332             D(bug("[X11OnBm] %s: failed to create notification message port!\n", __PRETTY_FUNCTION__));
 333
 334             return;
 335         }
 336
 337         msg.notify_type = NOTY_WINDISPOSE;
 338         msg.xdisplay = GetSysDisplay();
 339         msg.xwindow = WINDRAWABLE(data);
 340         msg.masterxwindow = MASTERWIN(data);
 341         msg.execmsg.mn_ReplyPort = port;
 342
 343         D(bug("[X11] %s: notifying port @ 0x%p\n", __PRETTY_FUNCTION__, xsd->x11task_notify_port));
 344         X11DoNotify(xsd, &msg);
 345         DeleteMsgPort(port);
 346     }
 347
 348     /* Dispose everything */
 349     HostLib_Lock();
 350
 351     if (WINDRAWABLE(data))
 352         XCALL(XDestroyWindow, GetSysDisplay(), WINDRAWABLE(data));
 353
 354 #if ADJUST_XWIN_SIZE
 355     if (MASTERWIN(data))
 356         XCALL(XDestroyWindow, GetSysDisplay(), MASTERWIN(data));
 357 #endif
 358
 359     if (data->flags & BMDF_COLORMAP_ALLOCED)
 360         XCALL(XFreeColormap, GetSysDisplay(), data->colmap);
 361
 362     if (!(data->flags & BMDF_BACKINGSTORE))
 363         XCALL(XFreePixmap, GetSysDisplay(), DRAWABLE(data));
 364
 365     XCALL(XFlush, GetSysDisplay());
 366
 367     HostLib_Unlock();
 368 }
 369
 370 /****************************************************************************************/
 371
 372 #if ADJUST_XWIN_SIZE
 373
 374 BOOL X11BM_SetMode(struct bitmap_data *data, HIDDT_ModeID modeid,
 375         struct x11_staticdata *xsd)
 376 {
 377     OOP_Object *sync, *pf;
 378
 379     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
 380
 381     if (HIDD_Gfx_GetMode(data->gfxhidd, (HIDDT_ModeID) modeid, &sync, &pf))
 382     {
 383         struct MsgPort *port;
 384         IPTR new_width, new_height;
 385
 386         D(bug("[X11OnBm] %s: got mode info\n", __PRETTY_FUNCTION__));
 387
 388         OOP_GetAttr(sync, aHidd_Sync_HDisp, &new_width);
 389         OOP_GetAttr(sync, aHidd_Sync_VDisp, &new_height);
 390
 391         /*
 392          * Don't do anything if the size actually won't change.
 393          * Prevents badly looking flashing, at least on Darwin.
 394          */
 395         if (!(xsd->options & OPTION_DELAYXWINMAPPING) && (new_width == data->width) && (new_height == data->height))
 396         {
 397             D(bug("[X11OnBm] %s: no change ..\n", __PRETTY_FUNCTION__));
 398             return TRUE;
 399         }
 400
 401         port = CreateMsgPort();
 402         if (port)
 403         {
 404             struct notify_msg nmsg;
 405
 406             /* Send resize message to the x11 task */
 407             nmsg.notify_type = NOTY_RESIZEWINDOW;
 408             nmsg.xdisplay = data->display;
 409             nmsg.xwindow = WINDRAWABLE(data);
 410             nmsg.masterxwindow = data->masterxwindow;
 411             nmsg.width = new_width;
 412             nmsg.height = new_height;
 413             nmsg.execmsg.mn_ReplyPort = port;
 414
 415             D(bug("[X11] %s: notifying port @ 0x%p\n", __PRETTY_FUNCTION__, xsd->x11task_notify_port));
 416             X11DoNotify(xsd, &nmsg);
 417             DeleteMsgPort(port);
 418
 419             /* Update cached size */
 420             data->width = new_width;
 421             data->height = new_height;
 422
 423             return TRUE;
 424         }
 425     }
 426     return FALSE;
 427 }
 428
 429 #endif
 430
 431 /****************************************************************************************/
 432
 433 VOID X11BM_ClearFB(struct bitmap_data *data, HIDDT_Pixel bg)
 434 {
 435     XSetWindowAttributes winattr;
 436
 437     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
 438
 439     winattr.background_pixel = bg;
 440
 441     XCALL(XChangeWindowAttributes, data->display, WINDRAWABLE(data), CWBackPixel, &winattr);
 442     XCALL(XClearArea, data->display, DRAWABLE(data), 0, 0, data->width, data->height, FALSE);
 443     X11BM_ExposeFB(data, 0, 0, data->width, data->height);
 444 }
 445
 446 /****************************************************************************************/
 447
 448 VOID X11BM_ExposeFB(struct bitmap_data *data, WORD x, WORD y, WORD width, WORD height)
 449 {
 450     D(bug("[X11OnBm] %s(%d, %d, %d, %d)\n", __PRETTY_FUNCTION__,
 451         x, y, width, height));
 452
 453     if (!(data->flags & BMDF_BACKINGSTORE))
 454     {
 455         XCALL(XSetFunction, data->display, data->gc, GXcopy);
 456         XCALL(XCopyArea, data->display, DRAWABLE(data), WINDRAWABLE(data), data->gc,
 457                 x, y, width, height, x, y);
 458     }
 459 }
 460
 461 /****************************************************************************************/
 462
 463 #if X11SOFTMOUSE
 464
 465 //void init_empty_cursor(Window w, GC gc, struct x11_staticdata *xsd)
 466 VOID X11BM_InitEmptyCursor(struct bitmap_data *data)
 467 {
 468     Pixmap p, mask;
 469     int width, height;
 470
 471     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
 472
 473     width = height = 1;
 474
 475     LOCK_X11
 476     p = XCALL(XCreatePixmap, data->display, WINDRAWABLE(data), width, height, 1);
 477     UNLOCK_X11
 478
 479     if (0 != p)
 480     {
 481         LOCK_X11
 482         mask = XCALL(XCreatePixmap, data->display, WINDRAWABLE(data), width, height, 1);
 483         XCALL(XFlush, data->display);
 484         UNLOCK_X11
 485
 486         if (0 != mask)
 487         {
 488             /* Define cursor for window */
 489             XColor fg, bg;
 490             Cursor c;
 491             GC gc;
 492
 493             LOCK_X11
 494             gc = XCALL(XCreateGC, data->display, WINDRAWABLE(data), 0, 0);
 495             XCALL(XSetForeground, data->display, gc, 0);
 496             XCALL(XSetFunction, data->display, gc, GXcopy);
 497 #if 0
 498             XCALL(XFillRectangle, data->display, p, gc, 1, 1, 1, 1);
 499             for (y = 0; y < height; y ++)
 500             {
 501                 for (x = 0; x < width; x ++)
 502                 {
 503                     XCALL(XDrawPoint, data->display, mask, gc, x, y);
 504                 }
 505             }
 506 #endif
 507             UNLOCK_X11
 508
 509             fg.pixel = BlackPixel(data->display, DefaultScreen(data->display));
 510             fg.red = 0x0000;
 511             fg.green = 0x0000;
 512             fg.blue = 0x0000;
 513             fg.flags = DoRed | DoGreen | DoBlue;
 514
 515             bg.pixel = WhitePixel(data->display, DefaultScreen(data->display));
 516             bg.red = 0xFFFF;
 517             bg.green = 0xFFFF;
 518             bg.blue = 0xFFFF;
 519             bg.flags = DoRed | DoGreen | DoBlue;
 520
 521             LOCK_X11
 522             c = XCALL(XCreatePixmapCursor, data->display, p, mask, &fg, &bg, 0, 0);
 523             UNLOCK_X11
 524
 525             if (0 != c)
 526             {
 527                 LOCK_X11
 528                 XCALL(XDefineCursor, data->display, WINDRAWABLE(data), c);
 529                 UNLOCK_X11
 530             }
 531
 532             LOCK_X11
 533             XCALL(XFreePixmap, data->display, mask);
 534             XCALL(XFreeGC, data->display, gc);
 535             UNLOCK_X11
 536         }
 537
 538         LOCK_X11
 539         XCALL(XFreePixmap, data->display, p);
 540         UNLOCK_X11
 541     }
 542
 543 }
 544
 545 #endif
 546
 547 /****************************************************************************************/
 548
 549 static Pixmap init_icon(Display *d, Window w, Colormap cm, LONG depth,
 550         struct x11_staticdata *xsd)
 551 {
 552 #include "icon.h"
 553
 554 #define SHIFT_PIX(pix, shift)    \
 555     (( (shift) < 0) ? (pix) >> (-shift) : (pix) << (shift) )
 556
 557     Pixmap icon = XCALL(XCreatePixmap, d, w, width, height, depth);
 558     char *data = header_data;
 559     LONG red_shift, green_shift, blue_shift;
 560     GC gc;
 561
 562     D(bug("[X11OnBm] %s()\n", __PRETTY_FUNCTION__));
 563
 564     red_shift = 24 - xsd->red_shift;
 565     green_shift = 24 - xsd->green_shift;
 566     blue_shift = 24 - xsd->blue_shift;
 567
 568     if (icon)
 569     {
 570         gc = XCALL(XCreateGC, d, icon, 0, 0);
 571
 572         if (gc)
 573         {
 574             WORD x, y;
 575
 576             for (y = 0; y < height; y++)
 577             {
 578                 for (x = 0; x < width; x++)
 579                 {
 580                     ULONG rgb[3];
 581                     ULONG pixel = 0;
 582
 583                     HEADER_PIXEL(data, rgb);
 584
 585                     if (xsd->vi->class == TrueColor)
 586                     {
 587                         pixel = (SHIFT_PIX(rgb[0] & 0xFF, red_shift)
 588                                 & xsd->vi->red_mask)
 589                                 | (SHIFT_PIX(rgb[1] & 0xFF, green_shift)
 590                                         & xsd->vi->green_mask)
 591                                 | (SHIFT_PIX(rgb[2] & 0xFF, blue_shift)
 592                                         & xsd->vi->blue_mask);
 593                     }
 594                     else if (xsd->vi->class == PseudoColor)
 595                     {
 596                         XColor xcol;
 597
 598                         xcol.red = (rgb[0] << 8) + rgb[0];
 599                         xcol.green = (rgb[1] << 8) + rgb[1];
 600                         xcol.blue = (rgb[2] << 8) + rgb[2];
 601                         xcol.flags = DoRed | DoGreen | DoBlue;
 602
 603                         if (XCALL(XAllocColor, d, cm, &xcol))
 604                         {
 605                             pixel = xcol.pixel;
 606                         }
 607                     }
 608
 609                     XCALL(XSetForeground, d, gc, pixel);
 610                     XCALL(XDrawPoint, d, icon, gc, x, y);
 611                 }
 612             }
 613
 614             XCALL(XFreeGC, d, gc);
 615
 616         } /* if (gc) */
 617
 618     } /* if (icon) */
 619
 620     return icon;
 621 }
 622