rom/graphics/fakegfxhidd.c

   1 /*
   2     Copyright © 1995-2014, 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
  76 /******************************************************************************/
  77
  78 static void gfx_setFrameBuffer(struct GfxBase *GfxBase, struct gfx_data *data, OOP_Object *fb);
  79 static VOID draw_cursor(struct gfx_data *data, BOOL draw, BOOL updaterect, struct GfxBase *GfxBase);
  80 static BOOL rethink_cursor(struct gfx_data *data, struct GfxBase *GfxBase);
  81 static OOP_Object *create_fake_fb(OOP_Object *framebuffer, struct gfx_data *data, struct GfxBase *GfxBase);
  82
  83 /******************************************************************************/
  84
  85 #if SPECIAL_LOCKING
  86
  87 static void FakeGfxHidd_ObtainSemaphore(struct SignalSemaphore *sigSem, BOOL urgent,
  88                                         struct GfxBase *GfxBase)
  89 {
  90     struct Task *me;
  91
  92     /* Get pointer to current task */
  93     me=SysBase->ThisTask;
  94
  95     /* Arbitrate for the semaphore structure */
  96     Forbid();
  97
  98     /*
  99         ss_QueueCount == -1 indicates that the semaphore is
 100         free, so we increment this straight away. If it then
 101         equals 0, then we are the first to allocate this semaphore.
 102
 103         Note: This will need protection for SMP machines.
 104     */
 105     sigSem->ss_QueueCount++;
 106     if( sigSem->ss_QueueCount == 0 )
 107     {
 108         /* We now own the semaphore. This is quick. */
 109         sigSem->ss_Owner = me;
 110         sigSem->ss_NestCount++;
 111     }
 112
 113     /* The semaphore was in use, but was it by us? */
 114     else if( sigSem->ss_Owner == me )
 115     {
 116         /* Yes, just increase the nesting count */
 117         sigSem->ss_NestCount++;
 118     }
 119
 120     /*
 121         Else, some other task must own it. We have
 122         to set a waiting request here.
 123     */
 124     else
 125     {
 126         /*
 127             We need a node to mark our semaphore request. Lets use some
 128             stack memory.
 129         */
 130         struct SemaphoreRequest sr;
 131         sr.sr_Waiter = me;
 132
 133         /*
 134             Have to clear the signal to make sure that we don't
 135             return immediately. We then add the SemReq to the
 136             waiters list of the semaphore. We were the last to
 137             request, so we must be the last to get the semaphore.
 138         */
 139
 140         AROS_ATOMIC_AND(me->tc_SigRecvd, ~SIGF_SINGLE);
 141
 142         if (urgent)
 143         {
 144             AddHead((struct List *)&sigSem->ss_WaitQueue, (struct Node *)&sr);
 145         }
 146         else
 147         {
 148             AddTail((struct List *)&sigSem->ss_WaitQueue, (struct Node *)&sr);
 149         }
 150
 151         /*
 152             Finally, we simply wait, ReleaseSemaphore() will fill in
 153             who owns the semaphore.
 154         */
 155         Wait(SIGF_SINGLE);
 156     }
 157
 158     /* All Done! */
 159     Permit();
 160
 161 }
 162
 163 /******************************************************************************/
 164
 165 static void FakeGfxHidd_ReleaseSemaphore(struct SignalSemaphore *sigSem,
 166                                          struct GfxBase *GfxBase)
 167 {
 168    /* Protect the semaphore structure from multiple access. */
 169     Forbid();
 170
 171     /* Release one on the nest count */
 172     sigSem->ss_NestCount--;
 173     sigSem->ss_QueueCount--;
 174
 175     if(sigSem->ss_NestCount == 0)
 176     {
 177         /*
 178             There are two cases here. Either we are a shared
 179             semaphore, or not. If we are not, make sure that the
 180             correct Task is calling ReleaseSemaphore()
 181         */
 182
 183         /*
 184             Do not try and wake anything unless there are a number
 185             of tasks waiting. We do both the tests, this is another
 186             opportunity to throw an alert if there is an error.
 187         */
 188         if(
 189             sigSem->ss_QueueCount >= 0
 190          && sigSem->ss_WaitQueue.mlh_Head->mln_Succ != NULL
 191         )
 192         {
 193             struct SemaphoreRequest *sr, *srn;
 194
 195             /*
 196                 Look at the first node, but only to see whether it
 197                 is shared or not.
 198             */
 199             sr = (struct SemaphoreRequest *)sigSem->ss_WaitQueue.mlh_Head;
 200
 201             /*
 202                 A node is shared if the ln_Name/sr_Waiter field is
 203                 odd (ie it has bit 1 set).
 204
 205                 If the sr_Waiter field is != NULL, then this is a
 206                 task waiting, otherwise it is a message.
 207             */
 208             if( ((IPTR)sr->sr_Waiter & SM_SHARED) == SM_SHARED )
 209             {
 210                 /* This is a shared lock, so ss_Owner == NULL */
 211                 sigSem->ss_Owner = NULL;
 212
 213                 /* Go through all the nodes to find the shared ones */
 214                 ForeachNodeSafe(&sigSem->ss_WaitQueue, sr, srn)
 215                 {
 216                     srn = (struct SemaphoreRequest *)sr->sr_Link.mln_Succ;
 217
 218                     if( ((IPTR)sr->sr_Waiter & SM_SHARED) == SM_SHARED )
 219                     {
 220                         Remove((struct Node *)sr);
 221
 222                         /* Clear the bit, and update the owner count */
 223                         sr->sr_Waiter = (APTR)((IPTR)sr->sr_Waiter & ~1);
 224                         sigSem->ss_NestCount++;
 225
 226                         /* This is a task, signal it */
 227                         Signal(sr->sr_Waiter, SIGF_SINGLE);
 228                     }
 229                 }
 230             }
 231
 232             /*  This is an exclusive lock - awaken first node */
 233             else
 234             {
 235                 /* Only awaken the first of the nodes */
 236                 Remove((struct Node *)sr);
 237                 sigSem->ss_NestCount++;
 238
 239                 sigSem->ss_Owner = sr->sr_Waiter;
 240                 Signal(sr->sr_Waiter, SIGF_SINGLE);
 241             }
 242
 243         } /* there are waiters */
 244         /*  Otherwise, there are not tasks waiting. */
 245         else
 246         {
 247             sigSem->ss_Owner = NULL;
 248             sigSem->ss_QueueCount = -1;
 249         }
 250     }
 251     else if(sigSem->ss_NestCount < 0)
 252     {
 253         /*
 254             This can't happen. It means that somebody has released
 255             more times than they have obtained.
 256         */
 257         Alert( AN_SemCorrupt );
 258     }
 259
 260     /* All done. */
 261     Permit();
 262
 263 }
 264
 265 /******************************************************************************/
 266
 267 #define LFB(data)       FakeGfxHidd_ObtainSemaphore(&(data)->fbsema, FALSE, GfxBase)
 268 #define UFB(data)       FakeGfxHidd_ReleaseSemaphore(&(data)->fbsema, GfxBase)
 269 #define LFB_QUICK(data) FakeGfxHidd_ObtainSemaphore(&(data)->fbsema, TRUE, GfxBase)
 270 #define UFB_QUICK(data) FakeGfxHidd_ReleaseSemaphore(&(data)->fbsema, GfxBase)
 271
 272 #else   /* !SPECIAL_LOCKING */
 273
 274 #define LFB(data)       ObtainSemaphore(&(data)->fbsema)
 275 #define UFB(data)       ReleaseSemaphore(&(data)->fbsema)
 276 #define LFB_QUICK(data) ObtainSemaphore(&(data)->fbsema)
 277 #define UFB_QUICK(data) ReleaseSemaphore(&(data)->fbsema)
 278
 279 #endif /* SPECIAL_LOCKING */
 280
 281 /******************************************************************************/
 282
 283 #define GfxBase ((struct GfxBase *)cl->UserData)
 284
 285 static OOP_Object *gfx_new(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 286 {
 287     /* Create a new gfxhid object */
 288     OOP_Object      *realgfxhidd;
 289     struct gfx_data *data;
 290     BOOL             ok = FALSE;
 291
 292     realgfxhidd = (OOP_Object *)GetTagData(aHidd_FakeGfxHidd_RealGfxHidd, (IPTR)NULL, msg->attrList);
 293     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 294     if (NULL == o)
 295         return NULL;
 296
 297     data = OOP_INST_DATA(cl, o);
 298     memset(data, 0, sizeof (*data));
 299     InitSemaphore(&data->fbsema);
 300
 301     /*
 302      * If this is direct framebuffer driver, we draw our
 303      * cursor on framebuffer bitmap.
 304      * Otherwise we draw cursor on displayable bitmaps.
 305      * TODO: Implement separate handling for mirrored framebuffers.
 306      *       In this case we actually don't need to backup pixels
 307      *       behind the sprite, because we can use mirror for this.
 308      */
 309     data->fakefb_attr = (OOP_GET(realgfxhidd, aHidd_Gfx_FrameBufferType) == vHidd_FrameBuffer_Direct) ?
 310                         aHidd_BitMap_FrameBuffer : aHidd_BitMap_Displayable;
 311
 312     data->gfxhidd = realgfxhidd;
 313
 314     if (NULL != data->gfxhidd)
 315     {
 316         struct TagItem gctags[] =
 317         {
 318             { TAG_DONE, 0UL }
 319         };
 320
 321         data->gc = HIDD_Gfx_NewGC(data->gfxhidd, gctags);
 322         if (NULL != data->gc)
 323         {
 324             ok = TRUE;
 325         }
 326     }
 327
 328     if (!ok)
 329     {
 330         OOP_MethodID mid;
 331
 332         mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 333         OOP_CoerceMethod(cl, o, (OOP_Msg)&mid);
 334     }
 335
 336     return o;
 337 }
 338
 339 static VOID gfx_dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 340 {
 341     struct gfx_data *data;
 342
 343     data = OOP_INST_DATA(cl, o);
 344     if (NULL != data->curs_backup)
 345     {
 346         OOP_DisposeObject(data->curs_backup);
 347         data->curs_backup = NULL;
 348     }
 349
 350     if (data->curs_pixels)
 351         FreeMem(data->curs_pixels, data->curs_width * data->curs_height * 4);
 352
 353     if (NULL != data->gc)
 354     {
 355         OOP_DisposeObject(data->gc);
 356         data->gc = NULL;
 357     }
 358 }
 359
 360 static void gfx_get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 361 {
 362     struct gfx_data *data = OOP_INST_DATA(cl, o);
 363
 364     if (msg->attrID == aHidd_Gfx_HWSpriteTypes) {
 365         *msg->storage = vHidd_SpriteType_3Plus1|vHidd_SpriteType_DirectColor;
 366         return;
 367     }
 368
 369     OOP_DoMethod(data->gfxhidd, (OOP_Msg)msg);
 370 }
 371
 372 static OOP_Object *gfx_newbitmap(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NewBitMap *msg)
 373 {
 374     /* Is the user about to create a framebuffer ? */
 375     BOOL             create_fb;
 376     struct gfx_data *data;
 377     OOP_Object      *realfb;
 378     OOP_Object      *ret = NULL;
 379
 380     data = OOP_INST_DATA(cl, o);
 381     create_fb = (BOOL)GetTagData(data->fakefb_attr, FALSE, msg->attrList);
 382
 383     realfb = HIDD_Gfx_NewBitMap(data->gfxhidd, msg->attrList);
 384
 385     if (realfb && create_fb)
 386     {
 387         ret = create_fake_fb(realfb, data, GfxBase);
 388         if (!ret)
 389             OOP_DisposeObject(realfb);
 390     }
 391     else
 392         ret = realfb;
 393
 394     return ret;
 395 }
 396
 397 static BOOL gfx_setcursorshape(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorShape *msg)
 398 {
 399     struct gfx_data *data;
 400     OOP_Object      *shape;
 401     BOOL             ok = TRUE;
 402
 403     data = OOP_INST_DATA(cl, o);
 404     shape = msg->shape;
 405     D(bug("[FakeGfx] SetCursorShape(0x%p)\n", shape));
 406
 407     /* Bitmap changed */
 408     if (NULL == shape)
 409     {
 410         /* Erase the old cursor */
 411         draw_cursor(data, FALSE, TRUE, GfxBase);
 412         data->curs_on = FALSE;
 413         data->curs_bm = NULL;
 414         data->curs_x     = data->curs_y         = 0;
 415         data->curs_maxx  = data->curs_maxy      = 0;
 416         data->curs_width = data->curs_height    = 0;
 417         data->curs_xoffset = 0;
 418         data->curs_yoffset = 0;
 419
 420         if (NULL != data->curs_backup)
 421         {
 422             OOP_DisposeObject(data->curs_backup);
 423             data->curs_backup = NULL;
 424         }
 425         if (data->curs_pixels) {
 426             FreeMem(data->curs_pixels, data->curs_width * data->curs_height * 4);
 427             data->curs_pixels = NULL;
 428         }
 429     }
 430     else
 431     {
 432         IPTR curs_width, curs_height;
 433         APTR new_curs_pixels;
 434         ULONG curs_pixels_len;
 435
 436         OOP_GetAttr(shape, aHidd_BitMap_Width,  &curs_width);
 437         OOP_GetAttr(shape, aHidd_BitMap_Height, &curs_height);
 438
 439         DCURS(bug("[FakeGfx] New cursor size: %lu x %lu, framebuffer 0x%p\n", curs_width, curs_height, data->framebuffer));
 440
 441         /* Create new cursor pixelbuffer. We multiply size by 4 because we want ARGB data
 442            to fit in. */
 443         curs_pixels_len = curs_width * curs_height * 4;
 444         new_curs_pixels = AllocMem(curs_pixels_len, MEMF_ANY|MEMF_CLEAR);
 445         if (!new_curs_pixels)
 446             return FALSE;
 447
 448         LFB(data);
 449
 450         /* Erase the old cursor */
 451         draw_cursor(data, FALSE, TRUE, GfxBase);
 452
 453         /* Now that we have disposed the old image using the old
 454            backup bm, we can install the new image and backup bm before
 455            rendering the new cursor.
 456            Backup bitmap is recreated in rethink_cursor()
 457         */
 458
 459         if (data->curs_pixels)
 460             FreeMem(data->curs_pixels, data->curs_width * data->curs_height * 4);
 461
 462         data->curs_bm     = shape;
 463         data->curs_width  = curs_width;
 464         data->curs_height = curs_height;
 465         data->curs_maxx   = data->curs_x + curs_width  - 1;
 466         data->curs_maxy   = data->curs_y + curs_height - 1;
 467         data->curs_pixels = new_curs_pixels;
 468         data->curs_xoffset = msg->xoffset;
 469         data->curs_yoffset = msg->yoffset;
 470
 471         ok = rethink_cursor(data, GfxBase);
 472         UFB(data);
 473
 474         draw_cursor(data, TRUE, TRUE, GfxBase);
 475     }
 476
 477     return ok;
 478 }
 479
 480 static BOOL gfx_setcursorpos(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorPos *msg)
 481 {
 482     struct gfx_data *data;
 483     IPTR xoffset = 0;
 484     IPTR yoffset = 0;
 485
 486     data = OOP_INST_DATA(cl, o);
 487     DPOS(bug("[FakeGfx] SetCursorPos(%d, %d)\n", msg->x, msg->y));
 488
 489     if (!data->framebuffer)
 490         return TRUE;
 491
 492     /* We draw our cursor on the bitmap, so we have to convert back
 493        from physical to logical coordinates */
 494     OOP_GetAttr(data->framebuffer, aHidd_BitMap_LeftEdge, &xoffset);
 495     OOP_GetAttr(data->framebuffer, aHidd_BitMap_TopEdge, &yoffset);
 496
 497     LFB_QUICK(data);
 498     /* erase the old cursor */
 499     draw_cursor(data, FALSE, TRUE, GfxBase);
 500
 501     data->curs_x = msg->x - xoffset;
 502     data->curs_y = msg->y - yoffset;
 503     /* Shift to the hotspot location */
 504     data->curs_x += data->curs_xoffset;
 505     data->curs_y += data->curs_yoffset;
 506     data->curs_maxx = data->curs_x + data->curs_width  - 1;
 507     data->curs_maxy = data->curs_y + data->curs_height - 1;
 508
 509     draw_cursor(data, TRUE, TRUE, GfxBase);
 510     UFB_QUICK(data);
 511     return TRUE;
 512 }
 513
 514 static VOID gfx_setcursorvisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
 515 {
 516     struct gfx_data *data;
 517
 518     data = OOP_INST_DATA(cl, o);
 519
 520 LFB_QUICK(data);
 521
 522     if (msg->visible)
 523     {
 524         if (!data->curs_on)
 525         {
 526             data->curs_on = TRUE;
 527             draw_cursor(data, TRUE, TRUE, GfxBase);
 528         }
 529     }
 530     else
 531     {
 532         if (data->curs_on)
 533         {
 534             draw_cursor(data, FALSE, TRUE, GfxBase);
 535             data->curs_on = FALSE;
 536         }
 537     }
 538
 539 UFB_QUICK(data);
 540
 541 }
 542
 543 #define PIXEL_INSIDE(fgh, x, y) \
 544         (    ( (x) >= (fgh)->curs_x     )       \
 545           && ( (y) >= (fgh)->curs_y     )       \
 546           && ( (x) <= (fgh)->curs_maxx  )       \
 547           && ( (y) <= (fgh)->curs_maxy  )       )
 548
 549 /* NOTE: x1, y1, x2, y2 MUST be sorted */
 550 #define RECT_INSIDE(fgh, x1, y1, x2, y2)        \
 551         (    ( (x1) <= fgh->curs_maxx   )       \
 552           && ( (x2) >= fgh->curs_x      )       \
 553           && ( (y1) <= fgh->curs_maxy   )       \
 554           && ( (y2) >= fgh->curs_y      )       )
 555
 556 #define WRECT_INSIDE(fgh, x1, y1, width, height)        \
 557         RECT_INSIDE(fgh, x1, y1, (x1) + (width) - 1, (y1) + (height) - 1)
 558
 559 static void gfx_copybox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
 560 {
 561     struct gfx_data *data;
 562     OOP_Object *src = NULL;
 563     OOP_Object *dest = NULL;
 564     BOOL inside = FALSE;
 565
 566     data = OOP_INST_DATA(cl, o);
 567     LFB(data);
 568
 569     /* De-masquerade bitmap objects, every of which can be fakefb object */
 570     OOP_GetAttr(msg->src, aHidd_FakeFB_RealBitMap, (IPTR *)&src);
 571     OOP_GetAttr(msg->dest, aHidd_FakeFB_RealBitMap, (IPTR *)&dest);
 572     if (!src)
 573         src = msg->src;
 574     if (!dest)
 575         dest = msg->dest;
 576
 577     /* FIXME: other bitmap may belong to another instance of fakegfx which can be on
 578               display on another monitor. In this case mouse cursor should be handled also
 579               there. Needs further reengineering. */
 580     if ((msg->src == data->fakefb) && WRECT_INSIDE(data, msg->srcX, msg->srcY, msg->width, msg->height))
 581         inside = TRUE;
 582
 583     if ((msg->dest == data->fakefb) && WRECT_INSIDE(data, msg->destX, msg->destY, msg->width, msg->height))
 584         inside = TRUE;
 585
 586     if (inside)
 587         draw_cursor(data, FALSE, FALSE, GfxBase);
 588
 589     HIDD_Gfx_CopyBox(data->gfxhidd, src, msg->srcX, msg->srcY,
 590                      dest, msg->destX, msg->destY, msg->width, msg->height, msg->gc);
 591
 592     if (inside)
 593         draw_cursor(data, TRUE, FALSE, GfxBase);
 594
 595     UFB(data);
 596 }
 597
 598 static IPTR gfx_copyboxmasked(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBoxMasked *msg)
 599 {
 600     struct gfx_data *data;
 601     OOP_Object *src = NULL;
 602     OOP_Object *dest = NULL;
 603     BOOL inside = FALSE;
 604     BOOL ret;
 605
 606     data = OOP_INST_DATA(cl, o);
 607     LFB(data);
 608
 609     /* De-masquerade bitmap objects, every of which can be fakefb object */
 610     OOP_GetAttr(msg->src, aHidd_FakeFB_RealBitMap, (IPTR *)&src);
 611     OOP_GetAttr(msg->dest, aHidd_FakeFB_RealBitMap, (IPTR *)&dest);
 612     if (!src)
 613         src = msg->src;
 614     if (!dest)
 615         dest = msg->dest;
 616
 617     /*
 618      * FIXME: other bitmap may belong to another instance of fakegfx which can be on
 619      *        display on another monitor. In this case mouse cursor should be handled also
 620      *        there. Needs further reengineering.
 621      */
 622     if ((msg->src == data->fakefb) && WRECT_INSIDE(data, msg->srcX, msg->srcY, msg->width, msg->height))
 623         inside = TRUE;
 624
 625     if ((msg->dest == data->fakefb) && WRECT_INSIDE(data, msg->destX, msg->destY, msg->width, msg->height))
 626         inside = TRUE;
 627
 628     if (inside)
 629         draw_cursor(data, FALSE, FALSE, GfxBase);
 630
 631     ret = HIDD_Gfx_CopyBoxMasked(data->gfxhidd, src, msg->srcX, msg->srcY,
 632                                  dest, msg->destX, msg->destY, msg->width, msg->height, msg->mask, msg->gc);
 633
 634     if (inside)
 635         draw_cursor(data, TRUE, FALSE, GfxBase);
 636
 637     UFB(data);
 638
 639     return ret;
 640 }
 641
 642 static OOP_Object *gfx_show(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_Show *msg)
 643 {
 644     OOP_Object *ret;
 645     struct gfx_data *data;
 646
 647     data = OOP_INST_DATA(cl, o);
 648     ret = msg->bitMap;
 649
 650     D(bug("[FakeGfx] Show(0x%p)\n", ret));
 651
 652     /*
 653      * If we are attempting to show a fake bitmap, we are working
 654      * in NoFrameBuffer mode where each displayable bitmap is
 655      * intercepted by us
 656      */
 657     if (ret && (OOP_OCLASS(ret) == CDD(GfxBase)->fakefbclass))
 658     {
 659         data->fakefb = ret;
 660         OOP_GetAttr(msg->bitMap, aHidd_FakeFB_RealBitMap, (IPTR *)&ret);
 661         D(bug("[FakeGfx] Bitmap is a fakefb object, real bitmap is 0x%p\n", ret));
 662     }
 663
 664     LFB(data);
 665     draw_cursor(data, FALSE, FALSE, GfxBase);
 666
 667     ret = HIDD_Gfx_Show(data->gfxhidd, ret, msg->flags);
 668     D(bug("[FakeGfx] Real framebuffer object 0x%p\n", ret));
 669     gfx_setFrameBuffer(GfxBase, data, ret);
 670     if (NULL != ret)
 671         ret = data->fakefb;
 672     /* FIXME: temporary workaround: at this point Intuition has already destroyed
 673        the sprite image (since the last screen was closed) but we have no information
 674        about it. Perhaps FreeSpriteData() should track this down somehow and inform
 675        drivers about destroyed sprites.
 676     if (!msg->bitMap)
 677         data->curs_bm = NULL;*/
 678     rethink_cursor(data, GfxBase);
 679     draw_cursor(data, TRUE, TRUE, GfxBase);
 680
 681     UFB(data);
 682
 683     D(bug("[FakeGfx] Returning 0x%p\n", ret));
 684     return ret;
 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 - height;
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)
1455                 HIDD_BM_UpdateRect(data->framebuffer, x, y, width, height);
1456         }
1457     }
1458     return;
1459 }
1460
1461 static void gfx_setFrameBuffer(struct GfxBase *GfxBase, struct gfx_data *data, OOP_Object *fb)
1462 {
1463     data->framebuffer = fb;
1464
1465     if (fb)
1466     {
1467         /* Cache framebuffer size, needed by sprite rendering routine */
1468         OOP_GetAttr(fb, aHidd_BitMap_Width, &data->fb_width);
1469         OOP_GetAttr(fb, aHidd_BitMap_Height, &data->fb_height);
1470
1471         DCURS(bug("[FakeGfx] Framebuffer size: %u x %u\n", data->fb_width, data->fb_height));
1472     }
1473 }
1474
1475 static OOP_Object *create_fake_fb(OOP_Object *framebuffer, struct gfx_data *data, struct GfxBase *GfxBase)
1476 {
1477     OOP_Object *fakebm;
1478     struct TagItem fakebmtags[] =
1479     {
1480         { aHidd_FakeFB_RealBitMap   , (IPTR)framebuffer },
1481         { aHidd_FakeFB_FakeGfxHidd  , (IPTR)data        },
1482         { TAG_DONE                  , 0UL               }
1483     };
1484
1485     /* If we work with framebuffer-based driver, Show() will never be called on
1486        a fakefb object so we remember it right now */
1487     fakebm = OOP_NewObject(CDD(GfxBase)->fakefbclass, NULL, fakebmtags);
1488
1489     if (data->fakefb_attr == aHidd_BitMap_FrameBuffer)
1490     {
1491         data->fakefb      = fakebm;
1492         gfx_setFrameBuffer(GfxBase, data, framebuffer);
1493     }
1494
1495     return fakebm;
1496 }
1497
1498 static OOP_Class *init_fakegfxhiddclass (struct GfxBase *GfxBase)
1499 {
1500     OOP_Class *cl = NULL;
1501
1502     struct OOP_MethodDescr root_descr[num_Root_Methods + 1] =
1503     {
1504         {(IPTR (*)())gfx_new    ,               moRoot_New      },
1505         {(IPTR (*)())gfx_dispose,               moRoot_Dispose  },
1506         {(IPTR (*)())gfx_get    ,               moRoot_Get      },
1507         {(IPTR (*)())gfx_fwd    ,               moRoot_Set      },
1508         { NULL                  , 0UL                           }
1509     };
1510
1511     struct OOP_MethodDescr gfxhidd_descr[num_Hidd_Gfx_Methods + 1] =
1512     {
1513         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NewGC           },
1514         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeGC       },
1515         {(IPTR (*)())gfx_newbitmap         , moHidd_Gfx_NewBitMap       },
1516         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeBitMap   },
1517         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_QueryModeIDs    },
1518         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ReleaseModeIDs  },
1519         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_CheckMode       },
1520         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NextModeID      },
1521         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetMode         },
1522         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetPixFmt       },
1523         {(IPTR (*)())gfx_setcursorshape    , moHidd_Gfx_SetCursorShape  },
1524         {(IPTR (*)())gfx_setcursorpos      , moHidd_Gfx_SetCursorPos    },
1525         {(IPTR (*)())gfx_setcursorvisible  , moHidd_Gfx_SetCursorVisible},
1526         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_SetMode         },
1527         {(IPTR (*)())gfx_show              , moHidd_Gfx_Show            },
1528         {(IPTR (*)())gfx_copybox           , moHidd_Gfx_CopyBox         },
1529         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ModeProperties  },
1530         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ShowViewPorts   },
1531         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetSync         },
1532         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetGamma        },
1533         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_SetGamma        },
1534         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_QueryHardware3D },
1535         {(IPTR (*)())gfx_getmaxspritesize  , moHidd_Gfx_GetMaxSpriteSize},
1536         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NewOverlay      },
1537         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeOverlay  },
1538         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_MakeViewPort    },
1539         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_CleanViewPort   },
1540         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_PrepareViewPorts},
1541         {(IPTR (*)())gfx_copyboxmasked     , moHidd_Gfx_CopyBoxMasked   },
1542         {NULL                              , 0UL                        }
1543     };
1544
1545     struct OOP_InterfaceDescr ifdescr[] =
1546     {
1547         {root_descr     , IID_Root      , num_Root_Methods      },
1548         {gfxhidd_descr  , IID_Hidd_Gfx  , num_Hidd_Gfx_Methods  },
1549         {NULL           , NULL          , 0                     }
1550     };
1551
1552     OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
1553
1554     struct TagItem tags[] =
1555     {
1556         { aMeta_SuperID         , (IPTR)CLID_Root                   },
1557         { aMeta_InterfaceDescr  , (IPTR)ifdescr                     },
1558         { aMeta_InstSize        , (IPTR)sizeof (struct gfx_data)    },
1559         {TAG_DONE               , 0UL                               }
1560     };
1561
1562
1563     D(bug("INIT FAKEGFXCLASS\n"));
1564
1565     if ((__IHidd_FakeFB = OOP_ObtainAttrBase(IID_Hidd_FakeFB)))
1566     {
1567         cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
1568         if(NULL != cl)
1569         {
1570             D(bug("FAKE GFX CLASS INITED\n"));
1571             cl->UserData = GfxBase;
1572
1573             return cl;
1574         }
1575
1576         OOP_ReleaseAttrBase(IID_Hidd_FakeFB);
1577     }
1578
1579     return NULL;
1580 }
1581
1582 static OOP_Class *init_fakefbclass(struct GfxBase *GfxBase)
1583 {
1584     struct OOP_MethodDescr root_descr[num_Root_Methods + 1] =
1585     {
1586         {(IPTR (*)())fakefb_new    , moRoot_New     },
1587         {(IPTR (*)())fakefb_dispose, moRoot_Dispose },
1588         {(IPTR (*)())fakefb_get    , moRoot_Get     },
1589         {(IPTR (*)())fakefb_set    , moRoot_Set     },
1590         {NULL                      , 0UL            }
1591     };
1592
1593     struct OOP_MethodDescr bitmap_descr[num_Hidd_BitMap_Methods + 1] =
1594     {
1595         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetColors           },
1596         {(IPTR (*)())fakefb_putpixel            , moHidd_BitMap_PutPixel            },
1597         {(IPTR (*)())fakefb_drawpixel           , moHidd_BitMap_DrawPixel           },
1598         {(IPTR (*)())fakefb_putimage            , moHidd_BitMap_PutImage            },
1599         {(IPTR (*)())fakefb_putalphaimage       , moHidd_BitMap_PutAlphaImage       },
1600         {(IPTR (*)())fakefb_puttemplate , moHidd_BitMap_PutTemplate         },
1601         {(IPTR (*)())fakefb_putalphatemplate    , moHidd_BitMap_PutAlphaTemplate    },
1602         {(IPTR (*)())fakefb_putpattern          , moHidd_BitMap_PutPattern          },
1603         {(IPTR (*)())fakefb_getimage            , moHidd_BitMap_GetImage            },
1604         {(IPTR (*)())fakefb_getpixel            , moHidd_BitMap_GetPixel            },
1605         {(IPTR (*)())fakefb_drawline            , moHidd_BitMap_DrawLine            },
1606         {(IPTR (*)())fakefb_drawrect            , moHidd_BitMap_DrawRect            },
1607         {(IPTR (*)())fakefb_fillrect            , moHidd_BitMap_FillRect            },
1608         {(IPTR (*)())fakefb_drawellipse , moHidd_BitMap_DrawEllipse         },
1609         {(IPTR (*)())fakefb_fillellipse , moHidd_BitMap_FillEllipse         },
1610         {(IPTR (*)())fakefb_drawpolygon , moHidd_BitMap_DrawPolygon         },
1611         {(IPTR (*)())fakefb_fillpolygon , moHidd_BitMap_FillPolygon         },
1612         {(IPTR (*)())fakefb_drawtext            , moHidd_BitMap_DrawText            },
1613         {(IPTR (*)())fakefb_drawfilltext        , moHidd_BitMap_FillText            },
1614         {(IPTR (*)())fakefb_fillspan            , moHidd_BitMap_FillSpan            },
1615         {(IPTR (*)())fakefb_clear               , moHidd_BitMap_Clear               },
1616         {(IPTR (*)())fakefb_blitcolexp          , moHidd_BitMap_BlitColorExpansion  },
1617         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_MapColor            },
1618         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_UnmapPixel          },
1619         {(IPTR (*)())fakefb_putimagelut , moHidd_BitMap_PutImageLUT         },
1620         {(IPTR (*)())fakefb_puttranspimagelut   , moHidd_BitMap_PutTranspImageLUT   },
1621         {(IPTR (*)())fakefb_getimagelut , moHidd_BitMap_GetImageLUT         },
1622         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_BytesPerLine        },
1623         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ConvertPixels       },
1624         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect8        },
1625         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect16       },
1626         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect24       },
1627         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect32       },
1628         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_InvertMemRect       },
1629         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox8         },
1630         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox16        },
1631         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox24        },
1632         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox32        },
1633         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox16     },
1634         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox24     },
1635         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox32     },
1636         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image8      },
1637         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image16     },
1638         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image24     },
1639         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image8      },
1640         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image16     },
1641         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image24     },
1642         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate8     },
1643         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate16    },
1644         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate24    },
1645         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate32    },
1646         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern8      },
1647         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern16     },
1648         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern24     },
1649         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern32     },
1650         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetColorMap         },
1651         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ObtainDirectAccess  },
1652         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ReleaseDirectAccess },
1653         {(IPTR (*)())fakefb_scale               , moHidd_BitMap_BitMapScale         },
1654         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PrivateSet          },
1655         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetRGBConversionFunction },
1656         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_UpdateRect          },
1657         {NULL                                   , 0UL                               }
1658     };
1659
1660     struct OOP_InterfaceDescr ifdescr[] =
1661     {
1662         {root_descr     , IID_Root       , num_Root_Methods         },
1663         {bitmap_descr   , IID_Hidd_BitMap, num_Hidd_BitMap_Methods  },
1664         {NULL           , NULL           , 0                        }
1665     };
1666
1667     OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
1668
1669     struct TagItem tags[] =
1670     {
1671         {aMeta_SuperID          , (IPTR) CLID_Root                  },
1672         {aMeta_InterfaceDescr   , (IPTR) ifdescr                    },
1673         {aMeta_InstSize         , (IPTR) sizeof(struct fakefb_data) },
1674         {TAG_DONE               , 0UL                               }
1675     };
1676
1677     OOP_Class *cl = NULL;
1678
1679     if (MetaAttrBase)
1680     {
1681         cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
1682         if (NULL != cl)
1683             cl->UserData = GfxBase;
1684     } /* if(MetaAttrBase) */
1685
1686     return cl;
1687 }
1688
1689 OOP_Object *init_fakegfxhidd(OOP_Object *gfxhidd, struct GfxBase *GfxBase)
1690 {
1691     struct common_driverdata *csd = CDD(GfxBase);
1692
1693     if (!csd->fakegfxclass)
1694     {
1695         /* Lazy class initialization */
1696         csd->fakegfxclass       = init_fakegfxhiddclass(GfxBase);
1697         csd->fakefbclass        = init_fakefbclass(GfxBase);
1698
1699         if (!csd->fakegfxclass || !csd->fakefbclass)
1700         {
1701             cleanup_fakegfxhidd(GfxBase);
1702             return NULL;
1703         }
1704
1705     }
1706
1707     return OOP_NewObjectTags(csd->fakegfxclass, NULL, aHidd_FakeGfxHidd_RealGfxHidd, gfxhidd, TAG_DONE);
1708 }
1709
1710 VOID cleanup_fakegfxhidd(struct GfxBase *GfxBase)
1711 {
1712     struct common_driverdata *csd = CDD(GfxBase);
1713
1714     if (NULL != csd->fakefbclass)
1715     {
1716         OOP_DisposeObject((OOP_Object *)csd->fakefbclass);
1717         csd->fakefbclass = NULL;
1718     }
1719
1720     if (NULL != csd->fakegfxclass)
1721     {
1722         OOP_DisposeObject((OOP_Object *)csd->fakegfxclass);
1723         OOP_ReleaseAttrBase(IID_Hidd_FakeFB);
1724         csd->fakegfxclass = NULL;
1725     }
1726 }