rom/graphics/fakegfxhidd.c

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