rom/graphics/fakegfxhidd.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <string.h>
   7
   8 #include <proto/exec.h>
   9 #include <proto/oop.h>
  10 #include <proto/utility.h>
  11 #include <oop/oop.h>
  12 #include <hidd/graphics.h>
  13 #include <aros/atomic.h>
  14 #include <proto/arossupport.h>
  15
  16 #include "graphics_intern.h"
  17 #include "fakegfxhidd.h"
  18
  19 #define DCLIP(x)
  20 #define DCURS(x)
  21 #define DPOS(x)
  22 /*
  23  * DISABLE_ARGB_POINTER actually makes the software mouse pointer code to always
  24  * behave like if a LUT framebuffer is used.
  25  * Useful for debugging if you have only truecolor display modes.
  26  * If you define this, make sure that ALWAYS_ALLOCATE_SPRITE_COLORS in
  27  * intuition/intuition_intern.h is also defined.
  28  *
  29 #define DISABLE_ARGB_POINTER */
  30
  31 #include <aros/debug.h>
  32
  33 /******************************************************************************/
  34
  35 #define SPECIAL_LOCKING 1   /* When activated mouse cursor relevant locks are
  36                                treated in some kind of privileged way, by
  37                                inserting wait-for-sem-requests at head of
  38                                wait queue, instead of at tail */
  39
  40 /******************************************************************************/
  41
  42 static OOP_Class *init_fakefbclass(struct GfxBase *GfxBase);
  43 static OOP_Class *init_fakegfxhiddclass (struct GfxBase *GfxBase);
  44
  45 /******************************************************************************/
  46
  47 struct gfx_data
  48 {
  49     OOP_Object              *gfxhidd;
  50     OOP_Object              *framebuffer;
  51     OOP_Object              *fakefb;
  52     OOP_Object              *gc;
  53
  54     ULONG                   fakefb_attr;
  55     IPTR                    fb_width;
  56     IPTR                    fb_height;
  57
  58     OOP_Object              *curs_bm;
  59     OOP_Object              *curs_backup;
  60     UBYTE                   *curs_pixels;
  61     HIDDT_StdPixFmt         curs_pixfmt;
  62     UBYTE                   curs_bpp;
  63     BOOL                    curs_on;
  64     LONG                    curs_x;
  65     LONG                    curs_y;
  66     LONG                    curs_xoffset;
  67     LONG                    curs_yoffset;
  68     ULONG                   curs_width;
  69     ULONG                   curs_height;
  70     LONG                    curs_maxx;
  71     LONG                    curs_maxy;
  72     struct SignalSemaphore  fbsema;
  73     BOOL                    backup_done;
  74
  75     /* baseclasses for CreateObject */
  76     OOP_Class *basegc;
  77     OOP_Class *basebm;
  78 };
  79
  80 /******************************************************************************/
  81
  82 static void gfx_setFrameBuffer(struct GfxBase *GfxBase, struct gfx_data *data, OOP_Object *fb);
  83 static VOID draw_cursor(struct gfx_data *data, BOOL draw, BOOL updaterect, struct GfxBase *GfxBase);
  84 static BOOL rethink_cursor(struct gfx_data *data, struct GfxBase *GfxBase);
  85 static OOP_Object *create_fake_fb(OOP_Object *framebuffer, struct gfx_data *data, struct GfxBase *GfxBase);
  86
  87 /******************************************************************************/
  88
  89 #if SPECIAL_LOCKING
  90
  91 static void FakeGfxHidd_ObtainSemaphore(struct SignalSemaphore *sigSem, BOOL urgent,
  92                                         struct GfxBase *GfxBase)
  93 {
  94     struct Task *me;
  95
  96     /* Get pointer to current task */
  97     me=FindTask(NULL);
  98
  99     /* Arbitrate for the semaphore structure */
 100     Forbid();
 101
 102     /*
 103         ss_QueueCount == -1 indicates that the semaphore is
 104         free, so we increment this straight away. If it then
 105         equals 0, then we are the first to allocate this semaphore.
 106
 107         Note: This will need protection for SMP machines.
 108     */
 109     sigSem->ss_QueueCount++;
 110     if( sigSem->ss_QueueCount == 0 )
 111     {
 112         /* We now own the semaphore. This is quick. */
 113         sigSem->ss_Owner = me;
 114         sigSem->ss_NestCount++;
 115     }
 116
 117     /* The semaphore was in use, but was it by us? */
 118     else if( sigSem->ss_Owner == me )
 119     {
 120         /* Yes, just increase the nesting count */
 121         sigSem->ss_NestCount++;
 122     }
 123
 124     /*
 125         Else, some other task must own it. We have
 126         to set a waiting request here.
 127     */
 128     else
 129     {
 130         /*
 131             We need a node to mark our semaphore request. Lets use some
 132             stack memory.
 133         */
 134         struct SemaphoreRequest sr;
 135         sr.sr_Waiter = me;
 136
 137         /*
 138             Have to clear the signal to make sure that we don't
 139             return immediately. We then add the SemReq to the
 140             waiters list of the semaphore. We were the last to
 141             request, so we must be the last to get the semaphore.
 142         */
 143
 144         AROS_ATOMIC_AND(me->tc_SigRecvd, ~SIGF_SINGLE);
 145
 146         if (urgent)
 147         {
 148             AddHead((struct List *)&sigSem->ss_WaitQueue, (struct Node *)&sr);
 149         }
 150         else
 151         {
 152             AddTail((struct List *)&sigSem->ss_WaitQueue, (struct Node *)&sr);
 153         }
 154
 155         /*
 156             Finally, we simply wait, ReleaseSemaphore() will fill in
 157             who owns the semaphore.
 158         */
 159         Wait(SIGF_SINGLE);
 160     }
 161
 162     /* All Done! */
 163     Permit();
 164
 165 }
 166
 167 /******************************************************************************/
 168
 169 static void FakeGfxHidd_ReleaseSemaphore(struct SignalSemaphore *sigSem,
 170                                          struct GfxBase *GfxBase)
 171 {
 172    /* Protect the semaphore structure from multiple access. */
 173     Forbid();
 174
 175     /* Release one on the nest count */
 176     sigSem->ss_NestCount--;
 177     sigSem->ss_QueueCount--;
 178
 179     if(sigSem->ss_NestCount == 0)
 180     {
 181         /*
 182             There are two cases here. Either we are a shared
 183             semaphore, or not. If we are not, make sure that the
 184             correct Task is calling ReleaseSemaphore()
 185         */
 186
 187         /*
 188             Do not try and wake anything unless there are a number
 189             of tasks waiting. We do both the tests, this is another
 190             opportunity to throw an alert if there is an error.
 191         */
 192         if(
 193             sigSem->ss_QueueCount >= 0
 194          && sigSem->ss_WaitQueue.mlh_Head->mln_Succ != NULL
 195         )
 196         {
 197             struct SemaphoreRequest *sr, *srn;
 198
 199             /*
 200                 Look at the first node, but only to see whether it
 201                 is shared or not.
 202             */
 203             sr = (struct SemaphoreRequest *)sigSem->ss_WaitQueue.mlh_Head;
 204
 205             /*
 206                 A node is shared if the ln_Name/sr_Waiter field is
 207                 odd (ie it has bit 1 set).
 208
 209                 If the sr_Waiter field is != NULL, then this is a
 210                 task waiting, otherwise it is a message.
 211             */
 212             if( ((IPTR)sr->sr_Waiter & SM_SHARED) == SM_SHARED )
 213             {
 214                 /* This is a shared lock, so ss_Owner == NULL */
 215                 sigSem->ss_Owner = NULL;
 216
 217                 /* Go through all the nodes to find the shared ones */
 218                 ForeachNodeSafe(&sigSem->ss_WaitQueue, sr, srn)
 219                 {
 220                     srn = (struct SemaphoreRequest *)sr->sr_Link.mln_Succ;
 221
 222                     if( ((IPTR)sr->sr_Waiter & SM_SHARED) == SM_SHARED )
 223                     {
 224                         Remove((struct Node *)sr);
 225
 226                         /* Clear the bit, and update the owner count */
 227                         sr->sr_Waiter = (APTR)((IPTR)sr->sr_Waiter & ~1);
 228                         sigSem->ss_NestCount++;
 229
 230                         /* This is a task, signal it */
 231                         Signal(sr->sr_Waiter, SIGF_SINGLE);
 232                     }
 233                 }
 234             }
 235
 236             /*  This is an exclusive lock - awaken first node */
 237             else
 238             {
 239                 /* Only awaken the first of the nodes */
 240                 Remove((struct Node *)sr);
 241                 sigSem->ss_NestCount++;
 242
 243                 sigSem->ss_Owner = sr->sr_Waiter;
 244                 Signal(sr->sr_Waiter, SIGF_SINGLE);
 245             }
 246
 247         } /* there are waiters */
 248         /*  Otherwise, there are not tasks waiting. */
 249         else
 250         {
 251             sigSem->ss_Owner = NULL;
 252             sigSem->ss_QueueCount = -1;
 253         }
 254     }
 255     else if(sigSem->ss_NestCount < 0)
 256     {
 257         /*
 258             This can't happen. It means that somebody has released
 259             more times than they have obtained.
 260         */
 261         Alert( AN_SemCorrupt );
 262     }
 263
 264     /* All done. */
 265     Permit();
 266
 267 }
 268
 269 /******************************************************************************/
 270
 271 #define LFB(data)       FakeGfxHidd_ObtainSemaphore(&(data)->fbsema, FALSE, GfxBase)
 272 #define UFB(data)       FakeGfxHidd_ReleaseSemaphore(&(data)->fbsema, GfxBase)
 273 #define LFB_QUICK(data) FakeGfxHidd_ObtainSemaphore(&(data)->fbsema, TRUE, GfxBase)
 274 #define UFB_QUICK(data) FakeGfxHidd_ReleaseSemaphore(&(data)->fbsema, GfxBase)
 275
 276 #else   /* !SPECIAL_LOCKING */
 277
 278 #define LFB(data)       ObtainSemaphore(&(data)->fbsema)
 279 #define UFB(data)       ReleaseSemaphore(&(data)->fbsema)
 280 #define LFB_QUICK(data) ObtainSemaphore(&(data)->fbsema)
 281 #define UFB_QUICK(data) ReleaseSemaphore(&(data)->fbsema)
 282
 283 #endif /* SPECIAL_LOCKING */
 284
 285 /******************************************************************************/
 286
 287 #define GfxBase ((struct GfxBase *)cl->UserData)
 288
 289 static OOP_Object *gfx_new(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 290 {
 291     /* Create a new gfxhid object */
 292     OOP_Object      *realgfxhidd;
 293     struct gfx_data *data;
 294     BOOL             ok = FALSE;
 295
 296     realgfxhidd = (OOP_Object *)GetTagData(aHidd_FakeGfxHidd_RealGfxHidd, (IPTR)NULL, msg->attrList);
 297     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 298     if (NULL == o)
 299         return NULL;
 300
 301     data = OOP_INST_DATA(cl, o);
 302     memset(data, 0, sizeof (*data));
 303     InitSemaphore(&data->fbsema);
 304
 305     data->basegc = OOP_FindClass(CLID_Hidd_GC);
 306     data->basebm = OOP_FindClass(CLID_Hidd_BitMap);
 307
 308     /*
 309      * If this is direct framebuffer driver, we draw our
 310      * cursor on framebuffer bitmap.
 311      * Otherwise we draw cursor on displayable bitmaps.
 312      * TODO: Implement separate handling for mirrored framebuffers.
 313      *       In this case we actually don't need to backup pixels
 314      *       behind the sprite, because we can use mirror for this.
 315      */
 316     data->fakefb_attr = (OOP_GET(realgfxhidd, aHidd_Gfx_FrameBufferType) == vHidd_FrameBuffer_Direct) ?
 317                         aHidd_BitMap_FrameBuffer : aHidd_BitMap_Displayable;
 318
 319     data->gfxhidd = realgfxhidd;
 320
 321     if (NULL != data->gfxhidd)
 322     {
 323         struct TagItem gctags[] =
 324         {
 325             { TAG_DONE, 0UL }
 326         };
 327
 328         data->gc = HIDD_Gfx_CreateObject(data->gfxhidd, data->basegc, gctags);
 329         if (NULL != data->gc)
 330         {
 331             ok = TRUE;
 332         }
 333     }
 334
 335     if (!ok)
 336     {
 337         OOP_MethodID mid;
 338
 339         mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 340         OOP_CoerceMethod(cl, o, (OOP_Msg)&mid);
 341     }
 342
 343     return o;
 344 }
 345
 346 static VOID gfx_dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 347 {
 348     struct gfx_data *data;
 349
 350     data = OOP_INST_DATA(cl, o);
 351     if (NULL != data->curs_backup)
 352     {
 353         OOP_DisposeObject(data->curs_backup);
 354         data->curs_backup = NULL;
 355     }
 356
 357     if (data->curs_pixels)
 358         FreeMem(data->curs_pixels, data->curs_width * data->curs_height * 4);
 359
 360     if (NULL != data->gc)
 361     {
 362         OOP_DisposeObject(data->gc);
 363         data->gc = NULL;
 364     }
 365 }
 366
 367 static void gfx_get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 368 {
 369     struct gfx_data *data = OOP_INST_DATA(cl, o);
 370
 371     if (msg->attrID == aHidd_Gfx_HWSpriteTypes) {
 372         *msg->storage = vHidd_SpriteType_3Plus1|vHidd_SpriteType_DirectColor;
 373         return;
 374     }
 375
 376     OOP_DoMethod(data->gfxhidd, (OOP_Msg)msg);
 377 }
 378
 379 static IPTR gfx_fwd(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 380 {
 381     struct gfx_data *data = OOP_INST_DATA(cl, o);
 382
 383     return OOP_DoMethod(data->gfxhidd, msg);
 384 }
 385
 386 static OOP_Object *gfx_createobject(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CreateObject *msg)
 387 {
 388     struct gfx_data *data = OOP_INST_DATA(cl, o);
 389     OOP_Object      *object = NULL;
 390
 391     if (msg->cl == data->basebm)
 392     {
 393         /* Is the user about to create a framebuffer ? */
 394         BOOL                 create_fb;
 395         OOP_Object      *realfb;
 396
 397         create_fb = (BOOL)GetTagData(data->fakefb_attr, FALSE, msg->attrList);
 398
 399         realfb = HIDD_Gfx_CreateObject(data->gfxhidd, msg->cl, msg->attrList);
 400
 401         if (realfb && create_fb)
 402         {
 403             object = create_fake_fb(realfb, data, GfxBase);
 404             if (!object)
 405                 OOP_DisposeObject(realfb);
 406         }
 407         else
 408             object = realfb;
 409     }
 410     else
 411     {
 412         object = (OOP_Object *)gfx_fwd(cl, o, (OOP_Msg)msg);
 413     }
 414
 415     return object;
 416 }
 417
 418 static BOOL gfx_setcursorshape(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorShape *msg)
 419 {
 420     struct gfx_data *data;
 421     OOP_Object      *shape;
 422     BOOL             ok = TRUE;
 423
 424     data = OOP_INST_DATA(cl, o);
 425     shape = msg->shape;
 426     D(bug("[FakeGfx] SetCursorShape(0x%p)\n", shape));
 427
 428     /* Bitmap changed */
 429     if (NULL == shape)
 430     {
 431         /* Erase the old cursor */
 432         draw_cursor(data, FALSE, TRUE, GfxBase);
 433         data->curs_on = FALSE;
 434         data->curs_bm = NULL;
 435         data->curs_x     = data->curs_y         = 0;
 436         data->curs_maxx  = data->curs_maxy      = 0;
 437         data->curs_width = data->curs_height    = 0;
 438         data->curs_xoffset = 0;
 439         data->curs_yoffset = 0;
 440
 441         if (NULL != data->curs_backup)
 442         {
 443             OOP_DisposeObject(data->curs_backup);
 444             data->curs_backup = NULL;
 445         }
 446         if (data->curs_pixels) {
 447             FreeMem(data->curs_pixels, data->curs_width * data->curs_height * 4);
 448             data->curs_pixels = NULL;
 449         }
 450     }
 451     else
 452     {
 453         IPTR curs_width, curs_height;
 454         APTR new_curs_pixels;
 455         ULONG curs_pixels_len;
 456
 457         OOP_GetAttr(shape, aHidd_BitMap_Width,  &curs_width);
 458         OOP_GetAttr(shape, aHidd_BitMap_Height, &curs_height);
 459
 460         DCURS(bug("[FakeGfx] New cursor size: %lu x %lu, framebuffer 0x%p\n", curs_width, curs_height, data->framebuffer));
 461
 462         /* Create new cursor pixelbuffer. We multiply size by 4 because we want ARGB data
 463            to fit in. */
 464         curs_pixels_len = curs_width * curs_height * 4;
 465         new_curs_pixels = AllocMem(curs_pixels_len, MEMF_ANY|MEMF_CLEAR);
 466         if (!new_curs_pixels)
 467             return FALSE;
 468
 469         LFB(data);
 470
 471         /* Erase the old cursor */
 472         draw_cursor(data, FALSE, TRUE, GfxBase);
 473
 474         /* Now that we have disposed the old image using the old
 475            backup bm, we can install the new image and backup bm before
 476            rendering the new cursor.
 477            Backup bitmap is recreated in rethink_cursor()
 478         */
 479
 480         if (data->curs_pixels)
 481             FreeMem(data->curs_pixels, data->curs_width * data->curs_height * 4);
 482
 483         data->curs_bm     = shape;
 484         data->curs_width  = curs_width;
 485         data->curs_height = curs_height;
 486         data->curs_maxx   = data->curs_x + curs_width  - 1;
 487         data->curs_maxy   = data->curs_y + curs_height - 1;
 488         data->curs_pixels = new_curs_pixels;
 489         data->curs_xoffset = msg->xoffset;
 490         data->curs_yoffset = msg->yoffset;
 491
 492         ok = rethink_cursor(data, GfxBase);
 493         UFB(data);
 494
 495         draw_cursor(data, TRUE, TRUE, GfxBase);
 496     }
 497
 498     return ok;
 499 }
 500
 501 static BOOL gfx_setcursorpos(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorPos *msg)
 502 {
 503     struct gfx_data *data;
 504     IPTR xoffset = 0;
 505     IPTR yoffset = 0;
 506
 507     data = OOP_INST_DATA(cl, o);
 508     DPOS(bug("[FakeGfx] SetCursorPos(%d, %d)\n", msg->x, msg->y));
 509
 510     if (!data->framebuffer)
 511         return TRUE;
 512
 513     /* We draw our cursor on the bitmap, so we have to convert back
 514        from physical to logical coordinates */
 515     OOP_GetAttr(data->framebuffer, aHidd_BitMap_LeftEdge, &xoffset);
 516     OOP_GetAttr(data->framebuffer, aHidd_BitMap_TopEdge, &yoffset);
 517
 518     LFB_QUICK(data);
 519     /* erase the old cursor */
 520     draw_cursor(data, FALSE, TRUE, GfxBase);
 521
 522     data->curs_x = msg->x - xoffset;
 523     data->curs_y = msg->y - yoffset;
 524     /* Shift to the hotspot location */
 525     data->curs_x += data->curs_xoffset;
 526     data->curs_y += data->curs_yoffset;
 527     data->curs_maxx = data->curs_x + data->curs_width  - 1;
 528     data->curs_maxy = data->curs_y + data->curs_height - 1;
 529
 530     draw_cursor(data, TRUE, TRUE, GfxBase);
 531     UFB_QUICK(data);
 532     return TRUE;
 533 }
 534
 535 static VOID gfx_setcursorvisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
 536 {
 537     struct gfx_data *data;
 538
 539     data = OOP_INST_DATA(cl, o);
 540
 541 LFB_QUICK(data);
 542
 543     if (msg->visible)
 544     {
 545         if (!data->curs_on)
 546         {
 547             data->curs_on = TRUE;
 548             draw_cursor(data, TRUE, TRUE, GfxBase);
 549         }
 550     }
 551     else
 552     {
 553         if (data->curs_on)
 554         {
 555             draw_cursor(data, FALSE, TRUE, GfxBase);
 556             data->curs_on = FALSE;
 557         }
 558     }
 559
 560 UFB_QUICK(data);
 561
 562 }
 563
 564 #define PIXEL_INSIDE(fgh, x, y) \
 565         (    ( (x) >= (fgh)->curs_x     )       \
 566           && ( (y) >= (fgh)->curs_y     )       \
 567           && ( (x) <= (fgh)->curs_maxx  )       \
 568           && ( (y) <= (fgh)->curs_maxy  )       )
 569
 570 /* NOTE: x1, y1, x2, y2 MUST be sorted */
 571 #define RECT_INSIDE(fgh, x1, y1, x2, y2)        \
 572         (    ( (x1) <= fgh->curs_maxx   )       \
 573           && ( (x2) >= fgh->curs_x      )       \
 574           && ( (y1) <= fgh->curs_maxy   )       \
 575           && ( (y2) >= fgh->curs_y      )       )
 576
 577 #define WRECT_INSIDE(fgh, x1, y1, width, height)        \
 578         RECT_INSIDE(fgh, x1, y1, (x1) + (width) - 1, (y1) + (height) - 1)
 579
 580 static void gfx_copybox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
 581 {
 582     struct gfx_data *data;
 583     OOP_Object *src = NULL;
 584     OOP_Object *dest = NULL;
 585     BOOL inside = FALSE;
 586
 587     data = OOP_INST_DATA(cl, o);
 588     LFB(data);
 589
 590     /* De-masquerade bitmap objects, every of which can be fakefb object */
 591     OOP_GetAttr(msg->src, aHidd_FakeFB_RealBitMap, (IPTR *)&src);
 592     OOP_GetAttr(msg->dest, aHidd_FakeFB_RealBitMap, (IPTR *)&dest);
 593     if (!src)
 594         src = msg->src;
 595     if (!dest)
 596         dest = msg->dest;
 597
 598     /* FIXME: other bitmap may belong to another instance of fakegfx which can be on
 599               display on another monitor. In this case mouse cursor should be handled also
 600               there. Needs further reengineering. */
 601     if ((msg->src == data->fakefb) && WRECT_INSIDE(data, msg->srcX, msg->srcY, msg->width, msg->height))
 602         inside = TRUE;
 603
 604     if ((msg->dest == data->fakefb) && WRECT_INSIDE(data, msg->destX, msg->destY, msg->width, msg->height))
 605         inside = TRUE;
 606
 607     if (inside)
 608         draw_cursor(data, FALSE, FALSE, GfxBase);
 609
 610     HIDD_Gfx_CopyBox(data->gfxhidd, src, msg->srcX, msg->srcY,
 611                      dest, msg->destX, msg->destY, msg->width, msg->height, msg->gc);
 612
 613     if (inside)
 614         draw_cursor(data, TRUE, FALSE, GfxBase);
 615
 616     UFB(data);
 617 }
 618
 619 static IPTR gfx_copyboxmasked(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBoxMasked *msg)
 620 {
 621     struct gfx_data *data;
 622     OOP_Object *src = NULL;
 623     OOP_Object *dest = NULL;
 624     BOOL inside = FALSE;
 625     BOOL ret;
 626
 627     data = OOP_INST_DATA(cl, o);
 628     LFB(data);
 629
 630     /* De-masquerade bitmap objects, every of which can be fakefb object */
 631     OOP_GetAttr(msg->src, aHidd_FakeFB_RealBitMap, (IPTR *)&src);
 632     OOP_GetAttr(msg->dest, aHidd_FakeFB_RealBitMap, (IPTR *)&dest);
 633     if (!src)
 634         src = msg->src;
 635     if (!dest)
 636         dest = msg->dest;
 637
 638     /*
 639      * FIXME: other bitmap may belong to another instance of fakegfx which can be on
 640      *        display on another monitor. In this case mouse cursor should be handled also
 641      *        there. Needs further reengineering.
 642      */
 643     if ((msg->src == data->fakefb) && WRECT_INSIDE(data, msg->srcX, msg->srcY, msg->width, msg->height))
 644         inside = TRUE;
 645
 646     if ((msg->dest == data->fakefb) && WRECT_INSIDE(data, msg->destX, msg->destY, msg->width, msg->height))
 647         inside = TRUE;
 648
 649     if (inside)
 650         draw_cursor(data, FALSE, FALSE, GfxBase);
 651
 652     ret = HIDD_Gfx_CopyBoxMasked(data->gfxhidd, src, msg->srcX, msg->srcY,
 653                                  dest, msg->destX, msg->destY, msg->width, msg->height, msg->mask, msg->gc);
 654
 655     if (inside)
 656         draw_cursor(data, TRUE, FALSE, GfxBase);
 657
 658     UFB(data);
 659
 660     return ret;
 661 }
 662
 663 static OOP_Object *gfx_show(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_Show *msg)
 664 {
 665     OOP_Object *ret;
 666     struct gfx_data *data;
 667
 668     data = OOP_INST_DATA(cl, o);
 669     ret = msg->bitMap;
 670
 671     D(bug("[FakeGfx] Show(0x%p)\n", ret));
 672
 673     /*
 674      * If we are attempting to show a fake bitmap, we are working
 675      * in NoFrameBuffer mode where each displayable bitmap is
 676      * intercepted by us
 677      */
 678     if (ret && (OOP_OCLASS(ret) == CDD(GfxBase)->fakefbclass))
 679     {
 680         data->fakefb = ret;
 681         OOP_GetAttr(msg->bitMap, aHidd_FakeFB_RealBitMap, (IPTR *)&ret);
 682         D(bug("[FakeGfx] Bitmap is a fakefb object, real bitmap is 0x%p\n", ret));
 683     }
 684
 685     LFB(data);
 686     draw_cursor(data, FALSE, FALSE, GfxBase);
 687
 688     ret = HIDD_Gfx_Show(data->gfxhidd, ret, msg->flags);
 689     D(bug("[FakeGfx] Real framebuffer object 0x%p\n", ret));
 690     gfx_setFrameBuffer(GfxBase, data, ret);
 691     if (NULL != ret)
 692         ret = data->fakefb;
 693     /* FIXME: temporary workaround: at this point Intuition has already destroyed
 694        the sprite image (since the last screen was closed) but we have no information
 695        about it. Perhaps FreeSpriteData() should track this down somehow and inform
 696        drivers about destroyed sprites.
 697     if (!msg->bitMap)
 698         data->curs_bm = NULL;*/
 699     rethink_cursor(data, GfxBase);
 700     draw_cursor(data, TRUE, TRUE, GfxBase);
 701
 702     UFB(data);
 703
 704     D(bug("[FakeGfx] Returning 0x%p\n", ret));
 705     return ret;
 706 }
 707
 708 static ULONG gfx_showviewports(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 709 {
 710     /* Composition is not supported here */
 711     return FALSE;
 712 }
 713
 714 static BOOL gfx_getmaxspritesize(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_GetMaxSpriteSize *msg)
 715 {
 716     if (msg->Type & (vHidd_SpriteType_3Plus1|vHidd_SpriteType_DirectColor)) {
 717         /* I hope these values are enough for everyone :) */
 718         *msg->Width  = 65535;
 719         *msg->Height = 65535;
 720
 721         return TRUE;
 722     } else
 723         return FALSE;
 724 }
 725
 726 /* Private non-virtual method */
 727 static BOOL FakeGfx_UpdateFrameBuffer(OOP_Object *o)
 728 {
 729     OOP_Class *cl = OOP_OCLASS(o);
 730     struct gfx_data *data = OOP_INST_DATA(cl, o);
 731     BOOL ok;
 732
 733     LFB(data);
 734
 735     OOP_GetAttr(data->framebuffer, aHidd_BitMap_Width, &data->fb_width);
 736     OOP_GetAttr(data->framebuffer, aHidd_BitMap_Height, &data->fb_height);
 737
 738     DCURS(bug("[FakeGfx] Changed framebuffer size: %u x %u\n", data->fb_width, data->fb_height));
 739
 740     ok = rethink_cursor(data, GfxBase);
 741     UFB(data);
 742
 743     draw_cursor(data, TRUE, TRUE, GfxBase);
 744     return ok;
 745 }
 746
 747 struct fakefb_data
 748 {
 749     OOP_Object *framebuffer;
 750     OOP_Object *fakegfxhidd;
 751 };
 752
 753 #define FGH(data) ((struct gfx_data *)data->fakegfxhidd)
 754 #define REMOVE_CURSOR(data)     \
 755         draw_cursor(FGH(data), FALSE, FALSE, GfxBase)
 756
 757 #define RENDER_CURSOR(data)     \
 758         draw_cursor(FGH(data), TRUE, FALSE, GfxBase)
 759
 760
 761 #define BITMAP_METHOD_INIT      \
 762     struct fakefb_data *data;   \
 763     BOOL inside = FALSE;        \
 764     IPTR retval;                \
 765     struct gfx_data *fgh;       \
 766     data = OOP_INST_DATA(cl, o);        \
 767     fgh = FGH(data);            \
 768 LFB(fgh);
 769
 770 #define FORWARD_METHOD                  \
 771     retval = OOP_DoMethod(data->framebuffer, (OOP_Msg)msg);
 772
 773 #define BITMAP_METHOD_EXIT      \
 774     if (inside) {               \
 775         RENDER_CURSOR(data);    \
 776     }                           \
 777 UFB(fgh);                       \
 778     return retval;
 779
 780 static OOP_Object *fakefb_new(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 781 {
 782     OOP_Object *framebuffer;
 783     OOP_Object *fakegfxhidd;
 784
 785     framebuffer = (OOP_Object *)GetTagData(aHidd_FakeFB_RealBitMap,     0, msg->attrList);
 786     fakegfxhidd = (OOP_Object *)GetTagData(aHidd_FakeFB_FakeGfxHidd,    0, msg->attrList);
 787
 788     if (NULL == framebuffer || NULL == fakegfxhidd)
 789     {
 790         D(bug("!!! FakeBM::New(): MISSING FRAMEBUFFER OR FAKE GFX HIDD !!!\n"));
 791         return NULL;
 792     }
 793
 794     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 795     if (NULL != o)
 796     {
 797         struct fakefb_data *data;
 798         data = OOP_INST_DATA(cl, o);
 799         data->framebuffer = framebuffer;
 800         data->fakegfxhidd = fakegfxhidd;
 801     }
 802     return o;
 803 }
 804
 805 static VOID fakefb_dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 806 {
 807     struct fakefb_data *data;
 808     data = OOP_INST_DATA(cl, o);
 809     if (NULL != data->framebuffer)
 810     {
 811         OOP_DisposeObject(data->framebuffer);
 812         data->framebuffer = NULL;
 813     }
 814 }
 815
 816 static void fakefb_get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 817 {
 818     struct fakefb_data *data = OOP_INST_DATA(cl, o);
 819
 820     if (msg->attrID == aHidd_FakeFB_RealBitMap)
 821     {
 822         *msg->storage = (IPTR)data->framebuffer;
 823         return;
 824     }
 825     else if (msg->attrID == aHidd_BitMap_GfxHidd)
 826     {
 827         *msg->storage = (IPTR)data->fakegfxhidd;
 828         return;
 829     }
 830     else
 831         OOP_DoMethod(data->framebuffer, (OOP_Msg)msg);
 832 }
 833
 834 /* Intercept framebuffer mode change */
 835 static IPTR fakefb_set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 836 {
 837     struct fakefb_data *data = OOP_INST_DATA(cl, o);
 838     IPTR ret = OOP_DoMethod(data->framebuffer, &msg->mID);
 839     struct TagItem *modeid = FindTagItem(aHidd_BitMap_ModeID, msg->attrList);
 840
 841     if (modeid && ret)
 842     {
 843         /* Framebuffer mode change succeeded. Update fakegfx' information */
 844         ret = FakeGfx_UpdateFrameBuffer(data->fakegfxhidd);
 845     }
 846
 847     return ret;
 848 }
 849
 850 static IPTR fakefb_getpixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetPixel *msg)
 851 {
 852     BITMAP_METHOD_INIT
 853
 854     if (PIXEL_INSIDE(fgh, msg->x, msg->y))
 855     {
 856         REMOVE_CURSOR(data);
 857         inside = TRUE;
 858     }
 859
 860     FORWARD_METHOD
 861
 862     BITMAP_METHOD_EXIT
 863 }
 864
 865 static IPTR fakefb_putpixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPixel *msg)
 866 {
 867     BITMAP_METHOD_INIT
 868
 869     if (PIXEL_INSIDE(fgh, msg->x, msg->y))
 870     {
 871         REMOVE_CURSOR(data);
 872         inside = TRUE;
 873     }
 874
 875     FORWARD_METHOD
 876
 877     BITMAP_METHOD_EXIT
 878 }
 879
 880 static IPTR fakefb_drawpixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPixel *msg)
 881 {
 882     BITMAP_METHOD_INIT
 883
 884     if (PIXEL_INSIDE(fgh, msg->x, msg->y))
 885     {
 886         REMOVE_CURSOR(data);
 887         inside = TRUE;
 888     }
 889
 890     FORWARD_METHOD
 891
 892     BITMAP_METHOD_EXIT
 893 }
 894
 895 static IPTR fakefb_drawline(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawLine *msg)
 896 {
 897     register LONG x1, y1, x2, y2;
 898     BITMAP_METHOD_INIT
 899
 900     if (msg->x1 < msg->x2)
 901     {
 902         x1 = msg->x1; x2 = msg->x2;
 903     }
 904     else
 905     {
 906         x2 = msg->x1; x1 = msg->x2;
 907     }
 908
 909     if (msg->y1 < msg->y2)
 910     {
 911         y1 = msg->y1; y2 = msg->y2;
 912     }
 913     else
 914     {
 915         y2 = msg->y1; y1 = msg->y2;
 916     }
 917
 918     /* FIXME: Maybe do some more intelligent checking for DrawLine */
 919     if (RECT_INSIDE(fgh, x1, y1, x2, y2))
 920     {
 921         REMOVE_CURSOR(data);
 922         inside = TRUE;
 923     }
 924
 925     FORWARD_METHOD
 926
 927     BITMAP_METHOD_EXIT
 928 }
 929
 930 static IPTR fakefb_getimage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
 931 {
 932     BITMAP_METHOD_INIT
 933
 934     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 935     {
 936         REMOVE_CURSOR(data);
 937         inside = TRUE;
 938     }
 939
 940     FORWARD_METHOD
 941
 942     BITMAP_METHOD_EXIT
 943 }
 944
 945 static IPTR fakefb_putimage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImage *msg)
 946 {
 947     BITMAP_METHOD_INIT
 948
 949     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 950     {
 951         REMOVE_CURSOR(data);
 952         inside = TRUE;
 953     }
 954
 955     FORWARD_METHOD
 956
 957     BITMAP_METHOD_EXIT
 958 }
 959
 960 static IPTR fakefb_putalphaimage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutAlphaImage *msg)
 961 {
 962     BITMAP_METHOD_INIT
 963
 964     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 965     {
 966         REMOVE_CURSOR(data);
 967         inside = TRUE;
 968     }
 969
 970     FORWARD_METHOD
 971
 972     BITMAP_METHOD_EXIT
 973 }
 974
 975 static IPTR fakefb_puttemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
 976 {
 977     BITMAP_METHOD_INIT
 978
 979     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 980     {
 981         REMOVE_CURSOR(data);
 982         inside = TRUE;
 983     }
 984
 985     FORWARD_METHOD
 986
 987     BITMAP_METHOD_EXIT
 988 }
 989
 990 static IPTR fakefb_putalphatemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutAlphaTemplate *msg)
 991 {
 992     BITMAP_METHOD_INIT
 993
 994     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 995     {
 996         REMOVE_CURSOR(data);
 997         inside = TRUE;
 998     }
 999
1000     FORWARD_METHOD
1001
1002     BITMAP_METHOD_EXIT
1003 }
1004
1005 static IPTR fakefb_putpattern(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPattern *msg)
1006 {
1007     BITMAP_METHOD_INIT
1008
1009     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1010     {
1011         REMOVE_CURSOR(data);
1012         inside = TRUE;
1013     }
1014
1015     FORWARD_METHOD
1016
1017     BITMAP_METHOD_EXIT
1018 }
1019
1020 static IPTR fakefb_getimagelut(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImageLUT *msg)
1021 {
1022     BITMAP_METHOD_INIT
1023
1024     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1025     {
1026         REMOVE_CURSOR(data);
1027         inside = TRUE;
1028     }
1029
1030     FORWARD_METHOD
1031
1032     BITMAP_METHOD_EXIT
1033 }
1034
1035 static IPTR fakefb_putimagelut(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImageLUT *msg)
1036 {
1037     BITMAP_METHOD_INIT
1038
1039     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1040     {
1041         REMOVE_CURSOR(data);
1042         inside = TRUE;
1043     }
1044
1045     FORWARD_METHOD
1046
1047     BITMAP_METHOD_EXIT
1048 }
1049
1050 static IPTR fakefb_puttranspimagelut(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTranspImageLUT *msg)
1051 {
1052     BITMAP_METHOD_INIT
1053
1054     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1055     {
1056         REMOVE_CURSOR(data);
1057         inside = TRUE;
1058     }
1059
1060     FORWARD_METHOD
1061
1062     BITMAP_METHOD_EXIT
1063 }
1064
1065 static IPTR fakefb_drawrect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
1066 {
1067     BITMAP_METHOD_INIT
1068
1069     /* FIXME: Maybe do something clever here to see if the rectangle is drawn around the cursor     */
1070     if (RECT_INSIDE(fgh, msg->minX, msg->minY, msg->maxX, msg->maxY))
1071     {
1072         REMOVE_CURSOR(data);
1073         inside = TRUE;
1074     }
1075
1076     FORWARD_METHOD
1077
1078     BITMAP_METHOD_EXIT
1079 }
1080
1081 static IPTR fakefb_fillrect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
1082 {
1083     BITMAP_METHOD_INIT
1084
1085  /* bug("BITMAP FILLRECT(%d, %d, %d, %d), (%d, %d, %d, %d, %d, %d)\n"
1086         , msg->minX, msg->minY, msg->maxX, msg->maxY
1087         , fgh->curs_x, fgh->curs_y, fgh->curs_maxx, fgh->curs_maxy
1088         , fgh->curs_width, fgh->curs_height);
1089 */
1090     if (RECT_INSIDE(fgh, msg->minX, msg->minY, msg->maxX, msg->maxY))
1091     {
1092 /*  bug("FILLRECT: REMOVING CURSOR\n");
1093 */
1094         REMOVE_CURSOR(data);
1095
1096         inside = TRUE;
1097     }
1098
1099     FORWARD_METHOD
1100
1101     BITMAP_METHOD_EXIT
1102 }
1103
1104 static IPTR fakefb_drawellipse(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawEllipse *msg)
1105 {
1106     register LONG x1, y1, x2, y2;
1107     BITMAP_METHOD_INIT
1108
1109     x1 = msg->x - msg->rx;
1110     y1 = msg->y - msg->ry;
1111     x2 = msg->x + msg->rx;
1112     y2 = msg->y + msg->ry;
1113     /* FIXME: Maybe do something clever here to see if the rectangle is drawn around the cursor     */
1114
1115     if (RECT_INSIDE(fgh, x1, y1, x2, y2))
1116     {
1117         REMOVE_CURSOR(data);
1118         inside = TRUE;
1119     }
1120
1121     FORWARD_METHOD
1122
1123     BITMAP_METHOD_EXIT
1124 }
1125
1126 static IPTR fakefb_fillellipse(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawEllipse *msg)
1127 {
1128     register LONG x1, y1, x2, y2;
1129     BITMAP_METHOD_INIT
1130
1131     x1 = msg->x - msg->rx;
1132     y1 = msg->y - msg->ry;
1133     x2 = msg->x + msg->rx;
1134     y2 = msg->y + msg->ry;
1135
1136     if (RECT_INSIDE(fgh, x1, y1, x2, y2))
1137     {
1138         REMOVE_CURSOR(data);
1139         inside = TRUE;
1140     }
1141
1142     FORWARD_METHOD
1143
1144     BITMAP_METHOD_EXIT
1145 }
1146
1147 static IPTR fakefb_drawpolygon(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPolygon *msg)
1148 {
1149     BITMAP_METHOD_INIT
1150     /* FIXME: Maybe do checking here, but it probably is not worth it     */
1151     REMOVE_CURSOR(data);
1152     inside = TRUE;
1153
1154     FORWARD_METHOD
1155
1156     BITMAP_METHOD_EXIT
1157 }
1158
1159 static IPTR fakefb_fillpolygon(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPolygon *msg)
1160 {
1161     BITMAP_METHOD_INIT
1162     /* FIXME: Maybe do checking here, but it probably is not worth it     */
1163     REMOVE_CURSOR(data);
1164     inside = TRUE;
1165
1166     FORWARD_METHOD
1167
1168     BITMAP_METHOD_EXIT
1169 }
1170
1171
1172 static IPTR fakefb_drawtext(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawText *msg)
1173 {
1174     BITMAP_METHOD_INIT
1175
1176     /* FIXME: Maybe do testing here, but probably not wirth it     */
1177     REMOVE_CURSOR(data);
1178
1179     FORWARD_METHOD
1180
1181     BITMAP_METHOD_EXIT
1182 }
1183
1184 static IPTR fakefb_drawfilltext(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawText *msg)
1185 {
1186     BITMAP_METHOD_INIT
1187
1188     /* FIXME: Maybe do testing here, but probably not worth it     */
1189     REMOVE_CURSOR(data);
1190
1191     FORWARD_METHOD
1192
1193     BITMAP_METHOD_EXIT
1194 }
1195
1196 static IPTR fakefb_blitcolexp(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BlitColorExpansion *msg)
1197 {
1198     BITMAP_METHOD_INIT
1199
1200     if (WRECT_INSIDE(fgh, msg->destX, msg->destY, msg->width, msg->height))
1201     {
1202         REMOVE_CURSOR(data);
1203         inside = TRUE;
1204     }
1205
1206     FORWARD_METHOD
1207
1208     BITMAP_METHOD_EXIT
1209 }
1210
1211 static IPTR fakefb_clear(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_Clear *msg)
1212 {
1213     BITMAP_METHOD_INIT
1214
1215     inside = TRUE;
1216
1217     FORWARD_METHOD
1218
1219     BITMAP_METHOD_EXIT
1220 }
1221
1222
1223 static IPTR fakefb_fillspan(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
1224 {
1225     BITMAP_METHOD_INIT
1226
1227     REMOVE_CURSOR(data);
1228     inside = TRUE;
1229
1230     FORWARD_METHOD
1231
1232     BITMAP_METHOD_EXIT
1233 }
1234
1235 static IPTR fakefb_scale(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BitMapScale *msg)
1236 {
1237     /* FIXME: should check both source and destination, similar to gfx_copybox() */
1238     BITMAP_METHOD_INIT
1239
1240     if (WRECT_INSIDE(fgh, msg->bsa->bsa_SrcX, msg->bsa->bsa_SrcY, msg->bsa->bsa_SrcWidth, msg->bsa->bsa_SrcHeight))
1241     {
1242         REMOVE_CURSOR(data);
1243         inside = TRUE;
1244     }
1245
1246     FORWARD_METHOD
1247
1248     BITMAP_METHOD_EXIT
1249 }
1250
1251 static IPTR fakefb_fwd(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
1252 {
1253     struct fakefb_data *data;
1254     data = OOP_INST_DATA(cl, o);
1255 // kill(getpid(), 19);
1256 // bug("BITMAP_FWD\n");
1257     return OOP_DoMethod(data->framebuffer, msg);
1258 }
1259
1260 #undef GfxBase
1261
1262 static BOOL rethink_cursor(struct gfx_data *data, struct GfxBase *GfxBase)
1263 {
1264     OOP_Object *pf, *cmap;
1265     IPTR        fbdepth, curdepth, i;
1266     UWORD       curs_base = 16;
1267
1268     struct TagItem bmtags[] = {
1269         { aHidd_BitMap_Width , data->curs_width       },
1270         { aHidd_BitMap_Height, data->curs_height      },
1271         { aHidd_BitMap_Friend, (IPTR)data->framebuffer},
1272         { TAG_DONE           , 0UL                     }
1273     };
1274
1275     D(bug("rethink_cursor(), curs_bm is 0x%p, framebuffer is 0x%p\n", data->curs_bm, data->framebuffer));
1276
1277     /* The first thing we do is recreating a backup bitmap. We do it every time when either
1278        cursor shape changes (because new shape may have different size) or shown bitmap
1279        changes (because new bitmap may have different depth). Note that even real framebuffer
1280        object may dynamically change its characteristics.
1281
1282        Delete the old backup bitmap first */
1283     if (NULL != data->curs_backup) {
1284         OOP_DisposeObject(data->curs_backup);
1285         D(bug("[FakeGfx] Disposed old backup bitmap\n"));
1286         data->curs_backup = NULL;
1287     }
1288
1289     /* If we have no cursor, we have nothing more to do.
1290        We also don't need new backup bitmap */
1291     if (!data->curs_bm)
1292         return TRUE;
1293
1294     /* We may also have no framebuffer (empty display on
1295        non-framebuffer driver). Also NOP in this case */
1296     if (!data->framebuffer)
1297         return TRUE;
1298
1299     /* Create new backup bitmap */
1300     data->curs_backup = HIDD_Gfx_CreateObject(data->gfxhidd, data->basebm, bmtags);
1301     D(bug("[FakeGfx] New backup bitmap is 0x%p\n", data->curs_backup));
1302     if (!data->curs_backup)
1303         return FALSE;
1304
1305     OOP_GetAttr(data->framebuffer, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1306     D(bug("[FakeGfx] Framebuffer pixelformat 0x%p\n", pf));
1307     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &fbdepth);
1308     D(bug("[FakeGfx] Framebuffer depth %u\n", fbdepth));
1309     OOP_GetAttr(data->curs_bm, aHidd_BitMap_ColorMap, (IPTR *)&cmap);
1310     D(bug("[FakeGfx] Cursor colormap 0x%p\n", cmap));
1311     OOP_GetAttr(data->curs_bm, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1312     D(bug("[FakeGfx] Cursor pixelformat 0x%p\n", pf));
1313     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &curdepth);
1314     D(bug("[FakeGfx] Cursor depth %u\n", curdepth));
1315
1316 #ifndef DISABLE_ARGB_POINTER
1317     /* We can get ARGB data from the pointer bitmap only
1318        on one of two cases:
1319        1) Pointer bitmap has more than 256 colors, in this case it
1320           stores ARGB data in itself.
1321        2) Pointer bitmap is a LUT bitmap with a colormap attached.
1322           In this case colormap should contain ARGB values for actual
1323           colors.
1324        Of course having ARGB data makes sense only on truecolor screens. */
1325     if ((fbdepth > 8) && ((curdepth > 8) || cmap)) {
1326         data->curs_pixfmt = vHidd_StdPixFmt_ARGB32;
1327         data->curs_bpp    = 4;
1328     } else
1329 #endif
1330     {
1331         data->curs_pixfmt = vHidd_StdPixFmt_LUT8;
1332         data->curs_bpp    = 1;
1333         /* TODO: curs_base should be somehow synchronised with SpriteBase field of ColorMap */
1334         curs_base = (fbdepth > 4) ? 16 : (1 << fbdepth) - 8;
1335     }
1336     /* If we have some good bitmap->bitmap blitting function with alpha channel support,
1337        we would not need this extra buffer and conversion for truecolor screens. */
1338     HIDD_BM_GetImage(data->curs_bm, data->curs_pixels, data->curs_width * data->curs_bpp, 0, 0, data->curs_width, data->curs_height, data->curs_pixfmt);
1339     D(bug("[FakeGfx] Obtained cursor sprite data @ 0x%p\n", data->curs_pixels));
1340
1341     if (data->curs_pixfmt == vHidd_StdPixFmt_LUT8)
1342     {
1343         for (i = 0; i < data->curs_width * data->curs_height; i++)
1344         {
1345             if (data->curs_pixels[i])
1346                 data->curs_pixels[i] += curs_base;
1347         }
1348     }
1349     return TRUE;
1350 }
1351
1352 static VOID draw_cursor(struct gfx_data *data, BOOL draw, BOOL updaterect, struct GfxBase *GfxBase)
1353 {
1354     LONG width, height;
1355     LONG fbwidth, fbheight;
1356     LONG x, y;
1357     LONG w2end, h2end;
1358     ULONG xoffset = 0;
1359     ULONG yoffset = 0;
1360
1361     struct TagItem gctags[] =
1362     {
1363         { aHidd_GC_DrawMode , vHidd_GC_DrawMode_Copy    },
1364         { TAG_DONE          , 0UL                       }
1365     };
1366
1367     if (!data->curs_on)
1368         return;
1369
1370     if (NULL == data->curs_bm || NULL == data->framebuffer)
1371     {
1372         DB2(bug("!!! draw_cursor: FAKE GFX HIDD NOT PROPERLY INITIALIZED !!!\n"));
1373         DB2(bug("CURS BM: 0x%p, FB: 0x%p\n", data->curs_bm, data->framebuffer));
1374         return;
1375     }
1376
1377     fbwidth  = data->fb_width;
1378     fbheight = data->fb_height;
1379     width    = data->curs_width;
1380     height   = data->curs_height;
1381     x        = data->curs_x;
1382     y        = data->curs_y;
1383
1384     /* Do nothing if sprite went outside of bitmap */
1385     if ((x < -width) || (y < -height)) {
1386         DCURS(bug("[FakeGfx] Cursor is beyond left or top edge\n"));
1387         return;
1388     }
1389     if ((x >= fbwidth) || (y >= fbheight)) {
1390         DCURS(bug("[FakeGfx] Cursor is beyond right or bottom edge\n"));
1391         return;
1392     }
1393
1394     /* Do some clipping */
1395     if (x < 0) {
1396         xoffset = -x;
1397         width += x;
1398         x = 0;
1399     }
1400
1401     if (y < 0) {
1402         yoffset = -y;
1403         height += y;
1404         y = 0;
1405     }
1406
1407     w2end = data->fb_width - width;
1408     h2end = data->fb_height - height;
1409
1410     if (x > w2end)
1411     {
1412         width -= (x - w2end);
1413         DCLIP(bug("[FakeGfx] Clipped sprite width to %d\n", width));
1414     }
1415
1416     if (y > h2end)
1417     {
1418         height -= (y - h2end);
1419         DCLIP(bug("[FakeGfx] Clipped sprite height to %d\n", height));
1420     }
1421
1422     /* FIXME: clip negative coordinates */
1423
1424     OOP_SetAttrs(data->gc, gctags);
1425
1426     if (draw)
1427     {
1428         /* Calculate origin of sprite image according to offsets */
1429         ULONG modulo = data->curs_width * data->curs_bpp;
1430         UBYTE *pixels = data->curs_pixels + yoffset * modulo + xoffset * data->curs_bpp;
1431
1432         /* Backup under the new cursor image */
1433         // bug("BACKING UP RENDERED AREA\n");
1434         HIDD_Gfx_CopyBox(data->gfxhidd
1435             , data->framebuffer
1436             , x, y
1437             , data->curs_backup
1438             , 0, 0
1439             , width, height
1440             , data->gc
1441         );
1442
1443         data->backup_done = TRUE;
1444
1445         DB2(bug("[FakeGfx] Rendering cursor, framebuffer 0x%p\n", data->framebuffer));
1446         /* Render the cursor image */
1447         if (data->curs_pixfmt == vHidd_StdPixFmt_ARGB32)
1448             HIDD_BM_PutAlphaImage(data->framebuffer, data->gc, pixels, modulo, x, y, width, height);
1449         else
1450             /* data->curs_bpp is always 1 here so we safely ignore it */
1451             HIDD_BM_PutTranspImageLUT(data->framebuffer, data->gc, pixels, modulo, x, y, width, height, NULL, 0);
1452
1453         if (updaterect)
1454             HIDD_BM_UpdateRect(data->framebuffer, x, y, width, height);
1455
1456     }
1457     else
1458     {
1459         /* Erase the old cursor image */
1460         if (data->backup_done)
1461         {
1462             DB2(bug("[FakeGfx] Restoring cursor area, framebuffer 0x%p\n", data->framebuffer));
1463             HIDD_Gfx_CopyBox(data->gfxhidd
1464                 , data->curs_backup
1465                 , 0, 0
1466                 , data->framebuffer
1467                 , x, y
1468                 , width, height
1469                 , data->gc
1470             );
1471
1472             if (updaterect)
1473                 HIDD_BM_UpdateRect(data->framebuffer, x, y, width, height);
1474         }
1475     }
1476     return;
1477 }
1478
1479 static void gfx_setFrameBuffer(struct GfxBase *GfxBase, struct gfx_data *data, OOP_Object *fb)
1480 {
1481     data->framebuffer = fb;
1482
1483     if (fb)
1484     {
1485         /* Cache framebuffer size, needed by sprite rendering routine */
1486         OOP_GetAttr(fb, aHidd_BitMap_Width, &data->fb_width);
1487         OOP_GetAttr(fb, aHidd_BitMap_Height, &data->fb_height);
1488
1489         DCURS(bug("[FakeGfx] Framebuffer size: %u x %u\n", data->fb_width, data->fb_height));
1490     }
1491 }
1492
1493 static OOP_Object *create_fake_fb(OOP_Object *framebuffer, struct gfx_data *data, struct GfxBase *GfxBase)
1494 {
1495     OOP_Object *fakebm;
1496     struct TagItem fakebmtags[] =
1497     {
1498         { aHidd_FakeFB_RealBitMap   , (IPTR)framebuffer },
1499         { aHidd_FakeFB_FakeGfxHidd  , (IPTR)data        },
1500         { TAG_DONE                  , 0UL               }
1501     };
1502
1503     /* If we work with framebuffer-based driver, Show() will never be called on
1504        a fakefb object so we remember it right now */
1505     fakebm = OOP_NewObject(CDD(GfxBase)->fakefbclass, NULL, fakebmtags);
1506
1507     if (data->fakefb_attr == aHidd_BitMap_FrameBuffer)
1508     {
1509         data->fakefb      = fakebm;
1510         gfx_setFrameBuffer(GfxBase, data, framebuffer);
1511     }
1512
1513     return fakebm;
1514 }
1515
1516 static OOP_Class *init_fakegfxhiddclass (struct GfxBase *GfxBase)
1517 {
1518     OOP_Class *cl = NULL;
1519
1520     struct OOP_MethodDescr root_descr[num_Root_Methods + 1] =
1521     {
1522         {(IPTR (*)())gfx_new    ,               moRoot_New      },
1523         {(IPTR (*)())gfx_dispose,               moRoot_Dispose  },
1524         {(IPTR (*)())gfx_get    ,               moRoot_Get      },
1525         {(IPTR (*)())gfx_fwd    ,               moRoot_Set      },
1526         { NULL                  , 0UL                           }
1527     };
1528
1529     struct OOP_MethodDescr gfxhidd_descr[num_Hidd_Gfx_Methods + 1] =
1530     {
1531         {(IPTR (*)())gfx_createobject      , moHidd_Gfx_CreateObject    },
1532         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_QueryModeIDs    },
1533         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ReleaseModeIDs  },
1534         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_CheckMode       },
1535         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NextModeID      },
1536         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetMode         },
1537         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetPixFmt       },
1538         {(IPTR (*)())gfx_setcursorshape    , moHidd_Gfx_SetCursorShape  },
1539         {(IPTR (*)())gfx_setcursorpos      , moHidd_Gfx_SetCursorPos    },
1540         {(IPTR (*)())gfx_setcursorvisible  , moHidd_Gfx_SetCursorVisible},
1541         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_SetMode         },
1542         {(IPTR (*)())gfx_show              , moHidd_Gfx_Show            },
1543         {(IPTR (*)())gfx_copybox           , moHidd_Gfx_CopyBox         },
1544         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ModeProperties  },
1545         {(IPTR (*)())gfx_showviewports     , moHidd_Gfx_ShowViewPorts   },
1546         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetSync         },
1547         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetGamma        },
1548         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_SetGamma        },
1549         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_QueryHardware3D },
1550         {(IPTR (*)())gfx_getmaxspritesize  , moHidd_Gfx_GetMaxSpriteSize},
1551         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NewOverlay      },
1552         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeOverlay  },
1553         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_MakeViewPort    },
1554         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_CleanViewPort   },
1555         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_PrepareViewPorts},
1556         {(IPTR (*)())gfx_copyboxmasked     , moHidd_Gfx_CopyBoxMasked   },
1557         {NULL                              , 0UL                        }
1558     };
1559
1560     struct OOP_InterfaceDescr ifdescr[] =
1561     {
1562         {root_descr     , IID_Root      , num_Root_Methods      },
1563         {gfxhidd_descr  , IID_Hidd_Gfx  , num_Hidd_Gfx_Methods  },
1564         {NULL           , NULL          , 0                     }
1565     };
1566
1567     OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
1568
1569     struct TagItem tags[] =
1570     {
1571         { aMeta_SuperID         , (IPTR)CLID_Root                   },
1572         { aMeta_InterfaceDescr  , (IPTR)ifdescr                     },
1573         { aMeta_InstSize        , (IPTR)sizeof (struct gfx_data)    },
1574         {TAG_DONE               , 0UL                               }
1575     };
1576
1577
1578     D(bug("INIT FAKEGFXCLASS\n"));
1579
1580     if ((__IHidd_FakeFB = OOP_ObtainAttrBase(IID_Hidd_FakeFB)))
1581     {
1582         cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
1583         if(NULL != cl)
1584         {
1585             D(bug("FAKE GFX CLASS INITED\n"));
1586             cl->UserData = GfxBase;
1587
1588             return cl;
1589         }
1590
1591         OOP_ReleaseAttrBase(IID_Hidd_FakeFB);
1592     }
1593
1594     return NULL;
1595 }
1596
1597 static OOP_Class *init_fakefbclass(struct GfxBase *GfxBase)
1598 {
1599     struct OOP_MethodDescr root_descr[num_Root_Methods + 1] =
1600     {
1601         {(IPTR (*)())fakefb_new    , moRoot_New     },
1602         {(IPTR (*)())fakefb_dispose, moRoot_Dispose },
1603         {(IPTR (*)())fakefb_get    , moRoot_Get     },
1604         {(IPTR (*)())fakefb_set    , moRoot_Set     },
1605         {NULL                      , 0UL            }
1606     };
1607
1608     struct OOP_MethodDescr bitmap_descr[num_Hidd_BitMap_Methods + 1] =
1609     {
1610         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetColors           },
1611         {(IPTR (*)())fakefb_putpixel            , moHidd_BitMap_PutPixel            },
1612         {(IPTR (*)())fakefb_drawpixel           , moHidd_BitMap_DrawPixel           },
1613         {(IPTR (*)())fakefb_putimage            , moHidd_BitMap_PutImage            },
1614         {(IPTR (*)())fakefb_putalphaimage       , moHidd_BitMap_PutAlphaImage       },
1615         {(IPTR (*)())fakefb_puttemplate , moHidd_BitMap_PutTemplate         },
1616         {(IPTR (*)())fakefb_putalphatemplate    , moHidd_BitMap_PutAlphaTemplate    },
1617         {(IPTR (*)())fakefb_putpattern          , moHidd_BitMap_PutPattern          },
1618         {(IPTR (*)())fakefb_getimage            , moHidd_BitMap_GetImage            },
1619         {(IPTR (*)())fakefb_getpixel            , moHidd_BitMap_GetPixel            },
1620         {(IPTR (*)())fakefb_drawline            , moHidd_BitMap_DrawLine            },
1621         {(IPTR (*)())fakefb_drawrect            , moHidd_BitMap_DrawRect            },
1622         {(IPTR (*)())fakefb_fillrect            , moHidd_BitMap_FillRect            },
1623         {(IPTR (*)())fakefb_drawellipse , moHidd_BitMap_DrawEllipse         },
1624         {(IPTR (*)())fakefb_fillellipse , moHidd_BitMap_FillEllipse         },
1625         {(IPTR (*)())fakefb_drawpolygon , moHidd_BitMap_DrawPolygon         },
1626         {(IPTR (*)())fakefb_fillpolygon , moHidd_BitMap_FillPolygon         },
1627         {(IPTR (*)())fakefb_drawtext            , moHidd_BitMap_DrawText            },
1628         {(IPTR (*)())fakefb_drawfilltext        , moHidd_BitMap_FillText            },
1629         {(IPTR (*)())fakefb_fillspan            , moHidd_BitMap_FillSpan            },
1630         {(IPTR (*)())fakefb_clear               , moHidd_BitMap_Clear               },
1631         {(IPTR (*)())fakefb_blitcolexp          , moHidd_BitMap_BlitColorExpansion  },
1632         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_MapColor            },
1633         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_UnmapPixel          },
1634         {(IPTR (*)())fakefb_putimagelut , moHidd_BitMap_PutImageLUT         },
1635         {(IPTR (*)())fakefb_puttranspimagelut   , moHidd_BitMap_PutTranspImageLUT   },
1636         {(IPTR (*)())fakefb_getimagelut , moHidd_BitMap_GetImageLUT         },
1637         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_BytesPerLine        },
1638         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ConvertPixels       },
1639         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect8        },
1640         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect16       },
1641         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect24       },
1642         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect32       },
1643         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_InvertMemRect       },
1644         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox8         },
1645         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox16        },
1646         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox24        },
1647         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox32        },
1648         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox16     },
1649         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox24     },
1650         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox32     },
1651         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image8      },
1652         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image16     },
1653         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image24     },
1654         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image8      },
1655         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image16     },
1656         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image24     },
1657         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate8     },
1658         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate16    },
1659         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate24    },
1660         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate32    },
1661         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern8      },
1662         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern16     },
1663         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern24     },
1664         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern32     },
1665         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetColorMap         },
1666         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ObtainDirectAccess  },
1667         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ReleaseDirectAccess },
1668         {(IPTR (*)())fakefb_scale               , moHidd_BitMap_BitMapScale         },
1669         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PrivateSet          },
1670         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetRGBConversionFunction },
1671         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_UpdateRect          },
1672         {NULL                                   , 0UL                               }
1673     };
1674
1675     struct OOP_InterfaceDescr ifdescr[] =
1676     {
1677         {root_descr     , IID_Root       , num_Root_Methods         },
1678         {bitmap_descr   , IID_Hidd_BitMap, num_Hidd_BitMap_Methods  },
1679         {NULL           , NULL           , 0                        }
1680     };
1681
1682     OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
1683
1684     struct TagItem tags[] =
1685     {
1686         {aMeta_SuperID          , (IPTR) CLID_Root                  },
1687         {aMeta_InterfaceDescr   , (IPTR) ifdescr                    },
1688         {aMeta_InstSize         , (IPTR) sizeof(struct fakefb_data) },
1689         {TAG_DONE               , 0UL                               }
1690     };
1691
1692     OOP_Class *cl = NULL;
1693
1694     if (MetaAttrBase)
1695     {
1696         cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
1697         if (NULL != cl)
1698             cl->UserData = GfxBase;
1699     } /* if(MetaAttrBase) */
1700
1701     return cl;
1702 }
1703
1704 OOP_Object *init_fakegfxhidd(OOP_Object *gfxhidd, struct GfxBase *GfxBase)
1705 {
1706     struct common_driverdata *csd = CDD(GfxBase);
1707
1708     if (!csd->fakegfxclass)
1709     {
1710         /* Lazy class initialization */
1711         csd->fakegfxclass       = init_fakegfxhiddclass(GfxBase);
1712         csd->fakefbclass        = init_fakefbclass(GfxBase);
1713
1714         if (!csd->fakegfxclass || !csd->fakefbclass)
1715         {
1716             cleanup_fakegfxhidd(GfxBase);
1717             return NULL;
1718         }
1719
1720     }
1721
1722     return OOP_NewObjectTags(csd->fakegfxclass, NULL, aHidd_FakeGfxHidd_RealGfxHidd, gfxhidd, TAG_DONE);
1723 }
1724
1725 VOID cleanup_fakegfxhidd(struct GfxBase *GfxBase)
1726 {
1727     struct common_driverdata *csd = CDD(GfxBase);
1728
1729     if (NULL != csd->fakefbclass)
1730     {
1731         OOP_DisposeObject((OOP_Object *)csd->fakefbclass);
1732         csd->fakefbclass = NULL;
1733     }
1734
1735     if (NULL != csd->fakegfxclass)
1736     {
1737         OOP_DisposeObject((OOP_Object *)csd->fakegfxclass);
1738         OOP_ReleaseAttrBase(IID_Hidd_FakeFB);
1739         csd->fakegfxclass = NULL;
1740     }
1741 }