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 "wine/wingdi16.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     BOOL r;
 218
 219     if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return -1;
 220
 221     switch(logbrush.lbStyle)
 222     {
 223     case BS_SOLID:
 224     case BS_NULL:
 225     case BS_HATCHED:
 226         {
 227             LOGBRUSH16 lb16;
 228
 229             lb16.lbStyle = logbrush.lbStyle;
 230             lb16.lbColor = logbrush.lbColor;
 231             lb16.lbHatch = logbrush.lbHatch;
 232             size = sizeof(METARECORD) + sizeof(LOGBRUSH16) - 2;
 233             mr = HeapAlloc( GetProcessHeap(), 0, size );
 234             mr->rdSize = size / 2;
 235             mr->rdFunction = META_CREATEBRUSHINDIRECT;
 236             memcpy( mr->rdParm, &lb16, sizeof(LOGBRUSH16));
 237             break;
 238         }
 239     case BS_PATTERN:
 240         {
 241             BITMAP bm;
 242             BITMAPINFO *info;
 243             DWORD bmSize;
 244             COLORREF cref;
 245
 246             GetObjectA((HANDLE)logbrush.lbHatch, sizeof(bm), &bm);
 247             if(bm.bmBitsPixel != 1 || bm.bmPlanes != 1) {
 248                 FIXME("Trying to store a colour pattern brush\n");
 249                 goto done;
 250             }
 251
 252             bmSize = get_dib_stride( bm.bmWidth, bm.bmBitsPixel) * bm.bmHeight;
 253
 254             size = sizeof(METARECORD) + sizeof(WORD) + sizeof(BITMAPINFO) +
 255               sizeof(RGBQUAD) + bmSize;
 256
 257             mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 258             if(!mr) goto done;
 259             mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 260             mr->rdSize = size / 2;
 261             mr->rdParm[0] = BS_PATTERN;
 262             mr->rdParm[1] = DIB_RGB_COLORS;
 263             info = (BITMAPINFO *)(mr->rdParm + 2);
 264
 265             info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 266             info->bmiHeader.biWidth = bm.bmWidth;
 267             info->bmiHeader.biHeight = bm.bmHeight;
 268             info->bmiHeader.biPlanes = 1;
 269             info->bmiHeader.biBitCount = 1;
 270             info->bmiHeader.biSizeImage = bmSize;
 271
 272             GetBitmapBits((HANDLE)logbrush.lbHatch,
 273                       bm.bmHeight * get_bitmap_stride(bm.bmWidth, bm.bmBitsPixel),
 274                       (LPBYTE)info + sizeof(BITMAPINFO) + sizeof(RGBQUAD));
 275
 276             /* Change the padding to be DIB compatible if needed */
 277             if(bm.bmWidth & 31)
 278                 MFDRV_PadTo32((LPBYTE)info + sizeof(BITMAPINFO) + sizeof(RGBQUAD),
 279                       bm.bmWidth, bm.bmHeight);
 280             /* BMP and DIB have opposite row order conventions */
 281             MFDRV_Reverse((LPBYTE)info + sizeof(BITMAPINFO) + sizeof(RGBQUAD),
 282                       bm.bmWidth, bm.bmHeight);
 283
 284             cref = GetTextColor( dev->hdc );
 285             info->bmiColors[0].rgbRed = GetRValue(cref);
 286             info->bmiColors[0].rgbGreen = GetGValue(cref);
 287             info->bmiColors[0].rgbBlue = GetBValue(cref);
 288             info->bmiColors[0].rgbReserved = 0;
 289             cref = GetBkColor( dev->hdc );
 290             info->bmiColors[1].rgbRed = GetRValue(cref);
 291             info->bmiColors[1].rgbGreen = GetGValue(cref);
 292             info->bmiColors[1].rgbBlue = GetBValue(cref);
 293             info->bmiColors[1].rgbReserved = 0;
 294             break;
 295         }
 296
 297     case BS_DIBPATTERN:
 298         {
 299               BITMAPINFO *info;
 300               DWORD bmSize, biSize;
 301
 302               info = GlobalLock( (HGLOBAL)logbrush.lbHatch );
 303               if (info->bmiHeader.biCompression)
 304                   bmSize = info->bmiHeader.biSizeImage;
 305               else
 306                   bmSize = get_dib_image_size( info );
 307               biSize = bitmap_info_size(info, LOWORD(logbrush.lbColor));
 308               size = sizeof(METARECORD) + biSize + bmSize + 2;
 309               mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 310               if (!mr)
 311               {
 312                   GlobalUnlock( (HGLOBAL)logbrush.lbHatch );
 313                   goto done;
 314               }
 315               mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 316               mr->rdSize = size / 2;
 317               *(mr->rdParm) = logbrush.lbStyle;
 318               *(mr->rdParm + 1) = LOWORD(logbrush.lbColor);
 319               memcpy(mr->rdParm + 2, info, biSize + bmSize);
 320               GlobalUnlock( (HGLOBAL)logbrush.lbHatch );
 321               break;
 322         }
 323         default:
 324             FIXME("Unkonwn brush style %x\n", logbrush.lbStyle);
 325             return 0;
 326     }
 327     r = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 328     HeapFree(GetProcessHeap(), 0, mr);
 329     if( !r )
 330         return -1;
 331 done:
 332     return MFDRV_AddHandle( dev, hBrush );
 333 }
 334
 335
 336 /***********************************************************************
 337  *           MFDRV_SelectBrush
 338  */
 339 HBRUSH MFDRV_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
 340 {
 341     INT16 index;
 342
 343     index = MFDRV_FindObject(dev, hbrush);
 344     if( index < 0 )
 345     {
 346         index = MFDRV_CreateBrushIndirect( dev, hbrush );
 347         if( index < 0 )
 348             return 0;
 349         GDI_hdc_using_object(hbrush, dev->hdc);
 350     }
 351     return MFDRV_SelectObject( dev, index ) ? hbrush : HGDI_ERROR;
 352 }
 353
 354 /******************************************************************
 355  *         MFDRV_CreateFontIndirect
 356  */
 357
 358 static UINT16 MFDRV_CreateFontIndirect(PHYSDEV dev, HFONT hFont, LOGFONTW *logfont)
 359 {
 360     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
 361     METARECORD *mr = (METARECORD *)&buffer;
 362     LOGFONT16 *font16;
 363     INT written;
 364
 365     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
 366     mr->rdFunction = META_CREATEFONTINDIRECT;
 367     font16 = (LOGFONT16 *)&mr->rdParm;
 368
 369     font16->lfHeight         = logfont->lfHeight;
 370     font16->lfWidth          = logfont->lfWidth;
 371     font16->lfEscapement     = logfont->lfEscapement;
 372     font16->lfOrientation    = logfont->lfOrientation;
 373     font16->lfWeight         = logfont->lfWeight;
 374     font16->lfItalic         = logfont->lfItalic;
 375     font16->lfUnderline      = logfont->lfUnderline;
 376     font16->lfStrikeOut      = logfont->lfStrikeOut;
 377     font16->lfCharSet        = logfont->lfCharSet;
 378     font16->lfOutPrecision   = logfont->lfOutPrecision;
 379     font16->lfClipPrecision  = logfont->lfClipPrecision;
 380     font16->lfQuality        = logfont->lfQuality;
 381     font16->lfPitchAndFamily = logfont->lfPitchAndFamily;
 382     written = WideCharToMultiByte( CP_ACP, 0, logfont->lfFaceName, -1, font16->lfFaceName, LF_FACESIZE - 1, NULL, NULL );
 383     /* Zero pad the facename buffer, so that we don't write uninitialized data to disk */
 384     memset(font16->lfFaceName + written, 0, LF_FACESIZE - written);
 385
 386     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
 387         return 0;
 388     return MFDRV_AddHandle( dev, hFont );
 389 }
 390
 391
 392 /***********************************************************************
 393  *           MFDRV_SelectFont
 394  */
 395 HFONT MFDRV_SelectFont( PHYSDEV dev, HFONT hfont, HANDLE gdiFont )
 396 {
 397     LOGFONTW font;
 398     INT16 index;
 399
 400     index = MFDRV_FindObject(dev, hfont);
 401     if( index < 0 )
 402     {
 403         if (!GetObjectW( hfont, sizeof(font), &font ))
 404             return HGDI_ERROR;
 405         index = MFDRV_CreateFontIndirect(dev, hfont, &font);
 406         if( index < 0 )
 407             return HGDI_ERROR;
 408         GDI_hdc_using_object(hfont, dev->hdc);
 409     }
 410     return MFDRV_SelectObject( dev, index ) ? hfont : HGDI_ERROR;
 411 }
 412
 413 /******************************************************************
 414  *         MFDRV_CreatePenIndirect
 415  */
 416 static UINT16 MFDRV_CreatePenIndirect(PHYSDEV dev, HPEN hPen, LOGPEN16 *logpen)
 417 {
 418     char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
 419     METARECORD *mr = (METARECORD *)&buffer;
 420
 421     mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
 422     mr->rdFunction = META_CREATEPENINDIRECT;
 423     memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
 424     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
 425         return 0;
 426     return MFDRV_AddHandle( dev, hPen );
 427 }
 428
 429
 430 /***********************************************************************
 431  *           MFDRV_SelectPen
 432  */
 433 HPEN MFDRV_SelectPen( PHYSDEV dev, HPEN hpen )
 434 {
 435     LOGPEN16 logpen;
 436     INT16 index;
 437
 438     index = MFDRV_FindObject(dev, hpen);
 439     if( index < 0 )
 440     {
 441         /* must be an extended pen */
 442         INT size = GetObjectW( hpen, 0, NULL );
 443
 444         if (!size) return 0;
 445
 446         if (size == sizeof(LOGPEN))
 447         {
 448             LOGPEN pen;
 449
 450             GetObjectW( hpen, sizeof(pen), &pen );
 451             logpen.lopnStyle   = pen.lopnStyle;
 452             logpen.lopnWidth.x = pen.lopnWidth.x;
 453             logpen.lopnWidth.y = pen.lopnWidth.y;
 454             logpen.lopnColor   = pen.lopnColor;
 455         }
 456         else  /* must be an extended pen */
 457         {
 458             EXTLOGPEN *elp = HeapAlloc( GetProcessHeap(), 0, size );
 459
 460             GetObjectW( hpen, size, elp );
 461             /* FIXME: add support for user style pens */
 462             logpen.lopnStyle = elp->elpPenStyle;
 463             logpen.lopnWidth.x = elp->elpWidth;
 464             logpen.lopnWidth.y = 0;
 465             logpen.lopnColor = elp->elpColor;
 466
 467             HeapFree( GetProcessHeap(), 0, elp );
 468         }
 469
 470         index = MFDRV_CreatePenIndirect( dev, hpen, &logpen );
 471         if( index < 0 )
 472             return 0;
 473         GDI_hdc_using_object(hpen, dev->hdc);
 474     }
 475     return MFDRV_SelectObject( dev, index ) ? hpen : HGDI_ERROR;
 476 }
 477
 478
 479 /******************************************************************
 480  *         MFDRV_CreatePalette
 481  */
 482 static BOOL MFDRV_CreatePalette(PHYSDEV dev, HPALETTE hPalette, LOGPALETTE* logPalette, int sizeofPalette)
 483 {
 484     int index;
 485     BOOL ret;
 486     METARECORD *mr;
 487
 488     mr = HeapAlloc( GetProcessHeap(), 0, sizeof(METARECORD) + sizeofPalette - sizeof(WORD) );
 489     mr->rdSize = (sizeof(METARECORD) + sizeofPalette - sizeof(WORD)) / sizeof(WORD);
 490     mr->rdFunction = META_CREATEPALETTE;
 491     memcpy(&(mr->rdParm), logPalette, sizeofPalette);
 492     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD))))
 493     {
 494         HeapFree(GetProcessHeap(), 0, mr);
 495         return FALSE;
 496     }
 497
 498     mr->rdSize = sizeof(METARECORD) / sizeof(WORD);
 499     mr->rdFunction = META_SELECTPALETTE;
 500
 501     if ((index = MFDRV_AddHandle( dev, hPalette )) == -1) ret = FALSE;
 502     else
 503     {
 504         *(mr->rdParm) = index;
 505         ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD));
 506     }
 507     HeapFree(GetProcessHeap(), 0, mr);
 508     return ret;
 509 }
 510
 511
 512 /***********************************************************************
 513  *           MFDRV_SelectPalette
 514  */
 515 HPALETTE MFDRV_SelectPalette( PHYSDEV dev, HPALETTE hPalette, BOOL bForceBackground )
 516 {
 517 #define PALVERSION 0x0300
 518
 519     PLOGPALETTE logPalette;
 520     WORD        wNumEntries = 0;
 521     BOOL        creationSucceed;
 522     int         sizeofPalette;
 523
 524     GetObjectA(hPalette, sizeof(WORD), &wNumEntries);
 525
 526     if (wNumEntries == 0) return 0;
 527
 528     sizeofPalette = sizeof(LOGPALETTE) + ((wNumEntries-1) * sizeof(PALETTEENTRY));
 529     logPalette = HeapAlloc( GetProcessHeap(), 0, sizeofPalette );
 530
 531     if (logPalette == NULL) return 0;
 532
 533     logPalette->palVersion = PALVERSION;
 534     logPalette->palNumEntries = wNumEntries;
 535
 536     GetPaletteEntries(hPalette, 0, wNumEntries, logPalette->palPalEntry);
 537
 538     creationSucceed = MFDRV_CreatePalette( dev, hPalette, logPalette, sizeofPalette );
 539
 540     HeapFree( GetProcessHeap(), 0, logPalette );
 541
 542     if (creationSucceed)
 543         return hPalette;
 544
 545     return 0;
 546 }
 547
 548 /***********************************************************************
 549  *           MFDRV_RealizePalette
 550  */
 551 UINT MFDRV_RealizePalette(PHYSDEV dev, HPALETTE hPalette, BOOL dummy)
 552 {
 553     char buffer[sizeof(METARECORD) - sizeof(WORD)];
 554     METARECORD *mr = (METARECORD *)&buffer;
 555
 556     mr->rdSize = (sizeof(METARECORD) - sizeof(WORD)) / sizeof(WORD);
 557     mr->rdFunction = META_REALIZEPALETTE;
 558
 559     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD)))) return 0;
 560
 561     /* The return value is suppose to be the number of entries
 562        in the logical palette mapped to the system palette or 0
 563        if the function failed. Since it's not trivial here to
 564        get that kind of information and since it's of little
 565        use in the case of metafiles, we'll always return 1. */
 566     return 1;
 567 }