git.oblomov.eu Git - wine/blob - dlls/gdi32/mfdrv/objects.c

   1 /*
   2  * GDI objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "wownt32.h"
  30 #include "mfdrv/metafiledrv.h"
  31 #include "gdi_private.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
  35
  36 /******************************************************************
  37  *         MFDRV_AddHandle
  38  */
  39 UINT MFDRV_AddHandle( PHYSDEV dev, HGDIOBJ obj )
  40 {
  41     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
  42     UINT16 index;
  43
  44     for(index = 0; index < physDev->handles_size; index++)
  45         if(physDev->handles[index] == 0) break;
  46     if(index == physDev->handles_size) {
  47         physDev->handles_size += HANDLE_LIST_INC;
  48         physDev->handles = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  49                                        physDev->handles,
  50                                        physDev->handles_size * sizeof(physDev->handles[0]));
  51     }
  52     physDev->handles[index] = obj;
  53
  54     physDev->cur_handles++;
  55     if(physDev->cur_handles > physDev->mh->mtNoObjects)
  56         physDev->mh->mtNoObjects++;
  57
  58     return index ; /* index 0 is not reserved for metafiles */
  59 }
  60
  61 /******************************************************************
  62  *         MFDRV_RemoveHandle
  63  */
  64 BOOL MFDRV_RemoveHandle( PHYSDEV dev, UINT index )
  65 {
  66     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
  67     BOOL ret = FALSE;
  68
  69     if (index < physDev->handles_size && physDev->handles[index])
  70     {
  71         physDev->handles[index] = 0;
  72         physDev->cur_handles--;
  73         ret = TRUE;
  74     }
  75     return ret;
  76 }
  77
  78 /******************************************************************
  79  *         MFDRV_FindObject
  80  */
  81 static INT16 MFDRV_FindObject( PHYSDEV dev, HGDIOBJ obj )
  82 {
  83     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
  84     INT16 index;
  85
  86     for(index = 0; index < physDev->handles_size; index++)
  87         if(physDev->handles[index] == obj) break;
  88
  89     if(index == physDev->handles_size) return -1;
  90
  91     return index ;
  92 }
  93
  94
  95 /******************************************************************
  96  *         MFDRV_DeleteObject
  97  */
  98 BOOL MFDRV_DeleteObject( PHYSDEV dev, HGDIOBJ obj )
  99 {
 100     METARECORD mr;
 101     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 102     INT16 index;
 103     BOOL ret = TRUE;
 104
 105     index = MFDRV_FindObject(dev, obj);
 106     if( index < 0 )
 107         return 0;
 108
 109     mr.rdSize = sizeof mr / 2;
 110     mr.rdFunction = META_DELETEOBJECT;
 111     mr.rdParm[0] = index;
 112
 113     if(!MFDRV_WriteRecord( dev, &mr, mr.rdSize*2 ))
 114         ret = FALSE;
 115
 116     physDev->handles[index] = 0;
 117     physDev->cur_handles--;
 118     return ret;
 119 }
 120
 121
 122 /***********************************************************************
 123  *           MFDRV_SelectObject
 124  */
 125 static BOOL MFDRV_SelectObject( PHYSDEV dev, INT16 index)
 126 {
 127     METARECORD mr;
 128
 129     mr.rdSize = sizeof mr / 2;
 130     mr.rdFunction = META_SELECTOBJECT;
 131     mr.rdParm[0] = index;
 132
 133     return MFDRV_WriteRecord( dev, &mr, mr.rdSize*2 );
 134 }
 135
 136
 137 /***********************************************************************
 138  *           MFDRV_SelectBitmap
 139  */
 140 HBITMAP MFDRV_SelectBitmap( PHYSDEV dev, HBITMAP hbitmap )
 141 {
 142     return 0;
 143 }
 144
 145 /***********************************************************************
 146  * Internal helper for MFDRV_CreateBrushIndirect():
 147  * Change the padding of a bitmap from 16 (BMP) to 32 (DIB) bits.
 148  */
 149 static inline void MFDRV_PadTo32(LPBYTE lpRows, int height, int width)
 150 {
 151     int bytes16 = 2 * ((width + 15) / 16);
 152     int bytes32 = 4 * ((width + 31) / 32);
 153     LPBYTE lpSrc, lpDst;
 154     int i;
 155
 156     if (!height)
 157         return;
 158
 159     height = abs(height) - 1;
 160     lpSrc = lpRows + height * bytes16;
 161     lpDst = lpRows + height * bytes32;
 162
 163     /* Note that we work backwards so we can re-pad in place */
 164     while (height >= 0)
 165     {
 166         for (i = bytes32; i > bytes16; i--)
 167             lpDst[i - 1] = 0; /* Zero the padding bytes */
 168         for (; i > 0; i--)
 169             lpDst[i - 1] = lpSrc[i - 1]; /* Move image bytes into alignment */
 170         lpSrc -= bytes16;
 171         lpDst -= bytes32;
 172         height--;
 173     }
 174 }
 175
 176 /***********************************************************************
 177  * Internal helper for MFDRV_CreateBrushIndirect():
 178  * Reverse order of bitmap rows in going from BMP to DIB.
 179  */
 180 static inline void MFDRV_Reverse(LPBYTE lpRows, int height, int width)
 181 {
 182     int bytes = 4 * ((width + 31) / 32);
 183     LPBYTE lpSrc, lpDst;
 184     BYTE temp;
 185     int i;
 186
 187     if (!height)
 188         return;
 189
 190     lpSrc = lpRows;
 191     lpDst = lpRows + (height-1) * bytes;
 192     height = height/2;
 193
 194     while (height > 0)
 195     {
 196         for (i = 0; i < bytes; i++)
 197         {
 198             temp = lpDst[i];
 199             lpDst[i] = lpSrc[i];
 200             lpSrc[i] = temp;
 201         }
 202         lpSrc += bytes;
 203         lpDst -= bytes;
 204         height--;
 205     }
 206 }
 207
 208 /******************************************************************
 209  *         MFDRV_CreateBrushIndirect
 210  */
 211
 212 INT16 MFDRV_CreateBrushIndirect(PHYSDEV dev, HBRUSH hBrush )
 213 {
 214     DWORD size;
 215     METARECORD *mr;
 216     LOGBRUSH logbrush;
 217     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 218     BOOL r;
 219
 220     if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return -1;
 221
 222     switch(logbrush.lbStyle)
 223     {
 224     case BS_SOLID:
 225     case BS_NULL:
 226     case BS_HATCHED:
 227         {
 228             LOGBRUSH16 lb16;
 229
 230             lb16.lbStyle = logbrush.lbStyle;
 231             lb16.lbColor = logbrush.lbColor;
 232             lb16.lbHatch = logbrush.lbHatch;
 233             size = sizeof(METARECORD) + sizeof(LOGBRUSH16) - 2;
 234             mr = HeapAlloc( GetProcessHeap(), 0, size );
 235             mr->rdSize = size / 2;
 236             mr->rdFunction = META_CREATEBRUSHINDIRECT;
 237             memcpy( mr->rdParm, &lb16, sizeof(LOGBRUSH16));
 238             break;
 239         }
 240     case BS_PATTERN:
 241         {
 242             BITMAP bm;
 243             BITMAPINFO *info;
 244             DWORD bmSize;
 245             COLORREF cref;
 246
 247             GetObjectA((HANDLE)logbrush.lbHatch, sizeof(bm), &bm);
 248             if(bm.bmBitsPixel != 1 || bm.bmPlanes != 1) {
 249                 FIXME("Trying to store a colour pattern brush\n");
 250                 goto done;
 251             }
 252
 253             bmSize = DIB_GetDIBImageBytes(bm.bmWidth, bm.bmHeight, DIB_PAL_COLORS);
 254
 255             size = sizeof(METARECORD) + sizeof(WORD) + sizeof(BITMAPINFO) +
 256               sizeof(RGBQUAD) + bmSize;
 257
 258             mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 259             if(!mr) goto done;
 260             mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 261             mr->rdSize = size / 2;
 262             mr->rdParm[0] = BS_PATTERN;
 263             mr->rdParm[1] = DIB_RGB_COLORS;
 264             info = (BITMAPINFO *)(mr->rdParm + 2);
 265
 266             info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 267             info->bmiHeader.biWidth = bm.bmWidth;
 268             info->bmiHeader.biHeight = bm.bmHeight;
 269             info->bmiHeader.biPlanes = 1;
 270             info->bmiHeader.biBitCount = 1;
 271             info->bmiHeader.biSizeImage = bmSize;
 272
 273             GetBitmapBits((HANDLE)logbrush.lbHatch,
 274                       bm.bmHeight * BITMAP_GetWidthBytes (bm.bmWidth, bm.bmBitsPixel),
 275                       (LPBYTE)info + sizeof(BITMAPINFO) + sizeof(RGBQUAD));
 276
 277             /* Change the padding to be DIB compatible if needed */
 278             if(bm.bmWidth & 31)
 279                 MFDRV_PadTo32((LPBYTE)info + sizeof(BITMAPINFO) + sizeof(RGBQUAD),
 280                       bm.bmWidth, bm.bmHeight);
 281             /* BMP and DIB have opposite row order conventions */
 282             MFDRV_Reverse((LPBYTE)info + sizeof(BITMAPINFO) + sizeof(RGBQUAD),
 283                       bm.bmWidth, bm.bmHeight);
 284
 285             cref = GetTextColor(physDev->hdc);
 286             info->bmiColors[0].rgbRed = GetRValue(cref);
 287             info->bmiColors[0].rgbGreen = GetGValue(cref);
 288             info->bmiColors[0].rgbBlue = GetBValue(cref);
 289             info->bmiColors[0].rgbReserved = 0;
 290             cref = GetBkColor(physDev->hdc);
 291             info->bmiColors[1].rgbRed = GetRValue(cref);
 292             info->bmiColors[1].rgbGreen = GetGValue(cref);
 293             info->bmiColors[1].rgbBlue = GetBValue(cref);
 294             info->bmiColors[1].rgbReserved = 0;
 295             break;
 296         }
 297
 298     case BS_DIBPATTERN:
 299         {
 300               BITMAPINFO *info;
 301               DWORD bmSize, biSize;
 302
 303               info = GlobalLock16((HGLOBAL16)logbrush.lbHatch);
 304               if (info->bmiHeader.biCompression)
 305                   bmSize = info->bmiHeader.biSizeImage;
 306               else
 307                   bmSize = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
 308                                                 info->bmiHeader.biHeight,
 309                                                 info->bmiHeader.biBitCount);
 310               biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush.lbColor));
 311               size = sizeof(METARECORD) + biSize + bmSize + 2;
 312               mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 313               if(!mr) goto done;
 314               mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 315               mr->rdSize = size / 2;
 316               *(mr->rdParm) = logbrush.lbStyle;
 317               *(mr->rdParm + 1) = LOWORD(logbrush.lbColor);
 318               memcpy(mr->rdParm + 2, info, biSize + bmSize);
 319               break;
 320         }
 321         default:
 322             FIXME("Unkonwn brush style %x\n", logbrush.lbStyle);
 323             return 0;
 324     }
 325     r = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 326     HeapFree(GetProcessHeap(), 0, mr);
 327     if( !r )
 328         return -1;
 329 done:
 330     return MFDRV_AddHandle( dev, hBrush );
 331 }
 332
 333
 334 /***********************************************************************
 335  *           MFDRV_SelectBrush
 336  */
 337 HBRUSH MFDRV_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
 338 {
 339     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 340     INT16 index;
 341
 342     index = MFDRV_FindObject(dev, hbrush);
 343     if( index < 0 )
 344     {
 345         index = MFDRV_CreateBrushIndirect( dev, hbrush );
 346         if( index < 0 )
 347             return 0;
 348         GDI_hdc_using_object(hbrush, physDev->hdc);
 349     }
 350     return MFDRV_SelectObject( dev, index ) ? hbrush : HGDI_ERROR;
 351 }
 352
 353 /******************************************************************
 354  *         MFDRV_CreateFontIndirect
 355  */
 356
 357 static UINT16 MFDRV_CreateFontIndirect(PHYSDEV dev, HFONT hFont, LOGFONT16 *logfont)
 358 {
 359     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
 360     METARECORD *mr = (METARECORD *)&buffer;
 361
 362     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
 363     mr->rdFunction = META_CREATEFONTINDIRECT;
 364     memcpy(&(mr->rdParm), logfont, sizeof(LOGFONT16));
 365     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
 366         return 0;
 367     return MFDRV_AddHandle( dev, hFont );
 368 }
 369
 370
 371 /***********************************************************************
 372  *           MFDRV_SelectFont
 373  */
 374 HFONT MFDRV_SelectFont( PHYSDEV dev, HFONT hfont, HANDLE gdiFont )
 375 {
 376     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 377     LOGFONT16 lf16;
 378     INT16 index;
 379
 380     index = MFDRV_FindObject(dev, hfont);
 381     if( index < 0 )
 382     {
 383         if (!GetObject16( HFONT_16(hfont), sizeof(lf16), &lf16 ))
 384             return HGDI_ERROR;
 385         index = MFDRV_CreateFontIndirect(dev, hfont, &lf16);
 386         if( index < 0 )
 387             return HGDI_ERROR;
 388         GDI_hdc_using_object(hfont, physDev->hdc);
 389     }
 390     return MFDRV_SelectObject( dev, index ) ? hfont : HGDI_ERROR;
 391 }
 392
 393 /******************************************************************
 394  *         MFDRV_CreatePenIndirect
 395  */
 396 static UINT16 MFDRV_CreatePenIndirect(PHYSDEV dev, HPEN hPen, LOGPEN16 *logpen)
 397 {
 398     char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
 399     METARECORD *mr = (METARECORD *)&buffer;
 400
 401     mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
 402     mr->rdFunction = META_CREATEPENINDIRECT;
 403     memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
 404     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
 405         return 0;
 406     return MFDRV_AddHandle( dev, hPen );
 407 }
 408
 409
 410 /***********************************************************************
 411  *           MFDRV_SelectPen
 412  */
 413 HPEN MFDRV_SelectPen( PHYSDEV dev, HPEN hpen )
 414 {
 415     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 416     LOGPEN16 logpen;
 417     INT16 index;
 418
 419     index = MFDRV_FindObject(dev, hpen);
 420     if( index < 0 )
 421     {
 422         if (!GetObject16( HPEN_16(hpen), sizeof(logpen), &logpen ))
 423         {
 424             /* must be an extended pen */
 425             EXTLOGPEN *elp;
 426             INT size = GetObjectW( hpen, 0, NULL );
 427
 428             if (!size) return 0;
 429
 430             elp = HeapAlloc( GetProcessHeap(), 0, size );
 431
 432             GetObjectW( hpen, size, elp );
 433             /* FIXME: add support for user style pens */
 434             logpen.lopnStyle = elp->elpPenStyle;
 435             logpen.lopnWidth.x = elp->elpWidth;
 436             logpen.lopnWidth.y = 0;
 437             logpen.lopnColor = elp->elpColor;
 438
 439             HeapFree( GetProcessHeap(), 0, elp );
 440         }
 441
 442         index = MFDRV_CreatePenIndirect( dev, hpen, &logpen );
 443         if( index < 0 )
 444             return 0;
 445         GDI_hdc_using_object(hpen, physDev->hdc);
 446     }
 447     return MFDRV_SelectObject( dev, index ) ? hpen : HGDI_ERROR;
 448 }
 449
 450
 451 /******************************************************************
 452  *         MFDRV_CreatePalette
 453  */
 454 static BOOL MFDRV_CreatePalette(PHYSDEV dev, HPALETTE hPalette, LOGPALETTE* logPalette, int sizeofPalette)
 455 {
 456     int index;
 457     BOOL ret;
 458     METARECORD *mr;
 459
 460     mr = HeapAlloc( GetProcessHeap(), 0, sizeof(METARECORD) + sizeofPalette - sizeof(WORD) );
 461     mr->rdSize = (sizeof(METARECORD) + sizeofPalette - sizeof(WORD)) / sizeof(WORD);
 462     mr->rdFunction = META_CREATEPALETTE;
 463     memcpy(&(mr->rdParm), logPalette, sizeofPalette);
 464     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD))))
 465     {
 466         HeapFree(GetProcessHeap(), 0, mr);
 467         return FALSE;
 468     }
 469
 470     mr->rdSize = sizeof(METARECORD) / sizeof(WORD);
 471     mr->rdFunction = META_SELECTPALETTE;
 472
 473     if ((index = MFDRV_AddHandle( dev, hPalette )) == -1) ret = FALSE;
 474     else
 475     {
 476         *(mr->rdParm) = index;
 477         ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD));
 478     }
 479     HeapFree(GetProcessHeap(), 0, mr);
 480     return ret;
 481 }
 482
 483
 484 /***********************************************************************
 485  *           MFDRV_SelectPalette
 486  */
 487 HPALETTE MFDRV_SelectPalette( PHYSDEV dev, HPALETTE hPalette, BOOL bForceBackground )
 488 {
 489 #define PALVERSION 0x0300
 490
 491     PLOGPALETTE logPalette;
 492     WORD        wNumEntries = 0;
 493     BOOL        creationSucceed;
 494     int         sizeofPalette;
 495
 496     GetObjectA(hPalette, sizeof(WORD), (LPSTR) &wNumEntries);
 497
 498     if (wNumEntries == 0) return 0;
 499
 500     sizeofPalette = sizeof(LOGPALETTE) + ((wNumEntries-1) * sizeof(PALETTEENTRY));
 501     logPalette = HeapAlloc( GetProcessHeap(), 0, sizeofPalette );
 502
 503     if (logPalette == NULL) return 0;
 504
 505     logPalette->palVersion = PALVERSION;
 506     logPalette->palNumEntries = wNumEntries;
 507
 508     GetPaletteEntries(hPalette, 0, wNumEntries, logPalette->palPalEntry);
 509
 510     creationSucceed = MFDRV_CreatePalette( dev, hPalette, logPalette, sizeofPalette );
 511
 512     HeapFree( GetProcessHeap(), 0, logPalette );
 513
 514     if (creationSucceed)
 515         return hPalette;
 516
 517     return 0;
 518 }
 519
 520 /***********************************************************************
 521  *           MFDRV_RealizePalette
 522  */
 523 UINT MFDRV_RealizePalette(PHYSDEV dev, HPALETTE hPalette, BOOL dummy)
 524 {
 525     char buffer[sizeof(METARECORD) - sizeof(WORD)];
 526     METARECORD *mr = (METARECORD *)&buffer;
 527
 528     mr->rdSize = (sizeof(METARECORD) - sizeof(WORD)) / sizeof(WORD);
 529     mr->rdFunction = META_REALIZEPALETTE;
 530
 531     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD)))) return 0;
 532
 533     /* The return value is suppose to be the number of entries
 534        in the logical palette mapped to the system palette or 0
 535        if the function failed. Since it's not trivial here to
 536        get that kind of information and since it's of little
 537        use in the case of metafiles, we'll always return 1. */
 538     return 1;
 539 }