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 CDECL 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 CDECL 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 = GlobalLock( (HGLOBAL)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 = bitmap_info_size(info, LOWORD(logbrush.lbColor));
 311               size = sizeof(METARECORD) + biSize + bmSize + 2;
 312               mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 313               if (!mr)
 314               {
 315                   GlobalUnlock( (HGLOBAL)logbrush.lbHatch );
 316                   goto done;
 317               }
 318               mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 319               mr->rdSize = size / 2;
 320               *(mr->rdParm) = logbrush.lbStyle;
 321               *(mr->rdParm + 1) = LOWORD(logbrush.lbColor);
 322               memcpy(mr->rdParm + 2, info, biSize + bmSize);
 323               GlobalUnlock( (HGLOBAL)logbrush.lbHatch );
 324               break;
 325         }
 326         default:
 327             FIXME("Unkonwn brush style %x\n", logbrush.lbStyle);
 328             return 0;
 329     }
 330     r = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 331     HeapFree(GetProcessHeap(), 0, mr);
 332     if( !r )
 333         return -1;
 334 done:
 335     return MFDRV_AddHandle( dev, hBrush );
 336 }
 337
 338
 339 /***********************************************************************
 340  *           MFDRV_SelectBrush
 341  */
 342 HBRUSH CDECL MFDRV_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
 343 {
 344     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 345     INT16 index;
 346
 347     index = MFDRV_FindObject(dev, hbrush);
 348     if( index < 0 )
 349     {
 350         index = MFDRV_CreateBrushIndirect( dev, hbrush );
 351         if( index < 0 )
 352             return 0;
 353         GDI_hdc_using_object(hbrush, physDev->hdc);
 354     }
 355     return MFDRV_SelectObject( dev, index ) ? hbrush : HGDI_ERROR;
 356 }
 357
 358 /******************************************************************
 359  *         MFDRV_CreateFontIndirect
 360  */
 361
 362 static UINT16 MFDRV_CreateFontIndirect(PHYSDEV dev, HFONT hFont, LOGFONTW *logfont)
 363 {
 364     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
 365     METARECORD *mr = (METARECORD *)&buffer;
 366     LOGFONT16 *font16;
 367
 368     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
 369     mr->rdFunction = META_CREATEFONTINDIRECT;
 370     font16 = (LOGFONT16 *)&mr->rdParm;
 371
 372     font16->lfHeight         = logfont->lfHeight;
 373     font16->lfWidth          = logfont->lfWidth;
 374     font16->lfEscapement     = logfont->lfEscapement;
 375     font16->lfOrientation    = logfont->lfOrientation;
 376     font16->lfWeight         = logfont->lfWeight;
 377     font16->lfItalic         = logfont->lfItalic;
 378     font16->lfUnderline      = logfont->lfUnderline;
 379     font16->lfStrikeOut      = logfont->lfStrikeOut;
 380     font16->lfCharSet        = logfont->lfCharSet;
 381     font16->lfOutPrecision   = logfont->lfOutPrecision;
 382     font16->lfClipPrecision  = logfont->lfClipPrecision;
 383     font16->lfQuality        = logfont->lfQuality;
 384     font16->lfPitchAndFamily = logfont->lfPitchAndFamily;
 385     WideCharToMultiByte( CP_ACP, 0, logfont->lfFaceName, -1, font16->lfFaceName, LF_FACESIZE, NULL, NULL );
 386     font16->lfFaceName[LF_FACESIZE-1] = 0;
 387
 388     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
 389         return 0;
 390     return MFDRV_AddHandle( dev, hFont );
 391 }
 392
 393
 394 /***********************************************************************
 395  *           MFDRV_SelectFont
 396  */
 397 HFONT CDECL MFDRV_SelectFont( PHYSDEV dev, HFONT hfont, HANDLE gdiFont )
 398 {
 399     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 400     LOGFONTW font;
 401     INT16 index;
 402
 403     index = MFDRV_FindObject(dev, hfont);
 404     if( index < 0 )
 405     {
 406         if (!GetObjectW( hfont, sizeof(font), &font ))
 407             return HGDI_ERROR;
 408         index = MFDRV_CreateFontIndirect(dev, hfont, &font);
 409         if( index < 0 )
 410             return HGDI_ERROR;
 411         GDI_hdc_using_object(hfont, physDev->hdc);
 412     }
 413     return MFDRV_SelectObject( dev, index ) ? hfont : HGDI_ERROR;
 414 }
 415
 416 /******************************************************************
 417  *         MFDRV_CreatePenIndirect
 418  */
 419 static UINT16 MFDRV_CreatePenIndirect(PHYSDEV dev, HPEN hPen, LOGPEN16 *logpen)
 420 {
 421     char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
 422     METARECORD *mr = (METARECORD *)&buffer;
 423
 424     mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
 425     mr->rdFunction = META_CREATEPENINDIRECT;
 426     memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
 427     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
 428         return 0;
 429     return MFDRV_AddHandle( dev, hPen );
 430 }
 431
 432
 433 /***********************************************************************
 434  *           MFDRV_SelectPen
 435  */
 436 HPEN CDECL MFDRV_SelectPen( PHYSDEV dev, HPEN hpen )
 437 {
 438     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
 439     LOGPEN16 logpen;
 440     INT16 index;
 441
 442     index = MFDRV_FindObject(dev, hpen);
 443     if( index < 0 )
 444     {
 445         /* must be an extended pen */
 446         INT size = GetObjectW( hpen, 0, NULL );
 447
 448         if (!size) return 0;
 449
 450         if (size == sizeof(LOGPEN))
 451         {
 452             LOGPEN pen;
 453
 454             GetObjectW( hpen, sizeof(pen), &pen );
 455             logpen.lopnStyle   = pen.lopnStyle;
 456             logpen.lopnWidth.x = pen.lopnWidth.x;
 457             logpen.lopnWidth.y = pen.lopnWidth.y;
 458             logpen.lopnColor   = pen.lopnColor;
 459         }
 460         else  /* must be an extended pen */
 461         {
 462             EXTLOGPEN *elp = HeapAlloc( GetProcessHeap(), 0, size );
 463
 464             GetObjectW( hpen, size, elp );
 465             /* FIXME: add support for user style pens */
 466             logpen.lopnStyle = elp->elpPenStyle;
 467             logpen.lopnWidth.x = elp->elpWidth;
 468             logpen.lopnWidth.y = 0;
 469             logpen.lopnColor = elp->elpColor;
 470
 471             HeapFree( GetProcessHeap(), 0, elp );
 472         }
 473
 474         index = MFDRV_CreatePenIndirect( dev, hpen, &logpen );
 475         if( index < 0 )
 476             return 0;
 477         GDI_hdc_using_object(hpen, physDev->hdc);
 478     }
 479     return MFDRV_SelectObject( dev, index ) ? hpen : HGDI_ERROR;
 480 }
 481
 482
 483 /******************************************************************
 484  *         MFDRV_CreatePalette
 485  */
 486 static BOOL MFDRV_CreatePalette(PHYSDEV dev, HPALETTE hPalette, LOGPALETTE* logPalette, int sizeofPalette)
 487 {
 488     int index;
 489     BOOL ret;
 490     METARECORD *mr;
 491
 492     mr = HeapAlloc( GetProcessHeap(), 0, sizeof(METARECORD) + sizeofPalette - sizeof(WORD) );
 493     mr->rdSize = (sizeof(METARECORD) + sizeofPalette - sizeof(WORD)) / sizeof(WORD);
 494     mr->rdFunction = META_CREATEPALETTE;
 495     memcpy(&(mr->rdParm), logPalette, sizeofPalette);
 496     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD))))
 497     {
 498         HeapFree(GetProcessHeap(), 0, mr);
 499         return FALSE;
 500     }
 501
 502     mr->rdSize = sizeof(METARECORD) / sizeof(WORD);
 503     mr->rdFunction = META_SELECTPALETTE;
 504
 505     if ((index = MFDRV_AddHandle( dev, hPalette )) == -1) ret = FALSE;
 506     else
 507     {
 508         *(mr->rdParm) = index;
 509         ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD));
 510     }
 511     HeapFree(GetProcessHeap(), 0, mr);
 512     return ret;
 513 }
 514
 515
 516 /***********************************************************************
 517  *           MFDRV_SelectPalette
 518  */
 519 HPALETTE CDECL MFDRV_SelectPalette( PHYSDEV dev, HPALETTE hPalette, BOOL bForceBackground )
 520 {
 521 #define PALVERSION 0x0300
 522
 523     PLOGPALETTE logPalette;
 524     WORD        wNumEntries = 0;
 525     BOOL        creationSucceed;
 526     int         sizeofPalette;
 527
 528     GetObjectA(hPalette, sizeof(WORD), &wNumEntries);
 529
 530     if (wNumEntries == 0) return 0;
 531
 532     sizeofPalette = sizeof(LOGPALETTE) + ((wNumEntries-1) * sizeof(PALETTEENTRY));
 533     logPalette = HeapAlloc( GetProcessHeap(), 0, sizeofPalette );
 534
 535     if (logPalette == NULL) return 0;
 536
 537     logPalette->palVersion = PALVERSION;
 538     logPalette->palNumEntries = wNumEntries;
 539
 540     GetPaletteEntries(hPalette, 0, wNumEntries, logPalette->palPalEntry);
 541
 542     creationSucceed = MFDRV_CreatePalette( dev, hPalette, logPalette, sizeofPalette );
 543
 544     HeapFree( GetProcessHeap(), 0, logPalette );
 545
 546     if (creationSucceed)
 547         return hPalette;
 548
 549     return 0;
 550 }
 551
 552 /***********************************************************************
 553  *           MFDRV_RealizePalette
 554  */
 555 UINT CDECL MFDRV_RealizePalette(PHYSDEV dev, HPALETTE hPalette, BOOL dummy)
 556 {
 557     char buffer[sizeof(METARECORD) - sizeof(WORD)];
 558     METARECORD *mr = (METARECORD *)&buffer;
 559
 560     mr->rdSize = (sizeof(METARECORD) - sizeof(WORD)) / sizeof(WORD);
 561     mr->rdFunction = META_REALIZEPALETTE;
 562
 563     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD)))) return 0;
 564
 565     /* The return value is suppose to be the number of entries
 566        in the logical palette mapped to the system palette or 0
 567        if the function failed. Since it's not trivial here to
 568        get that kind of information and since it's of little
 569        use in the case of metafiles, we'll always return 1. */
 570     return 1;
 571 }