arch/common/hidd.vmwaresvga/vmwaresvgaclass.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Class for VMWare.
   6     Lang: English.
   7 */
   8
   9 #define DEBUG 0
  10 #include <aros/debug.h>
  11
  12 #define __OOP_NOATTRBASES__
  13
  14 #include <proto/exec.h>
  15 #include <proto/oop.h>
  16 #include <proto/utility.h>
  17 #include <aros/symbolsets.h>
  18 #include <devices/inputevent.h>
  19 #include <exec/alerts.h>
  20 #include <exec/memory.h>
  21 #include <hardware/custom.h>
  22 #include <hidd/hidd.h>
  23 #include <hidd/graphics.h>
  24 #include <oop/oop.h>
  25 #include <clib/alib_protos.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28
  29 #include "vmwaresvgaclass.h"
  30 #include "vmwaresvgabitmap.h"
  31 #include "vmwaresvgahardware.h"
  32
  33 #include LC_LIBDEFS_FILE
  34
  35 static OOP_AttrBase HiddBitMapAttrBase;
  36 static OOP_AttrBase HiddPixFmtAttrBase;
  37 static OOP_AttrBase HiddGfxAttrBase;
  38 static OOP_AttrBase HiddSyncAttrBase;
  39 static OOP_AttrBase HiddVMWareSVGAAttrBase;
  40 static OOP_AttrBase HiddVMWareSVGABitMapAttrBase;
  41
  42 static struct OOP_ABDescr attrbases[] =
  43 {
  44     {IID_Hidd_BitMap,           &HiddBitMapAttrBase             },
  45     {IID_Hidd_VMWareSVGABitMap, &HiddVMWareSVGABitMapAttrBase   },
  46     {IID_Hidd_VMWareSVGA,       &HiddVMWareSVGAAttrBase         },
  47     {IID_Hidd_PixFmt,           &HiddPixFmtAttrBase             },
  48     {IID_Hidd_Sync,             &HiddSyncAttrBase               },
  49     {IID_Hidd_Gfx,              &HiddGfxAttrBase                },
  50     {NULL,                      NULL                            }
  51 };
  52
  53 STATIC ULONG mask_to_shift(ULONG mask)
  54 {
  55     ULONG i;
  56
  57     for (i = 32; mask; i --) {
  58         mask >>= 1;
  59     }
  60
  61     if (mask == 32) {
  62         i = 0;
  63     }
  64
  65     return i;
  66 }
  67
  68 OOP_Object *VMWareSVGA__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  69 {
  70     unsigned int sync_count, sync_modes, sync_curr, sync_displayid, sync_modeid;
  71
  72     struct TagItem pftags[] =
  73     {
  74         {aHidd_PixFmt_RedShift,         0       }, /*  0 */
  75         {aHidd_PixFmt_GreenShift,       0       }, /*  1 */
  76         {aHidd_PixFmt_BlueShift,        0       }, /*  2 */
  77         {aHidd_PixFmt_AlphaShift,       0       }, /*  3 */
  78         {aHidd_PixFmt_RedMask,          0       }, /*  4 */
  79         {aHidd_PixFmt_GreenMask,        0       }, /*  5 */
  80         {aHidd_PixFmt_BlueMask,         0       }, /*  6 */
  81         {aHidd_PixFmt_AlphaMask,        0       }, /*  7 */
  82         {aHidd_PixFmt_ColorModel,       0       }, /*  8 */
  83         {aHidd_PixFmt_Depth,            0       }, /*  9 */
  84         {aHidd_PixFmt_BytesPerPixel,    0       }, /* 10 */
  85         {aHidd_PixFmt_BitsPerPixel,     0       }, /* 11 */
  86         {aHidd_PixFmt_StdPixFmt,        0       }, /* 12 */
  87         {aHidd_PixFmt_CLUTShift,        0       }, /* 13 */
  88         {aHidd_PixFmt_CLUTMask,         0x0f    }, /* 14 */
  89         {aHidd_PixFmt_BitMapType,       0       }, /* 15 */
  90         {TAG_DONE,                      0UL     }
  91     };
  92 #warning "TODO: Probe available sync modes"
  93 #define VMWARESVGA_SYNCMODES   5
  94     sync_modes = VMWARESVGA_SYNCMODES;
  95     sync_count = sync_modes * XSD(cl)->data.displaycount;
  96
  97     struct TagItem *modetags = AllocVec((sync_count + 2) * sizeof(struct TagItem), MEMF_CLEAR);
  98
  99     modetags[0].ti_Tag = aHidd_Gfx_PixFmtTags;
 100     modetags[0].ti_Data = (IPTR)pftags;
 101     modetags[sync_count + 1].ti_Tag = TAG_DONE;
 102
 103     sync_curr = 0;
 104
 105     while (sync_curr < sync_count)
 106     {
 107         sync_modeid = sync_curr % sync_modes;
 108         sync_displayid = sync_curr/sync_modes;
 109
 110         ULONG sync_Width =0;
 111         ULONG sync_Height=0;
 112 D(bug("[VMWareSVGA] %s: Setting Sync Mode %d for Display %d\n", __PRETTY_FUNCTION__, sync_modeid, sync_displayid));
 113
 114         char *sync_Description = AllocVec(24 , MEMF_CLEAR);
 115
 116         switch (sync_modeid)
 117         {
 118             case 1:
 119                 sync_Width =800;
 120                 sync_Height=600;
 121                 break;
 122             case 2:
 123                 sync_Width =1024;
 124                 sync_Height=768;
 125                 break;
 126             case 3:
 127                 sync_Width =1280;
 128                 sync_Height=1024;
 129                 break;
 130             case 4:
 131                 sync_Width =1600;
 132                 sync_Height=1200;
 133                 break;
 134             default:
 135                 sync_Width =640;
 136                 sync_Height=480;
 137                 break;
 138         }
 139
 140         if (sync_displayid == 0)
 141         {
 142             sprintf(sync_Description, "VMWareSVGA:%dx%d", sync_Width, sync_Height);
 143         }
 144         else
 145         {
 146             sprintf(sync_Description, "VMWareSVGA.%d:%dx%d", sync_displayid, sync_Width, sync_Height);
 147         }
 148         D(bug("[VMWareSVGA] %s: Description '%s'\n", __PRETTY_FUNCTION__, sync_Description));
 149
 150         struct TagItem *sync_mode = AllocVec(11 * sizeof(struct TagItem), MEMF_CLEAR);
 151
 152         sync_mode[0].ti_Tag = aHidd_Sync_Description;
 153         sync_mode[0].ti_Data = (IPTR)sync_Description;
 154         sync_mode[1].ti_Tag = aHidd_Sync_PixelClock;
 155         sync_mode[2].ti_Tag = aHidd_Sync_HDisp;
 156         sync_mode[2].ti_Data = sync_Width;
 157         sync_mode[3].ti_Tag = aHidd_Sync_VDisp;
 158         sync_mode[3].ti_Data = sync_Height;
 159         sync_mode[4].ti_Tag = aHidd_Sync_HSyncStart;
 160         sync_mode[5].ti_Tag = aHidd_Sync_HSyncEnd;
 161         sync_mode[6].ti_Tag = aHidd_Sync_HTotal;
 162         sync_mode[7].ti_Tag = aHidd_Sync_VSyncStart;
 163         sync_mode[8].ti_Tag = aHidd_Sync_VSyncEnd;
 164         sync_mode[9].ti_Tag = aHidd_Sync_VTotal;
 165         sync_mode[10].ti_Tag = TAG_DONE;
 166
 167         modetags[1 + sync_curr].ti_Tag = aHidd_Gfx_SyncTags;
 168         modetags[1 + sync_curr].ti_Data = (IPTR)sync_mode;
 169
 170         sync_curr++;
 171     }
 172
 173     struct TagItem yourtags[] =
 174     {
 175         {aHidd_Gfx_ModeTags,    (IPTR)modetags  },
 176         {TAG_MORE,              0UL             }
 177     };
 178     struct pRoot_New yourmsg;
 179
 180     /* set pftags = 0 */
 181     if (!XSD(cl)->data.pseudocolor)
 182     {
 183         pftags[0].ti_Data = mask_to_shift(XSD(cl)->data.redmask);
 184         pftags[1].ti_Data = mask_to_shift(XSD(cl)->data.greenmask);
 185         pftags[2].ti_Data = mask_to_shift(XSD(cl)->data.bluemask);
 186     }
 187     else
 188     {
 189         pftags[0].ti_Data = 0;
 190         pftags[1].ti_Data = 0;
 191         pftags[2].ti_Data = 0;
 192     }
 193     pftags[3].ti_Data = 0;
 194     pftags[4].ti_Data = XSD(cl)->data.redmask;
 195     pftags[5].ti_Data = XSD(cl)->data.greenmask;
 196     pftags[6].ti_Data = XSD(cl)->data.bluemask;
 197     pftags[7].ti_Data = 0;
 198     D(bug("[VMWareSVGA] New: Masks red=%08x<<%d,green=%08x<<%d,blue%08x<<%d\n",
 199             pftags[4].ti_Data, pftags[0].ti_Data,
 200             pftags[5].ti_Data, pftags[1].ti_Data,
 201             pftags[6].ti_Data, pftags[2].ti_Data));
 202
 203     if (XSD(cl)->data.pseudocolor)
 204         pftags[8].ti_Data = vHidd_ColorModel_Palette;
 205     else
 206         pftags[8].ti_Data = vHidd_ColorModel_TrueColor;
 207
 208     pftags[9].ti_Data = XSD(cl)->data.depth;
 209     pftags[10].ti_Data = XSD(cl)->data.bytesperpixel;
 210     pftags[11].ti_Data = XSD(cl)->data.bitsperpixel;
 211     pftags[12].ti_Data = vHidd_StdPixFmt_Native;
 212     pftags[15].ti_Data = vHidd_BitMapType_Chunky;
 213
 214     yourtags[1].ti_Data = (IPTR)msg->attrList;
 215
 216     yourmsg.mID = msg->mID;
 217     yourmsg.attrList = yourtags;
 218     msg = &yourmsg;
 219     EnterFunc(bug("VMWareSVGA::New()\n"));
 220     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 221     if (o)
 222     {
 223         D(bug("[VMWareSVGA] Got object from super\n"));
 224         XSD(cl)->vmwaresvgahidd = o;
 225         XSD(cl)->mouse.shape = NULL;
 226         ReturnPtr("VMWareSVGA::New", OOP_Object *, o);
 227     }
 228     ReturnPtr("VMWareSVGA::New", OOP_Object *, NULL);
 229 }
 230
 231 VOID VMWareSVGA__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 232 {
 233     if (XSD(cl)->mouse.shape != NULL)
 234         FreeVec(XSD(cl)->mouse.shape);
 235     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 236 }
 237
 238 VOID VMWareSVGA__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 239 {
 240     ULONG idx;
 241     BOOL found = FALSE;
 242
 243     if (IS_GFX_ATTR(msg->attrID, idx))
 244     {
 245         switch (idx)
 246         {
 247         case aoHidd_Gfx_SupportsHWCursor:
 248             *msg->storage = (IPTR)TRUE;
 249             found = TRUE;
 250             break;
 251         }
 252     }
 253     if (!found)
 254         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 255 }
 256
 257 OOP_Object *VMWareSVGA__Hidd_Gfx__NewBitMap(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NewBitMap *msg)
 258 {
 259     BOOL displayable;
 260     BOOL framebuffer;
 261     OOP_Class *classptr = NULL;
 262     struct TagItem tags[2];
 263     struct pHidd_Gfx_NewBitMap yourmsg;
 264
 265     EnterFunc(bug("VMWareSVGA::NewBitMap()\n"));
 266     displayable = GetTagData(aHidd_BitMap_Displayable, FALSE, msg->attrList);
 267     framebuffer = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList);
 268     if (framebuffer)
 269         classptr = XSD(cl)->vmwaresvgaonbmclass;
 270     else if (displayable)
 271         classptr = XSD(cl)->vmwaresvgaoffbmclass;
 272     else
 273     {
 274         HIDDT_ModeID modeid;
 275         modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
 276         if (modeid != vHidd_ModeID_Invalid)
 277             classptr = XSD(cl)->vmwaresvgaoffbmclass;
 278         else
 279         {
 280             HIDDT_StdPixFmt stdpf;
 281             stdpf = (HIDDT_StdPixFmt)GetTagData(aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_Unknown, msg->attrList);
 282             if (stdpf == vHidd_StdPixFmt_Unknown)
 283             {
 284                 OOP_Object *friend;
 285                 friend = (OOP_Object *)GetTagData(aHidd_BitMap_Friend, NULL, msg->attrList);
 286                 if (friend != NULL)
 287                 {
 288                     OOP_Object *gfxhidd;
 289                     OOP_GetAttr(friend, aHidd_BitMap_GfxHidd, (IPTR *)&gfxhidd);
 290                     if (gfxhidd == o)
 291                     {
 292                         classptr = XSD(cl)->vmwaresvgaoffbmclass;
 293                     }
 294                 }
 295             }
 296         }
 297     }
 298     if (classptr != NULL)
 299     {
 300         tags[0].ti_Tag = aHidd_BitMap_ClassPtr;
 301         tags[0].ti_Data = (IPTR)classptr;
 302         tags[1].ti_Tag = TAG_MORE;
 303         tags[1].ti_Data = (IPTR)msg->attrList;
 304         yourmsg.mID = msg->mID;
 305         yourmsg.attrList = tags;
 306         msg = &yourmsg;
 307     }
 308     ReturnPtr("VMWareSVGA::NewBitMap", OOP_Object *, (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg));
 309 }
 310
 311 VOID VMWareSVGA__Hidd_Gfx__CopyBox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
 312 {
 313     UBYTE *src = NULL;
 314     UBYTE *dst = NULL;
 315     HIDDT_DrawMode mode;
 316     struct Box box;
 317
 318     EnterFunc(bug("VMWareSVGA.BitMap::CopyBox\n"));
 319     mode = GC_DRMD(msg->gc);
 320     OOP_GetAttr(msg->src, aHidd_VMWareSVGABitMap_Drawable, (IPTR *)&src);
 321     OOP_GetAttr(msg->dest, aHidd_VMWareSVGABitMap_Drawable, (IPTR *)&dst);
 322     if (((dst == NULL) || (src == NULL))) /* no vmwaregfx bitmap */
 323     {
 324         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 325     }
 326     else if (dst == src)
 327     {
 328         struct BitmapData *data;
 329         data = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
 330         switch (mode)
 331         {
 332         case vHidd_GC_DrawMode_Clear:
 333             clearCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 334             break;
 335         case vHidd_GC_DrawMode_And:
 336             andCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 337             break;
 338         case vHidd_GC_DrawMode_AndReverse:
 339             andReverseCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 340             break;
 341         case vHidd_GC_DrawMode_Copy:
 342             copyCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 343             break;
 344         case vHidd_GC_DrawMode_AndInverted:
 345             andInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 346             break;
 347         case vHidd_GC_DrawMode_NoOp:
 348             noOpCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 349             break;
 350         case vHidd_GC_DrawMode_Xor:
 351             xorCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 352             break;
 353         case vHidd_GC_DrawMode_Or:
 354             orCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 355             break;
 356         case vHidd_GC_DrawMode_Nor:
 357             norCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 358             break;
 359         case vHidd_GC_DrawMode_Equiv:
 360             equivCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 361             break;
 362         case vHidd_GC_DrawMode_Invert:
 363             invertCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 364             break;
 365         case vHidd_GC_DrawMode_OrReverse:
 366             orReverseCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 367             break;
 368         case vHidd_GC_DrawMode_CopyInverted:
 369             copyInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 370             break;
 371         case vHidd_GC_DrawMode_OrInverted:
 372             orInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 373             break;
 374         case vHidd_GC_DrawMode_Nand:
 375             nandCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 376             break;
 377         case vHidd_GC_DrawMode_Set:
 378             setCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 379             break;
 380         default:
 381             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 382         }
 383     }
 384     else
 385     {
 386         struct BitmapData *srcbd = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
 387         struct BitmapData *dstbd = OOP_INST_DATA(OOP_OCLASS(msg->dest), msg->dest);
 388         UBYTE *sbuffer;
 389         ULONG srestadd;
 390         UBYTE *dbuffer;
 391         ULONG drestadd;
 392         ULONG ycnt = msg->height;
 393         ULONG xcnt;
 394         LONG offset;
 395         /* get src/dest video data start addresses and skip sizes */
 396         if (srcbd->VideoData == srcbd->data->vrambase)
 397         {
 398             offset = (msg->srcX*srcbd->bytesperpix)+(msg->srcY*srcbd->data->bytesperline);
 399             srestadd = (srcbd->data->bytesperline - (msg->width*srcbd->bytesperpix));
 400             displayCursorVMWareSVGA(&XSD(cl)->data, 0);
 401             XSD(cl)->mouse.visible = 0;
 402         }
 403         else
 404         {
 405             offset = (msg->srcX+(msg->srcY*srcbd->width))*srcbd->bytesperpix;
 406             srestadd = (srcbd->width - msg->width)*srcbd->bytesperpix;
 407         }
 408         sbuffer = srcbd->VideoData+offset;
 409         if (dstbd->VideoData == dstbd->data->vrambase)
 410         {
 411             offset = (msg->destX*dstbd->bytesperpix)+(msg->destY*dstbd->data->bytesperline);
 412             drestadd = (dstbd->data->bytesperline - (msg->width*dstbd->bytesperpix));
 413             displayCursorVMWareSVGA(&XSD(cl)->data, 0);
 414             XSD(cl)->mouse.visible = 0;
 415         }
 416         else
 417         {
 418             offset = (msg->destX+(msg->destY*dstbd->width))*dstbd->bytesperpix;
 419             drestadd = (dstbd->width - msg->width)*dstbd->bytesperpix;
 420         }
 421         dbuffer = dstbd->VideoData+offset;
 422         switch (mode)
 423         {
 424         case vHidd_GC_DrawMode_Copy:
 425             while (ycnt--)
 426             {
 427                 ULONG pixel;
 428                 xcnt = msg->width;
 429                 while (xcnt)
 430                 {
 431                     /* get pixel from source */
 432                         switch (srcbd->bytesperpix)
 433                     {
 434                         case 1:
 435                         pixel = (ULONG)*((UBYTE *)sbuffer);
 436                         sbuffer++;
 437                         break;
 438                         case 2:
 439                         pixel = (ULONG)*((UWORD *)sbuffer);
 440                         sbuffer += 2;
 441                         break;
 442                         case 4:
 443                         pixel = (ULONG)*((ULONG *)sbuffer);
 444                         sbuffer += 4;
 445                         break;
 446                         default:
 447                         D(bug("[VMWareSVGA] Copy: Unknown number of bytes per pixel (%d) in source!\n",srcbd->bytesperpix));
 448                         pixel = 0;
 449                         break;
 450                     }
 451                     /* write pixel to destination */
 452                     switch (dstbd->bytesperpix)
 453                     {
 454                         case 1:
 455                         *((UBYTE *)dbuffer) = (UBYTE)pixel;
 456                         dbuffer++;
 457                         break;
 458                         case 2:
 459                         *((UWORD *)dbuffer) = (UWORD)pixel;
 460                         dbuffer += 2;
 461                         break;
 462                         case 4:
 463                         *((ULONG *)dbuffer) = (ULONG)pixel;
 464                         dbuffer += 4;
 465                         break;
 466                         default:
 467                         D(bug("[VMWareSVGA] Copy: Unknown number of bytes per pixel (%d) in destination!\n",dstbd->bytesperpix));
 468                         break;
 469                     }
 470                     xcnt--;
 471                 }
 472                 sbuffer += srestadd;
 473                 dbuffer += drestadd;
 474             }
 475             if (dstbd->VideoData == dstbd->data->vrambase)
 476             {
 477                 box.x1 = msg->destX;
 478                 box.y1 = msg->destY;
 479                 box.x2 = box.x1+msg->width-1;
 480                 box.y2 = box.y1+msg->height-1;
 481                 refreshAreaVMWareSVGA(dstbd->data, &box);
 482             }
 483             break;
 484         default:
 485             kprintf("[VMWareSVGA] mode = %ld src=%lx dst=%lx\n", mode, src, dst);
 486             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 487         }
 488         if (XSD(cl)->mouse.visible == 0)
 489         {
 490             displayCursorVMWareSVGA(&XSD(cl)->data, 1);
 491             XSD(cl)->mouse.visible = 1;
 492         }
 493     }
 494     ReturnVoid("VMWareSVGA.BitMap::CopyBox");
 495 }
 496
 497 BOOL VMWareSVGA__Hidd_Gfx__SetCursorShape(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorShape *msg)
 498 {
 499     struct VMWareSVGA_staticdata *data = XSD(cl);
 500
 501     if (msg->shape == NULL)
 502     {
 503         displayCursorVMWareSVGA(&XSD(cl)->data, 0);
 504         data->mouse.oopshape = NULL;
 505         if (data->mouse.shape != NULL)
 506             FreeVec(data->mouse.shape);
 507         data->mouse.shape = NULL;
 508         return TRUE;
 509     }
 510     else
 511     {
 512         OOP_Object *pfmt;
 513         OOP_Object *colmap;
 514         HIDDT_StdPixFmt pixfmt;
 515         HIDDT_Color color;
 516         OOP_GetAttr(msg->shape, aHidd_BitMap_Width, &data->mouse.width);
 517         OOP_GetAttr(msg->shape, aHidd_BitMap_Height, &data->mouse.height);
 518         OOP_GetAttr(msg->shape, aHidd_BitMap_PixFmt, (IPTR *)&pfmt);
 519         OOP_GetAttr(pfmt, aHidd_PixFmt_StdPixFmt, &pixfmt);
 520         OOP_GetAttr(msg->shape, aHidd_BitMap_ColorMap, (IPTR *)&colmap);
 521         data->mouse.oopshape = msg->shape;
 522 #if 0
 523         data->mouse.shape = cursor_shape;
 524         data->mouse.width = 11;
 525         data->mouse.height = 11;
 526         defineCursorVMWareSVGA(&XSD(cl)->data, &data->mouse);
 527         return TRUE;
 528 #else
 529         /* convert shape to vmware needs */
 530         if (data->mouse.shape != NULL)
 531             FreeVec(data->mouse.shape);
 532         data->mouse.shape = AllocVec(SVGA_PIXMAP_SIZE(data->mouse.width, data->mouse.height, data->data.bitsperpixel)*4, MEMF_PUBLIC);
 533         if (data->mouse.shape != NULL)
 534         {
 535             LONG xcnt;
 536             LONG ycnt;
 537             LONG linebytes;
 538             LONG bytecnt;
 539             LONG pixelbytes;
 540             UBYTE *shape;
 541             linebytes = SVGA_PIXMAP_SCANLINE_SIZE(data->mouse.width, data->data.bitsperpixel)*4;
 542             pixelbytes = (data->data.bitsperpixel+3)/8;
 543             shape = data->mouse.shape;
 544             for (ycnt=0;ycnt<data->mouse.height;ycnt++)
 545             {
 546                 for (xcnt=0;xcnt<data->mouse.width;xcnt++)
 547                 {
 548                     HIDDT_Pixel pixel;
 549                     pixel = HIDD_BM_GetPixel(msg->shape, xcnt, ycnt);
 550                     if (pixfmt == vHidd_StdPixFmt_LUT8)
 551                     {
 552                         if (HIDD_CM_GetColor(colmap, pixel, &color))
 553                         {
 554                             pixel =
 555                                 (
 556                                     (((color.red  <<16)>>mask_to_shift(data->data.redmask))   & data->data.redmask  )+
 557                                     (((color.green<<16)>>mask_to_shift(data->data.greenmask)) & data->data.greenmask)+
 558                                     (((color.blue <<16)>>mask_to_shift(data->data.bluemask))  & data->data.bluemask )
 559                                 );
 560                         }
 561                     }
 562                     if (pixelbytes == 1)
 563                     {
 564                         *((UBYTE *)shape) = (UBYTE)pixel;
 565                         shape++;
 566                     }
 567                     else if (pixelbytes == 2)
 568                     {
 569                         *((UWORD *)shape) = (UWORD)pixel;
 570                         shape += 2;
 571                     }
 572                     else if (pixelbytes == 4)
 573                     {
 574                         *((ULONG *)shape) = (ULONG)pixel;
 575                         shape += 4;
 576                     }
 577                 }
 578                 for (bytecnt=linebytes-(data->mouse.width*pixelbytes);bytecnt;bytecnt--)
 579                 {
 580                     *((UBYTE *)shape) = 0; /* fill up to long boundary */
 581                     shape++;
 582                 }
 583             }
 584             defineCursorVMWareSVGA(&XSD(cl)->data, &data->mouse);
 585             return TRUE;
 586         }
 587 #endif
 588     }
 589     return FALSE;
 590 }
 591
 592 BOOL VMWareSVGA__Hidd_Gfx__SetCursorPos(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorPos *msg)
 593 {
 594     struct Box box;
 595
 596     XSD(cl)->mouse.x = msg->x;
 597     XSD(cl)->mouse.y = msg->y;
 598     if (XSD(cl)->mouse.x<0)
 599         XSD(cl)->mouse.x=0;
 600     if (XSD(cl)->mouse.y<0)
 601         XSD(cl)->mouse.y=0;
 602 #warning "check visible width/height"
 603     moveCursorVMWareSVGA(&XSD(cl)->data, msg->x, msg->y);
 604     return TRUE;
 605 }
 606
 607 VOID VMWareSVGA__Hidd_Gfx__SetCursorVisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
 608 {
 609     XSD(cl)->mouse.visible = msg->visible;
 610     displayCursorVMWareSVGA(&XSD(cl)->data, msg->visible ? 1 : 0);
 611 }
 612
 613
 614 static int VMWareSVGA_InitStatic(LIBBASETYPEPTR LIBBASE)
 615 {
 616     EnterFunc(bug("[VMWareSVGA] VMWareSVGA_InitStatic()\n"));
 617
 618     LIBBASE->vsd.mouse.x=0;
 619     LIBBASE->vsd.mouse.y=0;
 620     LIBBASE->vsd.mouse.shape = NULL;
 621
 622     if (!OOP_ObtainAttrBases(attrbases))
 623     {
 624         D(bug("[VMWareSVGA] VMWareSVGA_InitStatic: attrbases init failed\n"));
 625         return FALSE;
 626     }
 627
 628     D(bug("[VMWareSVGA] VMWareSVGA_InitStatic: ok\n"));
 629
 630     ReturnInt("VMWareSVGA_InitStatic", int, TRUE);
 631 }
 632
 633 static int VMWareSVGA_ExpungeStatic(LIBBASETYPEPTR LIBBASE)
 634 {
 635     EnterFunc(bug("[VMWareSVGA] VMWareSVGA_ExpungeStatic()\n"));
 636
 637     OOP_ReleaseAttrBases(attrbases);
 638     ReturnInt("VMWareSVGA_ExpungeStatic", int, TRUE);
 639 }
 640
 641 ADD2INITLIB(VMWareSVGA_InitStatic, 0)
 642 ADD2EXPUNGELIB(VMWareSVGA_ExpungeStatic, 0)