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 ULONG gfx_showviewports(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 688 {
 689     /* Composition is not supported here */
 690     return FALSE;
 691 }
 692
 693 static BOOL gfx_getmaxspritesize(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_GetMaxSpriteSize *msg)
 694 {
 695     if (msg->Type & (vHidd_SpriteType_3Plus1|vHidd_SpriteType_DirectColor)) {
 696         /* I hope these values are enough for everyone :) */
 697         *msg->Width  = 65535;
 698         *msg->Height = 65535;
 699
 700         return TRUE;
 701     } else
 702         return FALSE;
 703 }
 704
 705 static IPTR gfx_fwd(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 706 {
 707     struct gfx_data *data;
 708
 709     data = OOP_INST_DATA(cl, o);
 710
 711     return OOP_DoMethod(data->gfxhidd, msg);
 712 }
 713
 714 /* Private non-virtual method */
 715 static BOOL FakeGfx_UpdateFrameBuffer(OOP_Object *o)
 716 {
 717     OOP_Class *cl = OOP_OCLASS(o);
 718     struct gfx_data *data = OOP_INST_DATA(cl, o);
 719     BOOL ok;
 720
 721     LFB(data);
 722
 723     OOP_GetAttr(data->framebuffer, aHidd_BitMap_Width, &data->fb_width);
 724     OOP_GetAttr(data->framebuffer, aHidd_BitMap_Height, &data->fb_height);
 725
 726     DCURS(bug("[FakeGfx] Changed framebuffer size: %u x %u\n", data->fb_width, data->fb_height));
 727
 728     ok = rethink_cursor(data, GfxBase);
 729     UFB(data);
 730
 731     draw_cursor(data, TRUE, TRUE, GfxBase);
 732     return ok;
 733 }
 734
 735 struct fakefb_data
 736 {
 737     OOP_Object *framebuffer;
 738     OOP_Object *fakegfxhidd;
 739 };
 740
 741 #define FGH(data) ((struct gfx_data *)data->fakegfxhidd)
 742 #define REMOVE_CURSOR(data)     \
 743         draw_cursor(FGH(data), FALSE, FALSE, GfxBase)
 744
 745 #define RENDER_CURSOR(data)     \
 746         draw_cursor(FGH(data), TRUE, FALSE, GfxBase)
 747
 748
 749 #define BITMAP_METHOD_INIT      \
 750     struct fakefb_data *data;   \
 751     BOOL inside = FALSE;        \
 752     IPTR retval;                \
 753     struct gfx_data *fgh;       \
 754     data = OOP_INST_DATA(cl, o);        \
 755     fgh = FGH(data);            \
 756 LFB(fgh);
 757
 758 #define FORWARD_METHOD                  \
 759     retval = OOP_DoMethod(data->framebuffer, (OOP_Msg)msg);
 760
 761 #define BITMAP_METHOD_EXIT      \
 762     if (inside) {               \
 763         RENDER_CURSOR(data);    \
 764     }                           \
 765 UFB(fgh);                       \
 766     return retval;
 767
 768 static OOP_Object *fakefb_new(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
 769 {
 770     OOP_Object *framebuffer;
 771     OOP_Object *fakegfxhidd;
 772
 773     framebuffer = (OOP_Object *)GetTagData(aHidd_FakeFB_RealBitMap,     0, msg->attrList);
 774     fakegfxhidd = (OOP_Object *)GetTagData(aHidd_FakeFB_FakeGfxHidd,    0, msg->attrList);
 775
 776     if (NULL == framebuffer || NULL == fakegfxhidd)
 777     {
 778         D(bug("!!! FakeBM::New(): MISSING FRAMEBUFFER OR FAKE GFX HIDD !!!\n"));
 779         return NULL;
 780     }
 781
 782     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 783     if (NULL != o)
 784     {
 785         struct fakefb_data *data;
 786         data = OOP_INST_DATA(cl, o);
 787         data->framebuffer = framebuffer;
 788         data->fakegfxhidd = fakegfxhidd;
 789     }
 790     return o;
 791 }
 792
 793 static VOID fakefb_dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 794 {
 795     struct fakefb_data *data;
 796     data = OOP_INST_DATA(cl, o);
 797     if (NULL != data->framebuffer)
 798     {
 799         OOP_DisposeObject(data->framebuffer);
 800         data->framebuffer = NULL;
 801     }
 802 }
 803
 804 static void fakefb_get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 805 {
 806     struct fakefb_data *data = OOP_INST_DATA(cl, o);
 807
 808     if (msg->attrID == aHidd_FakeFB_RealBitMap)
 809     {
 810         *msg->storage = (IPTR)data->framebuffer;
 811         return;
 812     }
 813     else if (msg->attrID == aHidd_BitMap_GfxHidd)
 814     {
 815         *msg->storage = (IPTR)data->fakegfxhidd;
 816         return;
 817     }
 818     else
 819         OOP_DoMethod(data->framebuffer, (OOP_Msg)msg);
 820 }
 821
 822 /* Intercept framebuffer mode change */
 823 static IPTR fakefb_set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
 824 {
 825     struct fakefb_data *data = OOP_INST_DATA(cl, o);
 826     IPTR ret = OOP_DoMethod(data->framebuffer, &msg->mID);
 827     struct TagItem *modeid = FindTagItem(aHidd_BitMap_ModeID, msg->attrList);
 828
 829     if (modeid && ret)
 830     {
 831         /* Framebuffer mode change succeeded. Update fakegfx' information */
 832         ret = FakeGfx_UpdateFrameBuffer(data->fakegfxhidd);
 833     }
 834
 835     return ret;
 836 }
 837
 838 static IPTR fakefb_getpixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetPixel *msg)
 839 {
 840     BITMAP_METHOD_INIT
 841
 842     if (PIXEL_INSIDE(fgh, msg->x, msg->y))
 843     {
 844         REMOVE_CURSOR(data);
 845         inside = TRUE;
 846     }
 847
 848     FORWARD_METHOD
 849
 850     BITMAP_METHOD_EXIT
 851 }
 852
 853 static IPTR fakefb_putpixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPixel *msg)
 854 {
 855     BITMAP_METHOD_INIT
 856
 857     if (PIXEL_INSIDE(fgh, msg->x, msg->y))
 858     {
 859         REMOVE_CURSOR(data);
 860         inside = TRUE;
 861     }
 862
 863     FORWARD_METHOD
 864
 865     BITMAP_METHOD_EXIT
 866 }
 867
 868 static IPTR fakefb_drawpixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPixel *msg)
 869 {
 870     BITMAP_METHOD_INIT
 871
 872     if (PIXEL_INSIDE(fgh, msg->x, msg->y))
 873     {
 874         REMOVE_CURSOR(data);
 875         inside = TRUE;
 876     }
 877
 878     FORWARD_METHOD
 879
 880     BITMAP_METHOD_EXIT
 881 }
 882
 883 static IPTR fakefb_drawline(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawLine *msg)
 884 {
 885     register LONG x1, y1, x2, y2;
 886     BITMAP_METHOD_INIT
 887
 888     if (msg->x1 < msg->x2)
 889     {
 890         x1 = msg->x1; x2 = msg->x2;
 891     }
 892     else
 893     {
 894         x2 = msg->x1; x1 = msg->x2;
 895     }
 896
 897     if (msg->y1 < msg->y2)
 898     {
 899         y1 = msg->y1; y2 = msg->y2;
 900     }
 901     else
 902     {
 903         y2 = msg->y1; y1 = msg->y2;
 904     }
 905
 906     /* FIXME: Maybe do some more intelligent checking for DrawLine */
 907     if (RECT_INSIDE(fgh, x1, y1, x2, y2))
 908     {
 909         REMOVE_CURSOR(data);
 910         inside = TRUE;
 911     }
 912
 913     FORWARD_METHOD
 914
 915     BITMAP_METHOD_EXIT
 916 }
 917
 918 static IPTR fakefb_getimage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
 919 {
 920     BITMAP_METHOD_INIT
 921
 922     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 923     {
 924         REMOVE_CURSOR(data);
 925         inside = TRUE;
 926     }
 927
 928     FORWARD_METHOD
 929
 930     BITMAP_METHOD_EXIT
 931 }
 932
 933 static IPTR fakefb_putimage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImage *msg)
 934 {
 935     BITMAP_METHOD_INIT
 936
 937     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 938     {
 939         REMOVE_CURSOR(data);
 940         inside = TRUE;
 941     }
 942
 943     FORWARD_METHOD
 944
 945     BITMAP_METHOD_EXIT
 946 }
 947
 948 static IPTR fakefb_putalphaimage(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutAlphaImage *msg)
 949 {
 950     BITMAP_METHOD_INIT
 951
 952     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 953     {
 954         REMOVE_CURSOR(data);
 955         inside = TRUE;
 956     }
 957
 958     FORWARD_METHOD
 959
 960     BITMAP_METHOD_EXIT
 961 }
 962
 963 static IPTR fakefb_puttemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
 964 {
 965     BITMAP_METHOD_INIT
 966
 967     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 968     {
 969         REMOVE_CURSOR(data);
 970         inside = TRUE;
 971     }
 972
 973     FORWARD_METHOD
 974
 975     BITMAP_METHOD_EXIT
 976 }
 977
 978 static IPTR fakefb_putalphatemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutAlphaTemplate *msg)
 979 {
 980     BITMAP_METHOD_INIT
 981
 982     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 983     {
 984         REMOVE_CURSOR(data);
 985         inside = TRUE;
 986     }
 987
 988     FORWARD_METHOD
 989
 990     BITMAP_METHOD_EXIT
 991 }
 992
 993 static IPTR fakefb_putpattern(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPattern *msg)
 994 {
 995     BITMAP_METHOD_INIT
 996
 997     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
 998     {
 999         REMOVE_CURSOR(data);
1000         inside = TRUE;
1001     }
1002
1003     FORWARD_METHOD
1004
1005     BITMAP_METHOD_EXIT
1006 }
1007
1008 static IPTR fakefb_getimagelut(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImageLUT *msg)
1009 {
1010     BITMAP_METHOD_INIT
1011
1012     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1013     {
1014         REMOVE_CURSOR(data);
1015         inside = TRUE;
1016     }
1017
1018     FORWARD_METHOD
1019
1020     BITMAP_METHOD_EXIT
1021 }
1022
1023 static IPTR fakefb_putimagelut(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImageLUT *msg)
1024 {
1025     BITMAP_METHOD_INIT
1026
1027     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1028     {
1029         REMOVE_CURSOR(data);
1030         inside = TRUE;
1031     }
1032
1033     FORWARD_METHOD
1034
1035     BITMAP_METHOD_EXIT
1036 }
1037
1038 static IPTR fakefb_puttranspimagelut(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTranspImageLUT *msg)
1039 {
1040     BITMAP_METHOD_INIT
1041
1042     if (WRECT_INSIDE(fgh, msg->x, msg->y, msg->width, msg->height))
1043     {
1044         REMOVE_CURSOR(data);
1045         inside = TRUE;
1046     }
1047
1048     FORWARD_METHOD
1049
1050     BITMAP_METHOD_EXIT
1051 }
1052
1053 static IPTR fakefb_drawrect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
1054 {
1055     BITMAP_METHOD_INIT
1056
1057     /* FIXME: Maybe do something clever here to see if the rectangle is drawn around the cursor     */
1058     if (RECT_INSIDE(fgh, msg->minX, msg->minY, msg->maxX, msg->maxY))
1059     {
1060         REMOVE_CURSOR(data);
1061         inside = TRUE;
1062     }
1063
1064     FORWARD_METHOD
1065
1066     BITMAP_METHOD_EXIT
1067 }
1068
1069 static IPTR fakefb_fillrect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
1070 {
1071     BITMAP_METHOD_INIT
1072
1073  /* bug("BITMAP FILLRECT(%d, %d, %d, %d), (%d, %d, %d, %d, %d, %d)\n"
1074         , msg->minX, msg->minY, msg->maxX, msg->maxY
1075         , fgh->curs_x, fgh->curs_y, fgh->curs_maxx, fgh->curs_maxy
1076         , fgh->curs_width, fgh->curs_height);
1077 */
1078     if (RECT_INSIDE(fgh, msg->minX, msg->minY, msg->maxX, msg->maxY))
1079     {
1080 /*  bug("FILLRECT: REMOVING CURSOR\n");
1081 */
1082         REMOVE_CURSOR(data);
1083
1084         inside = TRUE;
1085     }
1086
1087     FORWARD_METHOD
1088
1089     BITMAP_METHOD_EXIT
1090 }
1091
1092 static IPTR fakefb_drawellipse(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawEllipse *msg)
1093 {
1094     register LONG x1, y1, x2, y2;
1095     BITMAP_METHOD_INIT
1096
1097     x1 = msg->x - msg->rx;
1098     y1 = msg->y - msg->ry;
1099     x2 = msg->x + msg->rx;
1100     y2 = msg->y + msg->ry;
1101     /* FIXME: Maybe do something clever here to see if the rectangle is drawn around the cursor     */
1102
1103     if (RECT_INSIDE(fgh, x1, y1, x2, y2))
1104     {
1105         REMOVE_CURSOR(data);
1106         inside = TRUE;
1107     }
1108
1109     FORWARD_METHOD
1110
1111     BITMAP_METHOD_EXIT
1112 }
1113
1114 static IPTR fakefb_fillellipse(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawEllipse *msg)
1115 {
1116     register LONG x1, y1, x2, y2;
1117     BITMAP_METHOD_INIT
1118
1119     x1 = msg->x - msg->rx;
1120     y1 = msg->y - msg->ry;
1121     x2 = msg->x + msg->rx;
1122     y2 = msg->y + msg->ry;
1123
1124     if (RECT_INSIDE(fgh, x1, y1, x2, y2))
1125     {
1126         REMOVE_CURSOR(data);
1127         inside = TRUE;
1128     }
1129
1130     FORWARD_METHOD
1131
1132     BITMAP_METHOD_EXIT
1133 }
1134
1135 static IPTR fakefb_drawpolygon(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPolygon *msg)
1136 {
1137     BITMAP_METHOD_INIT
1138     /* FIXME: Maybe do checking here, but it probably is not worth it     */
1139     REMOVE_CURSOR(data);
1140     inside = TRUE;
1141
1142     FORWARD_METHOD
1143
1144     BITMAP_METHOD_EXIT
1145 }
1146
1147 static IPTR fakefb_fillpolygon(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPolygon *msg)
1148 {
1149     BITMAP_METHOD_INIT
1150     /* FIXME: Maybe do checking here, but it probably is not worth it     */
1151     REMOVE_CURSOR(data);
1152     inside = TRUE;
1153
1154     FORWARD_METHOD
1155
1156     BITMAP_METHOD_EXIT
1157 }
1158
1159
1160 static IPTR fakefb_drawtext(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawText *msg)
1161 {
1162     BITMAP_METHOD_INIT
1163
1164     /* FIXME: Maybe do testing here, but probably not wirth it     */
1165     REMOVE_CURSOR(data);
1166
1167     FORWARD_METHOD
1168
1169     BITMAP_METHOD_EXIT
1170 }
1171
1172 static IPTR fakefb_drawfilltext(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawText *msg)
1173 {
1174     BITMAP_METHOD_INIT
1175
1176     /* FIXME: Maybe do testing here, but probably not worth it     */
1177     REMOVE_CURSOR(data);
1178
1179     FORWARD_METHOD
1180
1181     BITMAP_METHOD_EXIT
1182 }
1183
1184 static IPTR fakefb_blitcolexp(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BlitColorExpansion *msg)
1185 {
1186     BITMAP_METHOD_INIT
1187
1188     if (WRECT_INSIDE(fgh, msg->destX, msg->destY, msg->width, msg->height))
1189     {
1190         REMOVE_CURSOR(data);
1191         inside = TRUE;
1192     }
1193
1194     FORWARD_METHOD
1195
1196     BITMAP_METHOD_EXIT
1197 }
1198
1199 static IPTR fakefb_clear(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_Clear *msg)
1200 {
1201     BITMAP_METHOD_INIT
1202
1203     inside = TRUE;
1204
1205     FORWARD_METHOD
1206
1207     BITMAP_METHOD_EXIT
1208 }
1209
1210
1211 static IPTR fakefb_fillspan(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
1212 {
1213     BITMAP_METHOD_INIT
1214
1215     REMOVE_CURSOR(data);
1216     inside = TRUE;
1217
1218     FORWARD_METHOD
1219
1220     BITMAP_METHOD_EXIT
1221 }
1222
1223 static IPTR fakefb_scale(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BitMapScale *msg)
1224 {
1225     /* FIXME: should check both source and destination, similar to gfx_copybox() */
1226     BITMAP_METHOD_INIT
1227
1228     if (WRECT_INSIDE(fgh, msg->bsa->bsa_SrcX, msg->bsa->bsa_SrcY, msg->bsa->bsa_SrcWidth, msg->bsa->bsa_SrcHeight))
1229     {
1230         REMOVE_CURSOR(data);
1231         inside = TRUE;
1232     }
1233
1234     FORWARD_METHOD
1235
1236     BITMAP_METHOD_EXIT
1237 }
1238
1239 static IPTR fakefb_fwd(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
1240 {
1241     struct fakefb_data *data;
1242     data = OOP_INST_DATA(cl, o);
1243 // kill(getpid(), 19);
1244 // bug("BITMAP_FWD\n");
1245     return OOP_DoMethod(data->framebuffer, msg);
1246 }
1247
1248 #undef GfxBase
1249
1250 static BOOL rethink_cursor(struct gfx_data *data, struct GfxBase *GfxBase)
1251 {
1252     OOP_Object *pf, *cmap;
1253     IPTR        fbdepth, curdepth, i;
1254     UWORD       curs_base = 16;
1255
1256     struct TagItem bmtags[] = {
1257         { aHidd_BitMap_Width , data->curs_width       },
1258         { aHidd_BitMap_Height, data->curs_height      },
1259         { aHidd_BitMap_Friend, (IPTR)data->framebuffer},
1260         { TAG_DONE           , 0UL                     }
1261     };
1262
1263     D(bug("rethink_cursor(), curs_bm is 0x%p, framebuffer is 0x%p\n", data->curs_bm, data->framebuffer));
1264
1265     /* The first thing we do is recreating a backup bitmap. We do it every time when either
1266        cursor shape changes (because new shape may have different size) or shown bitmap
1267        changes (because new bitmap may have different depth). Note that even real framebuffer
1268        object may dynamically change its characteristics.
1269
1270        Delete the old backup bitmap first */
1271     if (NULL != data->curs_backup) {
1272         OOP_DisposeObject(data->curs_backup);
1273         D(bug("[FakeGfx] Disposed old backup bitmap\n"));
1274         data->curs_backup = NULL;
1275     }
1276
1277     /* If we have no cursor, we have nothing more to do.
1278        We also don't need new backup bitmap */
1279     if (!data->curs_bm)
1280         return TRUE;
1281
1282     /* We may also have no framebuffer (empty display on
1283        non-framebuffer driver). Also NOP in this case */
1284     if (!data->framebuffer)
1285         return TRUE;
1286
1287     /* Create new backup bitmap */
1288     data->curs_backup = HIDD_Gfx_NewBitMap(data->gfxhidd, bmtags);
1289     D(bug("[FakeGfx] New backup bitmap is 0x%p\n", data->curs_backup));
1290     if (!data->curs_backup)
1291         return FALSE;
1292
1293     OOP_GetAttr(data->framebuffer, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1294     D(bug("[FakeGfx] Framebuffer pixelformat 0x%p\n", pf));
1295     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &fbdepth);
1296     D(bug("[FakeGfx] Framebuffer depth %u\n", fbdepth));
1297     OOP_GetAttr(data->curs_bm, aHidd_BitMap_ColorMap, (IPTR *)&cmap);
1298     D(bug("[FakeGfx] Cursor colormap 0x%p\n", cmap));
1299     OOP_GetAttr(data->curs_bm, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1300     D(bug("[FakeGfx] Cursor pixelformat 0x%p\n", pf));
1301     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &curdepth);
1302     D(bug("[FakeGfx] Cursor depth %u\n", curdepth));
1303
1304 #ifndef DISABLE_ARGB_POINTER
1305     /* We can get ARGB data from the pointer bitmap only
1306        on one of two cases:
1307        1) Pointer bitmap has more than 256 colors, in this case it
1308           stores ARGB data in itself.
1309        2) Pointer bitmap is a LUT bitmap with a colormap attached.
1310           In this case colormap should contain ARGB values for actual
1311           colors.
1312        Of course having ARGB data makes sense only on truecolor screens. */
1313     if ((fbdepth > 8) && ((curdepth > 8) || cmap)) {
1314         data->curs_pixfmt = vHidd_StdPixFmt_ARGB32;
1315         data->curs_bpp    = 4;
1316     } else
1317 #endif
1318     {
1319         data->curs_pixfmt = vHidd_StdPixFmt_LUT8;
1320         data->curs_bpp    = 1;
1321         /* TODO: curs_base should be somehow synchronised with SpriteBase field of ColorMap */
1322         curs_base = (fbdepth > 4) ? 16 : (1 << fbdepth) - 8;
1323     }
1324     /* If we have some good bitmap->bitmap blitting function with alpha channel support,
1325        we would not need this extra buffer and conversion for truecolor screens. */
1326     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);
1327     D(bug("[FakeGfx] Obtained cursor sprite data @ 0x%p\n", data->curs_pixels));
1328
1329     if (data->curs_pixfmt == vHidd_StdPixFmt_LUT8)
1330     {
1331         for (i = 0; i < data->curs_width * data->curs_height; i++)
1332         {
1333             if (data->curs_pixels[i])
1334                 data->curs_pixels[i] += curs_base;
1335         }
1336     }
1337     return TRUE;
1338 }
1339
1340 static VOID draw_cursor(struct gfx_data *data, BOOL draw, BOOL updaterect, struct GfxBase *GfxBase)
1341 {
1342     LONG width, height;
1343     LONG fbwidth, fbheight;
1344     LONG x, y;
1345     LONG w2end, h2end;
1346     ULONG xoffset = 0;
1347     ULONG yoffset = 0;
1348
1349     struct TagItem gctags[] =
1350     {
1351         { aHidd_GC_DrawMode , vHidd_GC_DrawMode_Copy    },
1352         { TAG_DONE          , 0UL                       }
1353     };
1354
1355     if (!data->curs_on)
1356         return;
1357
1358     if (NULL == data->curs_bm || NULL == data->framebuffer)
1359     {
1360         DB2(bug("!!! draw_cursor: FAKE GFX HIDD NOT PROPERLY INITIALIZED !!!\n"));
1361         DB2(bug("CURS BM: 0x%p, FB: 0x%p\n", data->curs_bm, data->framebuffer));
1362         return;
1363     }
1364
1365     fbwidth  = data->fb_width;
1366     fbheight = data->fb_height;
1367     width    = data->curs_width;
1368     height   = data->curs_height;
1369     x        = data->curs_x;
1370     y        = data->curs_y;
1371
1372     /* Do nothing if sprite went outside of bitmap */
1373     if ((x < -width) || (y < -height)) {
1374         DCURS(bug("[FakeGfx] Cursor is beyond left or top edge\n"));
1375         return;
1376     }
1377     if ((x >= fbwidth) || (y >= fbheight)) {
1378         DCURS(bug("[FakeGfx] Cursor is beyond right or bottom edge\n"));
1379         return;
1380     }
1381
1382     /* Do some clipping */
1383     if (x < 0) {
1384         xoffset = -x;
1385         width += x;
1386         x = 0;
1387     }
1388
1389     if (y < 0) {
1390         yoffset = -y;
1391         height += y;
1392         y = 0;
1393     }
1394
1395     w2end = data->fb_width - width;
1396     h2end = data->fb_height - height;
1397
1398     if (x > w2end)
1399     {
1400         width -= (x - w2end);
1401         DCLIP(bug("[FakeGfx] Clipped sprite width to %d\n", width));
1402     }
1403
1404     if (y > h2end)
1405     {
1406         height -= (y - h2end);
1407         DCLIP(bug("[FakeGfx] Clipped sprite height to %d\n", height));
1408     }
1409
1410     /* FIXME: clip negative coordinates */
1411
1412     OOP_SetAttrs(data->gc, gctags);
1413
1414     if (draw)
1415     {
1416         /* Calculate origin of sprite image according to offsets */
1417         ULONG modulo = data->curs_width * data->curs_bpp;
1418         UBYTE *pixels = data->curs_pixels + yoffset * modulo + xoffset * data->curs_bpp;
1419
1420         /* Backup under the new cursor image */
1421         // bug("BACKING UP RENDERED AREA\n");
1422         HIDD_Gfx_CopyBox(data->gfxhidd
1423             , data->framebuffer
1424             , x, y
1425             , data->curs_backup
1426             , 0, 0
1427             , width, height
1428             , data->gc
1429         );
1430
1431         data->backup_done = TRUE;
1432
1433         DB2(bug("[FakeGfx] Rendering cursor, framebuffer 0x%p\n", data->framebuffer));
1434         /* Render the cursor image */
1435         if (data->curs_pixfmt == vHidd_StdPixFmt_ARGB32)
1436             HIDD_BM_PutAlphaImage(data->framebuffer, data->gc, pixels, modulo, x, y, width, height);
1437         else
1438             /* data->curs_bpp is always 1 here so we safely ignore it */
1439             HIDD_BM_PutTranspImageLUT(data->framebuffer, data->gc, pixels, modulo, x, y, width, height, NULL, 0);
1440
1441         if (updaterect)
1442             HIDD_BM_UpdateRect(data->framebuffer, x, y, width, height);
1443
1444     }
1445     else
1446     {
1447         /* Erase the old cursor image */
1448         if (data->backup_done)
1449         {
1450             DB2(bug("[FakeGfx] Restoring cursor area, framebuffer 0x%p\n", data->framebuffer));
1451             HIDD_Gfx_CopyBox(data->gfxhidd
1452                 , data->curs_backup
1453                 , 0, 0
1454                 , data->framebuffer
1455                 , x, y
1456                 , width, height
1457                 , data->gc
1458             );
1459
1460             if (updaterect)
1461                 HIDD_BM_UpdateRect(data->framebuffer, x, y, width, height);
1462         }
1463     }
1464     return;
1465 }
1466
1467 static void gfx_setFrameBuffer(struct GfxBase *GfxBase, struct gfx_data *data, OOP_Object *fb)
1468 {
1469     data->framebuffer = fb;
1470
1471     if (fb)
1472     {
1473         /* Cache framebuffer size, needed by sprite rendering routine */
1474         OOP_GetAttr(fb, aHidd_BitMap_Width, &data->fb_width);
1475         OOP_GetAttr(fb, aHidd_BitMap_Height, &data->fb_height);
1476
1477         DCURS(bug("[FakeGfx] Framebuffer size: %u x %u\n", data->fb_width, data->fb_height));
1478     }
1479 }
1480
1481 static OOP_Object *create_fake_fb(OOP_Object *framebuffer, struct gfx_data *data, struct GfxBase *GfxBase)
1482 {
1483     OOP_Object *fakebm;
1484     struct TagItem fakebmtags[] =
1485     {
1486         { aHidd_FakeFB_RealBitMap   , (IPTR)framebuffer },
1487         { aHidd_FakeFB_FakeGfxHidd  , (IPTR)data        },
1488         { TAG_DONE                  , 0UL               }
1489     };
1490
1491     /* If we work with framebuffer-based driver, Show() will never be called on
1492        a fakefb object so we remember it right now */
1493     fakebm = OOP_NewObject(CDD(GfxBase)->fakefbclass, NULL, fakebmtags);
1494
1495     if (data->fakefb_attr == aHidd_BitMap_FrameBuffer)
1496     {
1497         data->fakefb      = fakebm;
1498         gfx_setFrameBuffer(GfxBase, data, framebuffer);
1499     }
1500
1501     return fakebm;
1502 }
1503
1504 static OOP_Class *init_fakegfxhiddclass (struct GfxBase *GfxBase)
1505 {
1506     OOP_Class *cl = NULL;
1507
1508     struct OOP_MethodDescr root_descr[num_Root_Methods + 1] =
1509     {
1510         {(IPTR (*)())gfx_new    ,               moRoot_New      },
1511         {(IPTR (*)())gfx_dispose,               moRoot_Dispose  },
1512         {(IPTR (*)())gfx_get    ,               moRoot_Get      },
1513         {(IPTR (*)())gfx_fwd    ,               moRoot_Set      },
1514         { NULL                  , 0UL                           }
1515     };
1516
1517     struct OOP_MethodDescr gfxhidd_descr[num_Hidd_Gfx_Methods + 1] =
1518     {
1519         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NewGC           },
1520         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeGC       },
1521         {(IPTR (*)())gfx_newbitmap         , moHidd_Gfx_NewBitMap       },
1522         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeBitMap   },
1523         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_QueryModeIDs    },
1524         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ReleaseModeIDs  },
1525         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_CheckMode       },
1526         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NextModeID      },
1527         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetMode         },
1528         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetPixFmt       },
1529         {(IPTR (*)())gfx_setcursorshape    , moHidd_Gfx_SetCursorShape  },
1530         {(IPTR (*)())gfx_setcursorpos      , moHidd_Gfx_SetCursorPos    },
1531         {(IPTR (*)())gfx_setcursorvisible  , moHidd_Gfx_SetCursorVisible},
1532         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_SetMode         },
1533         {(IPTR (*)())gfx_show              , moHidd_Gfx_Show            },
1534         {(IPTR (*)())gfx_copybox           , moHidd_Gfx_CopyBox         },
1535         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_ModeProperties  },
1536         {(IPTR (*)())gfx_showviewports     , moHidd_Gfx_ShowViewPorts   },
1537         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetSync         },
1538         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_GetGamma        },
1539         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_SetGamma        },
1540         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_QueryHardware3D },
1541         {(IPTR (*)())gfx_getmaxspritesize  , moHidd_Gfx_GetMaxSpriteSize},
1542         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_NewOverlay      },
1543         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_DisposeOverlay  },
1544         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_MakeViewPort    },
1545         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_CleanViewPort   },
1546         {(IPTR (*)())gfx_fwd               , moHidd_Gfx_PrepareViewPorts},
1547         {(IPTR (*)())gfx_copyboxmasked     , moHidd_Gfx_CopyBoxMasked   },
1548         {NULL                              , 0UL                        }
1549     };
1550
1551     struct OOP_InterfaceDescr ifdescr[] =
1552     {
1553         {root_descr     , IID_Root      , num_Root_Methods      },
1554         {gfxhidd_descr  , IID_Hidd_Gfx  , num_Hidd_Gfx_Methods  },
1555         {NULL           , NULL          , 0                     }
1556     };
1557
1558     OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
1559
1560     struct TagItem tags[] =
1561     {
1562         { aMeta_SuperID         , (IPTR)CLID_Root                   },
1563         { aMeta_InterfaceDescr  , (IPTR)ifdescr                     },
1564         { aMeta_InstSize        , (IPTR)sizeof (struct gfx_data)    },
1565         {TAG_DONE               , 0UL                               }
1566     };
1567
1568
1569     D(bug("INIT FAKEGFXCLASS\n"));
1570
1571     if ((__IHidd_FakeFB = OOP_ObtainAttrBase(IID_Hidd_FakeFB)))
1572     {
1573         cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
1574         if(NULL != cl)
1575         {
1576             D(bug("FAKE GFX CLASS INITED\n"));
1577             cl->UserData = GfxBase;
1578
1579             return cl;
1580         }
1581
1582         OOP_ReleaseAttrBase(IID_Hidd_FakeFB);
1583     }
1584
1585     return NULL;
1586 }
1587
1588 static OOP_Class *init_fakefbclass(struct GfxBase *GfxBase)
1589 {
1590     struct OOP_MethodDescr root_descr[num_Root_Methods + 1] =
1591     {
1592         {(IPTR (*)())fakefb_new    , moRoot_New     },
1593         {(IPTR (*)())fakefb_dispose, moRoot_Dispose },
1594         {(IPTR (*)())fakefb_get    , moRoot_Get     },
1595         {(IPTR (*)())fakefb_set    , moRoot_Set     },
1596         {NULL                      , 0UL            }
1597     };
1598
1599     struct OOP_MethodDescr bitmap_descr[num_Hidd_BitMap_Methods + 1] =
1600     {
1601         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetColors           },
1602         {(IPTR (*)())fakefb_putpixel            , moHidd_BitMap_PutPixel            },
1603         {(IPTR (*)())fakefb_drawpixel           , moHidd_BitMap_DrawPixel           },
1604         {(IPTR (*)())fakefb_putimage            , moHidd_BitMap_PutImage            },
1605         {(IPTR (*)())fakefb_putalphaimage       , moHidd_BitMap_PutAlphaImage       },
1606         {(IPTR (*)())fakefb_puttemplate , moHidd_BitMap_PutTemplate         },
1607         {(IPTR (*)())fakefb_putalphatemplate    , moHidd_BitMap_PutAlphaTemplate    },
1608         {(IPTR (*)())fakefb_putpattern          , moHidd_BitMap_PutPattern          },
1609         {(IPTR (*)())fakefb_getimage            , moHidd_BitMap_GetImage            },
1610         {(IPTR (*)())fakefb_getpixel            , moHidd_BitMap_GetPixel            },
1611         {(IPTR (*)())fakefb_drawline            , moHidd_BitMap_DrawLine            },
1612         {(IPTR (*)())fakefb_drawrect            , moHidd_BitMap_DrawRect            },
1613         {(IPTR (*)())fakefb_fillrect            , moHidd_BitMap_FillRect            },
1614         {(IPTR (*)())fakefb_drawellipse , moHidd_BitMap_DrawEllipse         },
1615         {(IPTR (*)())fakefb_fillellipse , moHidd_BitMap_FillEllipse         },
1616         {(IPTR (*)())fakefb_drawpolygon , moHidd_BitMap_DrawPolygon         },
1617         {(IPTR (*)())fakefb_fillpolygon , moHidd_BitMap_FillPolygon         },
1618         {(IPTR (*)())fakefb_drawtext            , moHidd_BitMap_DrawText            },
1619         {(IPTR (*)())fakefb_drawfilltext        , moHidd_BitMap_FillText            },
1620         {(IPTR (*)())fakefb_fillspan            , moHidd_BitMap_FillSpan            },
1621         {(IPTR (*)())fakefb_clear               , moHidd_BitMap_Clear               },
1622         {(IPTR (*)())fakefb_blitcolexp          , moHidd_BitMap_BlitColorExpansion  },
1623         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_MapColor            },
1624         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_UnmapPixel          },
1625         {(IPTR (*)())fakefb_putimagelut , moHidd_BitMap_PutImageLUT         },
1626         {(IPTR (*)())fakefb_puttranspimagelut   , moHidd_BitMap_PutTranspImageLUT   },
1627         {(IPTR (*)())fakefb_getimagelut , moHidd_BitMap_GetImageLUT         },
1628         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_BytesPerLine        },
1629         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ConvertPixels       },
1630         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect8        },
1631         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect16       },
1632         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect24       },
1633         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_FillMemRect32       },
1634         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_InvertMemRect       },
1635         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox8         },
1636         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox16        },
1637         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox24        },
1638         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyMemBox32        },
1639         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox16     },
1640         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox24     },
1641         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_CopyLUTMemBox32     },
1642         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image8      },
1643         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image16     },
1644         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMem32Image24     },
1645         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image8      },
1646         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image16     },
1647         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_GetMem32Image24     },
1648         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate8     },
1649         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate16    },
1650         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate24    },
1651         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemTemplate32    },
1652         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern8      },
1653         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern16     },
1654         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern24     },
1655         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PutMemPattern32     },
1656         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetColorMap         },
1657         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ObtainDirectAccess  },
1658         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_ReleaseDirectAccess },
1659         {(IPTR (*)())fakefb_scale               , moHidd_BitMap_BitMapScale         },
1660         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_PrivateSet          },
1661         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_SetRGBConversionFunction },
1662         {(IPTR (*)())fakefb_fwd         , moHidd_BitMap_UpdateRect          },
1663         {NULL                                   , 0UL                               }
1664     };
1665
1666     struct OOP_InterfaceDescr ifdescr[] =
1667     {
1668         {root_descr     , IID_Root       , num_Root_Methods         },
1669         {bitmap_descr   , IID_Hidd_BitMap, num_Hidd_BitMap_Methods  },
1670         {NULL           , NULL           , 0                        }
1671     };
1672
1673     OOP_AttrBase MetaAttrBase = OOP_GetAttrBase(IID_Meta);
1674
1675     struct TagItem tags[] =
1676     {
1677         {aMeta_SuperID          , (IPTR) CLID_Root                  },
1678         {aMeta_InterfaceDescr   , (IPTR) ifdescr                    },
1679         {aMeta_InstSize         , (IPTR) sizeof(struct fakefb_data) },
1680         {TAG_DONE               , 0UL                               }
1681     };
1682
1683     OOP_Class *cl = NULL;
1684
1685     if (MetaAttrBase)
1686     {
1687         cl = OOP_NewObject(NULL, CLID_HiddMeta, tags);
1688         if (NULL != cl)
1689             cl->UserData = GfxBase;
1690     } /* if(MetaAttrBase) */
1691
1692     return cl;
1693 }
1694
1695 OOP_Object *init_fakegfxhidd(OOP_Object *gfxhidd, struct GfxBase *GfxBase)
1696 {
1697     struct common_driverdata *csd = CDD(GfxBase);
1698
1699     if (!csd->fakegfxclass)
1700     {
1701         /* Lazy class initialization */
1702         csd->fakegfxclass       = init_fakegfxhiddclass(GfxBase);
1703         csd->fakefbclass        = init_fakefbclass(GfxBase);
1704
1705         if (!csd->fakegfxclass || !csd->fakefbclass)
1706         {
1707             cleanup_fakegfxhidd(GfxBase);
1708             return NULL;
1709         }
1710
1711     }
1712
1713     return OOP_NewObjectTags(csd->fakegfxclass, NULL, aHidd_FakeGfxHidd_RealGfxHidd, gfxhidd, TAG_DONE);
1714 }
1715
1716 VOID cleanup_fakegfxhidd(struct GfxBase *GfxBase)
1717 {
1718     struct common_driverdata *csd = CDD(GfxBase);
1719
1720     if (NULL != csd->fakefbclass)
1721     {
1722         OOP_DisposeObject((OOP_Object *)csd->fakefbclass);
1723         csd->fakefbclass = NULL;
1724     }
1725
1726     if (NULL != csd->fakegfxclass)
1727     {
1728         OOP_DisposeObject((OOP_Object *)csd->fakegfxclass);
1729         OOP_ReleaseAttrBase(IID_Hidd_FakeFB);
1730         csd->fakegfxclass = NULL;
1731     }
1732 }