workbench/hidds/vmwaresvga/vmwaresvgaclass.c

   1 /*
   2     Copyright © 1995-2013, 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     /* 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     FreeVec(XSD(cl)->mouse.shape);
 234     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 235 }
 236
 237 VOID VMWareSVGA__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
 238 {
 239     ULONG idx;
 240     BOOL found = FALSE;
 241
 242     if (IS_GFX_ATTR(msg->attrID, idx))
 243     {
 244         switch (idx)
 245         {
 246         case aoHidd_Gfx_SupportsHWCursor:
 247             *msg->storage = (IPTR)TRUE;
 248             found = TRUE;
 249             break;
 250         }
 251     }
 252     if (!found)
 253         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 254 }
 255
 256 OOP_Object *VMWareSVGA__Hidd_Gfx__NewBitMap(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NewBitMap *msg)
 257 {
 258     BOOL displayable;
 259     BOOL framebuffer;
 260     OOP_Class *classptr = NULL;
 261     struct TagItem tags[2];
 262     struct pHidd_Gfx_NewBitMap yourmsg;
 263
 264     EnterFunc(bug("VMWareSVGA::NewBitMap()\n"));
 265     displayable = GetTagData(aHidd_BitMap_Displayable, FALSE, msg->attrList);
 266     framebuffer = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList);
 267     if (framebuffer)
 268         classptr = XSD(cl)->vmwaresvgaonbmclass;
 269     else if (displayable)
 270         classptr = XSD(cl)->vmwaresvgaoffbmclass;
 271     else
 272     {
 273         HIDDT_ModeID modeid;
 274         modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
 275         if (modeid != vHidd_ModeID_Invalid)
 276             classptr = XSD(cl)->vmwaresvgaoffbmclass;
 277         else
 278         {
 279             HIDDT_StdPixFmt stdpf;
 280             stdpf = (HIDDT_StdPixFmt)GetTagData(aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_Unknown, msg->attrList);
 281             if (stdpf == vHidd_StdPixFmt_Unknown)
 282             {
 283                 OOP_Object *friend;
 284                 friend = (OOP_Object *)GetTagData(aHidd_BitMap_Friend, (IPTR)NULL, msg->attrList);
 285                 if (friend != NULL)
 286                 {
 287                     OOP_Class *friend_class = NULL;
 288                     OOP_GetAttr(friend, aHidd_BitMap_ClassPtr, (IPTR *)&friend_class);
 289                     if (friend_class == XSD(cl)->vmwaresvgaonbmclass)
 290                     {
 291                         classptr = XSD(cl)->vmwaresvgaoffbmclass;
 292                     }
 293                 }
 294             }
 295         }
 296     }
 297     if (classptr != NULL)
 298     {
 299         tags[0].ti_Tag = aHidd_BitMap_ClassPtr;
 300         tags[0].ti_Data = (IPTR)classptr;
 301         tags[1].ti_Tag = TAG_MORE;
 302         tags[1].ti_Data = (IPTR)msg->attrList;
 303         yourmsg.mID = msg->mID;
 304         yourmsg.attrList = tags;
 305         msg = &yourmsg;
 306     }
 307     ReturnPtr("VMWareSVGA::NewBitMap", OOP_Object *, (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg));
 308 }
 309
 310 VOID VMWareSVGA__Hidd_Gfx__CopyBox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
 311 {
 312     UBYTE *src = NULL;
 313     UBYTE *dst = NULL;
 314     HIDDT_DrawMode mode;
 315     struct Box box;
 316
 317     EnterFunc(bug("VMWareSVGA.BitMap::CopyBox\n"));
 318     mode = GC_DRMD(msg->gc);
 319     OOP_GetAttr(msg->src, aHidd_VMWareSVGABitMap_Drawable, (IPTR *)&src);
 320     OOP_GetAttr(msg->dest, aHidd_VMWareSVGABitMap_Drawable, (IPTR *)&dst);
 321     if (((dst == NULL) || (src == NULL))) /* no vmwaregfx bitmap */
 322     {
 323         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 324     }
 325     else if (dst == src)
 326     {
 327         struct BitmapData *data;
 328         data = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
 329         switch (mode)
 330         {
 331         case vHidd_GC_DrawMode_Clear:
 332             clearCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 333             break;
 334         case vHidd_GC_DrawMode_And:
 335             andCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 336             break;
 337         case vHidd_GC_DrawMode_AndReverse:
 338             andReverseCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 339             break;
 340         case vHidd_GC_DrawMode_Copy:
 341             copyCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 342             break;
 343         case vHidd_GC_DrawMode_AndInverted:
 344             andInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 345             break;
 346         case vHidd_GC_DrawMode_NoOp:
 347             noOpCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 348             break;
 349         case vHidd_GC_DrawMode_Xor:
 350             xorCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 351             break;
 352         case vHidd_GC_DrawMode_Or:
 353             orCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 354             break;
 355         case vHidd_GC_DrawMode_Nor:
 356             norCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 357             break;
 358         case vHidd_GC_DrawMode_Equiv:
 359             equivCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 360             break;
 361         case vHidd_GC_DrawMode_Invert:
 362             invertCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 363             break;
 364         case vHidd_GC_DrawMode_OrReverse:
 365             orReverseCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 366             break;
 367         case vHidd_GC_DrawMode_CopyInverted:
 368             copyInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 369             break;
 370         case vHidd_GC_DrawMode_OrInverted:
 371             orInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 372             break;
 373         case vHidd_GC_DrawMode_Nand:
 374             nandCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 375             break;
 376         case vHidd_GC_DrawMode_Set:
 377             setCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
 378             break;
 379         default:
 380             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 381         }
 382     }
 383     else
 384     {
 385         struct BitmapData *srcbd = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
 386         struct BitmapData *dstbd = OOP_INST_DATA(OOP_OCLASS(msg->dest), msg->dest);
 387         UBYTE *sbuffer;
 388         ULONG srestadd;
 389         UBYTE *dbuffer;
 390         ULONG drestadd;
 391         ULONG ycnt = msg->height;
 392         ULONG xcnt;
 393         LONG offset;
 394         /* get src/dest video data start addresses and skip sizes */
 395         if (srcbd->VideoData == srcbd->data->vrambase)
 396         {
 397             offset = (msg->srcX*srcbd->bytesperpix)+(msg->srcY*srcbd->data->bytesperline);
 398             srestadd = (srcbd->data->bytesperline - (msg->width*srcbd->bytesperpix));
 399             displayCursorVMWareSVGA(&XSD(cl)->data, 0);
 400             XSD(cl)->mouse.visible = 0;
 401         }
 402         else
 403         {
 404             offset = (msg->srcX+(msg->srcY*srcbd->width))*srcbd->bytesperpix;
 405             srestadd = (srcbd->width - msg->width)*srcbd->bytesperpix;
 406         }
 407         sbuffer = srcbd->VideoData+offset;
 408         if (dstbd->VideoData == dstbd->data->vrambase)
 409         {
 410             offset = (msg->destX*dstbd->bytesperpix)+(msg->destY*dstbd->data->bytesperline);
 411             drestadd = (dstbd->data->bytesperline - (msg->width*dstbd->bytesperpix));
 412             displayCursorVMWareSVGA(&XSD(cl)->data, 0);
 413             XSD(cl)->mouse.visible = 0;
 414         }
 415         else
 416         {
 417             offset = (msg->destX+(msg->destY*dstbd->width))*dstbd->bytesperpix;
 418             drestadd = (dstbd->width - msg->width)*dstbd->bytesperpix;
 419         }
 420         dbuffer = dstbd->VideoData+offset;
 421         switch (mode)
 422         {
 423         case vHidd_GC_DrawMode_Copy:
 424             while (ycnt--)
 425             {
 426                 ULONG pixel;
 427                 xcnt = msg->width;
 428                 while (xcnt)
 429                 {
 430                     /* get pixel from source */
 431                         switch (srcbd->bytesperpix)
 432                     {
 433                         case 1:
 434                         pixel = (ULONG)*((UBYTE *)sbuffer);
 435                         sbuffer++;
 436                         break;
 437                         case 2:
 438                         pixel = (ULONG)*((UWORD *)sbuffer);
 439                         sbuffer += 2;
 440                         break;
 441                         case 4:
 442                         pixel = (ULONG)*((ULONG *)sbuffer);
 443                         sbuffer += 4;
 444                         break;
 445                         default:
 446                         D(bug("[VMWareSVGA] Copy: Unknown number of bytes per pixel (%d) in source!\n",srcbd->bytesperpix));
 447                         pixel = 0;
 448                         break;
 449                     }
 450                     /* write pixel to destination */
 451                     switch (dstbd->bytesperpix)
 452                     {
 453                         case 1:
 454                         *((UBYTE *)dbuffer) = (UBYTE)pixel;
 455                         dbuffer++;
 456                         break;
 457                         case 2:
 458                         *((UWORD *)dbuffer) = (UWORD)pixel;
 459                         dbuffer += 2;
 460                         break;
 461                         case 4:
 462                         *((ULONG *)dbuffer) = (ULONG)pixel;
 463                         dbuffer += 4;
 464                         break;
 465                         default:
 466                         D(bug("[VMWareSVGA] Copy: Unknown number of bytes per pixel (%d) in destination!\n",dstbd->bytesperpix));
 467                         break;
 468                     }
 469                     xcnt--;
 470                 }
 471                 sbuffer += srestadd;
 472                 dbuffer += drestadd;
 473             }
 474             if (dstbd->VideoData == dstbd->data->vrambase)
 475             {
 476                 box.x1 = msg->destX;
 477                 box.y1 = msg->destY;
 478                 box.x2 = box.x1+msg->width-1;
 479                 box.y2 = box.y1+msg->height-1;
 480                 refreshAreaVMWareSVGA(dstbd->data, &box);
 481             }
 482             break;
 483         default:
 484             kprintf("[VMWareSVGA] mode = %ld src=%lx dst=%lx\n", mode, src, dst);
 485             OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 486         }
 487         if (XSD(cl)->mouse.visible == 0)
 488         {
 489             displayCursorVMWareSVGA(&XSD(cl)->data, 1);
 490             XSD(cl)->mouse.visible = 1;
 491         }
 492     }
 493     ReturnVoid("VMWareSVGA.BitMap::CopyBox");
 494 }
 495
 496 BOOL VMWareSVGA__Hidd_Gfx__SetCursorShape(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorShape *msg)
 497 {
 498     struct VMWareSVGA_staticdata *data = XSD(cl);
 499
 500     if (msg->shape == NULL)
 501     {
 502         displayCursorVMWareSVGA(&XSD(cl)->data, 0);
 503         data->mouse.oopshape = NULL;
 504         FreeVec(data->mouse.shape);
 505         data->mouse.shape = NULL;
 506         return TRUE;
 507     }
 508     else
 509     {
 510         OOP_Object *pfmt;
 511         OOP_Object *colmap;
 512         HIDDT_StdPixFmt pixfmt;
 513         HIDDT_Color color;
 514         IPTR tmp;
 515         OOP_GetAttr(msg->shape, aHidd_BitMap_Width, &tmp);
 516         data->mouse.width = tmp;
 517         OOP_GetAttr(msg->shape, aHidd_BitMap_Height, &tmp);
 518         data->mouse.height = tmp;
 519         OOP_GetAttr(msg->shape, aHidd_BitMap_PixFmt, (IPTR *)&pfmt);
 520         OOP_GetAttr(pfmt, aHidd_PixFmt_StdPixFmt, (IPTR *)&pixfmt);
 521         OOP_GetAttr(msg->shape, aHidd_BitMap_ColorMap, (IPTR *)&colmap);
 522         data->mouse.oopshape = msg->shape;
 523 #if 0
 524         data->mouse.shape = cursor_shape;
 525         data->mouse.width = 11;
 526         data->mouse.height = 11;
 527         defineCursorVMWareSVGA(&XSD(cl)->data, &data->mouse);
 528         return TRUE;
 529 #else
 530         /* convert shape to vmware needs */
 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     XSD(cl)->mouse.x = msg->x;
 595     XSD(cl)->mouse.y = msg->y;
 596     if (XSD(cl)->mouse.x<0)
 597         XSD(cl)->mouse.x=0;
 598     if (XSD(cl)->mouse.y<0)
 599         XSD(cl)->mouse.y=0;
 600     /* TODO: check visible width/height */
 601     moveCursorVMWareSVGA(&XSD(cl)->data, msg->x, msg->y);
 602     return TRUE;
 603 }
 604
 605 VOID VMWareSVGA__Hidd_Gfx__SetCursorVisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
 606 {
 607     XSD(cl)->mouse.visible = msg->visible;
 608     displayCursorVMWareSVGA(&XSD(cl)->data, msg->visible ? 1 : 0);
 609 }
 610
 611
 612 static int VMWareSVGA_InitStatic(LIBBASETYPEPTR LIBBASE)
 613 {
 614     EnterFunc(bug("[VMWareSVGA] VMWareSVGA_InitStatic()\n"));
 615
 616     LIBBASE->vsd.mouse.x=0;
 617     LIBBASE->vsd.mouse.y=0;
 618     LIBBASE->vsd.mouse.shape = NULL;
 619
 620     if (!OOP_ObtainAttrBases(attrbases))
 621     {
 622         D(bug("[VMWareSVGA] VMWareSVGA_InitStatic: attrbases init failed\n"));
 623         return FALSE;
 624     }
 625
 626     D(bug("[VMWareSVGA] VMWareSVGA_InitStatic: ok\n"));
 627
 628     ReturnInt("VMWareSVGA_InitStatic", int, TRUE);
 629 }
 630
 631 static int VMWareSVGA_ExpungeStatic(LIBBASETYPEPTR LIBBASE)
 632 {
 633     EnterFunc(bug("[VMWareSVGA] VMWareSVGA_ExpungeStatic()\n"));
 634
 635     OOP_ReleaseAttrBases(attrbases);
 636     ReturnInt("VMWareSVGA_ExpungeStatic", int, TRUE);
 637 }
 638
 639 ADD2INITLIB(VMWareSVGA_InitStatic, 0)
 640 ADD2EXPUNGELIB(VMWareSVGA_ExpungeStatic, 0)