objects/metafile.c

   1 /*
   2  * Metafile functions
   3  *
   4  * Copyright  David W. Metcalfe, 1994
   5  *            Niels de Carpentier, Albrecht Kleine, Huw Davies 1996
   6  *
   7  */
   8
   9 #include <string.h>
  10 #include <fcntl.h>
  11 #include "gdi.h"
  12 #include "bitmap.h"
  13 #include "file.h"
  14 #include "heap.h"
  15 #include "metafile.h"
  16 #include "metafiledrv.h"
  17 #include "stddebug.h"
  18 #include "debug.h"
  19
  20 /******************************************************************
  21  *         MF_AddHandle
  22  *
  23  *    Add a handle to an external handle table and return the index
  24  */
  25
  26 static int MF_AddHandle(HANDLETABLE16 *ht, WORD htlen, HGDIOBJ16 hobj)
  27 {
  28     int i;
  29
  30     for (i = 0; i < htlen; i++)
  31     {
  32         if (*(ht->objectHandle + i) == 0)
  33         {
  34             *(ht->objectHandle + i) = hobj;
  35             return i;
  36         }
  37     }
  38     return -1;
  39 }
  40
  41
  42 /******************************************************************
  43  *         MF_AddHandleDC
  44  *
  45  * Note: this function assumes that we never delete objects.
  46  * If we do someday, we'll need to maintain a table to re-use deleted
  47  * handles.
  48  */
  49 static int MF_AddHandleDC( DC *dc )
  50 {
  51     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
  52     physDev->mh->mtNoObjects++;
  53     return physDev->nextHandle++;
  54 }
  55
  56
  57 /******************************************************************
  58  *         GetMetafile16   (GDI.124)
  59  */
  60 HMETAFILE16 GetMetaFile16( LPCSTR lpFilename )
  61 {
  62     return GetMetaFile32A( lpFilename );
  63 }
  64
  65
  66 /******************************************************************
  67  *         GetMetafile32A   (GDI32.197)
  68  */
  69 HMETAFILE32 GetMetaFile32A( LPCSTR lpFilename )
  70 {
  71   HMETAFILE16 hmf;
  72   METAHEADER *mh;
  73   HFILE32 hFile;
  74   DWORD size;
  75
  76   dprintf_metafile(stddeb,"GetMetaFile: %s\n", lpFilename);
  77
  78   if (!lpFilename)
  79     return 0;
  80
  81   hmf = GlobalAlloc16(GMEM_MOVEABLE, MFHEADERSIZE);
  82   mh = (METAHEADER *)GlobalLock16(hmf);
  83
  84   if (!mh)
  85   {
  86     GlobalFree16(hmf);
  87     return 0;
  88   }
  89
  90   if ((hFile = _lopen32(lpFilename, OF_READ)) == HFILE_ERROR32)
  91   {
  92     GlobalFree16(hmf);
  93     return 0;
  94   }
  95
  96   if (_lread32(hFile, (char *)mh, MFHEADERSIZE) == HFILE_ERROR32)
  97   {
  98     _lclose32( hFile );
  99     GlobalFree16(hmf);
 100     return 0;
 101   }
 102
 103   size = mh->mtSize * 2;         /* alloc memory for whole metafile */
 104   GlobalUnlock16(hmf);
 105   hmf = GlobalReAlloc16(hmf,size,GMEM_MOVEABLE);
 106   mh = (METAHEADER *)GlobalLock16(hmf);
 107
 108   if (!mh)
 109   {
 110     _lclose32( hFile );
 111     GlobalFree16(hmf);
 112     return 0;
 113   }
 114
 115   if (_lread32(hFile, (char*)mh + mh->mtHeaderSize * 2,
 116                 size - mh->mtHeaderSize * 2) == HFILE_ERROR32)
 117   {
 118     _lclose32( hFile );
 119     GlobalFree16(hmf);
 120     return 0;
 121   }
 122
 123   _lclose32(hFile);
 124
 125   if (mh->mtType != 1)
 126   {
 127     GlobalFree16(hmf);
 128     return 0;
 129   }
 130
 131   GlobalUnlock16(hmf);
 132   return hmf;
 133
 134 }
 135
 136
 137 /******************************************************************
 138  *         GetMetafile32W   (GDI32.199)
 139  */
 140 HMETAFILE32 GetMetaFile32W( LPCWSTR lpFilename )
 141 {
 142     LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFilename );
 143     HMETAFILE32 ret = GetMetaFile32A( p );
 144     HeapFree( GetProcessHeap(), 0, p );
 145     return ret;
 146 }
 147
 148
 149 /******************************************************************
 150  *         CopyMetaFile16   (GDI.151)
 151  */
 152
 153 HMETAFILE16 CopyMetaFile16( HMETAFILE16 hSrcMetaFile, LPCSTR lpFilename )
 154 {
 155     return CopyMetaFile32A( hSrcMetaFile, lpFilename );
 156 }
 157
 158
 159 /******************************************************************
 160  *         CopyMetaFile32A   (GDI32.23)
 161  */
 162 HMETAFILE32 CopyMetaFile32A( HMETAFILE32 hSrcMetaFile, LPCSTR lpFilename )
 163 {
 164     HMETAFILE16 handle = 0;
 165     METAHEADER *mh;
 166     METAHEADER *mh2;
 167     HFILE32 hFile;
 168
 169     dprintf_metafile(stddeb,"CopyMetaFile: %s\n", lpFilename);
 170
 171     mh = (METAHEADER *)GlobalLock16(hSrcMetaFile);
 172
 173     if (!mh)
 174       return 0;
 175
 176     if (lpFilename)          /* disk based metafile */
 177         {
 178         int i,j;
 179         hFile = _lcreat32(lpFilename, 0);
 180         j=mh->mtType;
 181         mh->mtType=1;        /* disk file version stores 1 here */
 182         i=_lwrite32(hFile, (char *)mh, mh->mtSize * 2) ;
 183         mh->mtType=j;        /* restore old value  [0 or 1] */
 184         _lclose32(hFile);
 185         if (i == -1)
 186             return 0;
 187         /* FIXME: return value */
 188         }
 189     else                     /* memory based metafile */
 190         {
 191         handle = GlobalAlloc16(GMEM_MOVEABLE,mh->mtSize * 2);
 192         mh2 = (METAHEADER *)GlobalLock16(handle);
 193         memcpy(mh2,mh, mh->mtSize * 2);
 194         GlobalUnlock16(handle);
 195         }
 196
 197     return handle;
 198 }
 199
 200
 201 /******************************************************************
 202  *         CopyMetaFile32W   (GDI32.24)
 203  */
 204 HMETAFILE32 CopyMetaFile32W( HMETAFILE32 hSrcMetaFile, LPCWSTR lpFilename )
 205 {
 206     LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFilename );
 207     HMETAFILE32 ret = CopyMetaFile32A( hSrcMetaFile, p );
 208     HeapFree( GetProcessHeap(), 0, p );
 209     return ret;
 210 }
 211
 212
 213 /******************************************************************
 214  *         IsValidMetaFile   (GDI.410)
 215  *         (This is not exactly what windows does, see "Undoc Win")
 216  */
 217
 218 BOOL16 IsValidMetaFile(HMETAFILE16 hmf)
 219 {
 220     BOOL16 resu=FALSE;
 221     METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
 222     if (mh) {
 223       if (mh->mtType == 1 || mh->mtType == 0)
 224         if (mh->mtHeaderSize == MFHEADERSIZE/sizeof(INT16))
 225           if (mh->mtVersion == MFVERSION)
 226             resu=TRUE;
 227       GlobalUnlock16(hmf);
 228     }
 229     dprintf_metafile(stddeb,"IsValidMetaFile %x => %d\n",hmf,resu);
 230     return resu;
 231 }
 232
 233
 234 /******************************************************************
 235  *         PlayMetafile16   (GDI.123)
 236  */
 237 BOOL16 PlayMetaFile16( HDC16 hdc, HMETAFILE16 hmf )
 238 {
 239     return PlayMetaFile32( hdc, hmf );
 240 }
 241
 242
 243 /******************************************************************
 244  *         PlayMetafile32   (GDI32.265)
 245  */
 246 BOOL32 PlayMetaFile32( HDC32 hdc, HMETAFILE32 hmf )
 247 {
 248     METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
 249     METARECORD *mr;
 250     HANDLETABLE16 *ht;
 251     HGLOBAL16 hHT;
 252     int offset = 0;
 253     WORD i;
 254     HPEN32 hPen;
 255     HBRUSH32 hBrush;
 256     HFONT32 hFont;
 257     DC *dc;
 258
 259     dprintf_metafile(stddeb,"PlayMetaFile(%04x %04x)\n",hdc,hmf);
 260
 261     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 262     hPen = dc->w.hPen;
 263     hBrush = dc->w.hBrush;
 264     hFont = dc->w.hFont;
 265
 266     /* create the handle table */
 267     hHT = GlobalAlloc16(GMEM_MOVEABLE|GMEM_ZEROINIT,
 268                       sizeof(HANDLETABLE16) * mh->mtNoObjects);
 269     ht = (HANDLETABLE16 *)GlobalLock16(hHT);
 270
 271     /* loop through metafile playing records */
 272     offset = mh->mtHeaderSize * 2;
 273     while (offset < mh->mtSize * 2)
 274     {
 275         mr = (METARECORD *)((char *)mh + offset);
 276         dprintf_metafile(stddeb,"offset = %04x size = %08lx function = %04x\n",
 277                          offset,mr->rdSize,mr->rdFunction);
 278         offset += mr->rdSize * 2;
 279         PlayMetaFileRecord16( hdc, ht, mr, mh->mtNoObjects );
 280     }
 281
 282     SelectObject32(hdc, hBrush);
 283     SelectObject32(hdc, hPen);
 284     SelectObject32(hdc, hFont);
 285
 286     /* free objects in handle table */
 287     for(i = 0; i < mh->mtNoObjects; i++)
 288       if(*(ht->objectHandle + i) != 0)
 289         DeleteObject32(*(ht->objectHandle + i));
 290
 291     /* free handle table */
 292     GlobalFree16(hHT);
 293
 294     return TRUE;
 295 }
 296
 297
 298 /******************************************************************
 299  *            EnumMetaFile16   (GDI.175)
 300  *                                    Niels de carpentier, april 1996
 301  */
 302 BOOL16 EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf, MFENUMPROC16 lpEnumFunc,
 303                        LPARAM lpData )
 304 {
 305     METAHEADER *mh = (METAHEADER *)GlobalLock16(hmf);
 306     METARECORD *mr;
 307     HGLOBAL16 hHT;
 308     SEGPTR ht, spRecord;
 309     int offset = 0;
 310
 311     dprintf_metafile(stddeb,"EnumMetaFile(%04x, %04x, %08lx, %08lx)\n",
 312                      hdc, hmf, (DWORD)lpEnumFunc, lpData);
 313
 314     /* create the handle table */
 315
 316     hHT = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT,
 317                      sizeof(HANDLETABLE16) * mh->mtNoObjects);
 318     ht = WIN16_GlobalLock16(hHT);
 319
 320     offset = mh->mtHeaderSize * 2;
 321
 322     /* loop through metafile records */
 323
 324     spRecord = WIN16_GlobalLock16(hmf);
 325     while (offset < (mh->mtSize * 2))
 326     {
 327         mr = (METARECORD *)((char *)mh + offset);
 328         if (!lpEnumFunc( hdc, (HANDLETABLE16 *)ht,
 329                          (METARECORD *)((UINT32)spRecord + offset),
 330                          mh->mtNoObjects, (LONG)lpData))
 331             break;
 332
 333         offset += (mr->rdSize * 2);
 334     }
 335
 336     /* free handle table */
 337     GlobalFree16(hHT);
 338
 339     return TRUE;
 340 }
 341
 342
 343 /******************************************************************
 344  *             PlayMetaFileRecord16   (GDI.176)
 345  */
 346 void PlayMetaFileRecord16( HDC16 hdc, HANDLETABLE16 *ht, METARECORD *mr,
 347                            UINT16 nHandles )
 348 {
 349     short s1;
 350     HANDLE16 hndl;
 351     char *ptr;
 352     BITMAPINFOHEADER *infohdr;
 353
 354     dprintf_metafile(stddeb,"PlayMetaFileRecord(%04x %08lx %08lx %04x)\n",
 355                      hdc,(LONG)ht, (LONG)mr, nHandles);
 356
 357     switch (mr->rdFunction)
 358     {
 359     case META_EOF:
 360       break;
 361
 362     case META_DELETEOBJECT:
 363       DeleteObject32(*(ht->objectHandle + *(mr->rdParam)));
 364       *(ht->objectHandle + *(mr->rdParam)) = 0;
 365       break;
 366
 367     case META_SETBKCOLOR:
 368         SetBkColor16(hdc, MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 369         break;
 370
 371     case META_SETBKMODE:
 372         SetBkMode16(hdc, *(mr->rdParam));
 373         break;
 374
 375     case META_SETMAPMODE:
 376         SetMapMode16(hdc, *(mr->rdParam));
 377         break;
 378
 379     case META_SETROP2:
 380         SetROP216(hdc, *(mr->rdParam));
 381         break;
 382
 383     case META_SETRELABS:
 384         SetRelAbs16(hdc, *(mr->rdParam));
 385         break;
 386
 387     case META_SETPOLYFILLMODE:
 388         SetPolyFillMode16(hdc, *(mr->rdParam));
 389         break;
 390
 391     case META_SETSTRETCHBLTMODE:
 392         SetStretchBltMode16(hdc, *(mr->rdParam));
 393         break;
 394     case META_SETTEXTCOLOR:
 395         SetTextColor16(hdc, MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 396         break;
 397
 398     case META_SETWINDOWORG:
 399         SetWindowOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 400         break;
 401
 402     case META_SETWINDOWEXT:
 403         SetWindowExt(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 404         break;
 405
 406     case META_SETVIEWPORTORG:
 407         SetViewportOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 408         break;
 409
 410     case META_SETVIEWPORTEXT:
 411         SetViewportExt(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 412         break;
 413
 414     case META_OFFSETWINDOWORG:
 415         OffsetWindowOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 416         break;
 417
 418     case META_SCALEWINDOWEXT:
 419         ScaleWindowExt(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 420                        *(mr->rdParam + 1), *(mr->rdParam));
 421         break;
 422
 423     case META_OFFSETVIEWPORTORG:
 424         OffsetViewportOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 425         break;
 426
 427     case META_SCALEVIEWPORTEXT:
 428         ScaleViewportExt(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 429                          *(mr->rdParam + 1), *(mr->rdParam));
 430         break;
 431
 432     case META_LINETO:
 433         LineTo32(hdc, (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 434         break;
 435
 436     case META_MOVETO:
 437         MoveTo(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 438         break;
 439
 440     case META_EXCLUDECLIPRECT:
 441         ExcludeClipRect16( hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 442                            *(mr->rdParam + 1), *(mr->rdParam) );
 443         break;
 444
 445     case META_INTERSECTCLIPRECT:
 446         IntersectClipRect16( hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 447                              *(mr->rdParam + 1), *(mr->rdParam) );
 448         break;
 449
 450     case META_ARC:
 451         Arc32(hdc, (INT16)*(mr->rdParam + 7), (INT16)*(mr->rdParam + 6),
 452               (INT16)*(mr->rdParam + 5), (INT16)*(mr->rdParam + 4),
 453               (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 454              (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 455         break;
 456
 457     case META_ELLIPSE:
 458         Ellipse32(hdc, (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 459                   (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 460         break;
 461
 462     case META_FLOODFILL:
 463         FloodFill32(hdc, (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 464                     MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 465         break;
 466
 467     case META_PIE:
 468         Pie32(hdc, (INT16)*(mr->rdParam + 7), (INT16)*(mr->rdParam + 6),
 469               (INT16)*(mr->rdParam + 5), (INT16)*(mr->rdParam + 4),
 470               (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 471              (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 472         break;
 473
 474     case META_RECTANGLE:
 475         Rectangle32(hdc, (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 476                     (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 477         break;
 478
 479     case META_ROUNDRECT:
 480         RoundRect32(hdc, (INT16)*(mr->rdParam + 5), (INT16)*(mr->rdParam + 4),
 481                     (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 482                     (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 483         break;
 484
 485     case META_PATBLT:
 486         PatBlt16(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
 487                  *(mr->rdParam + 3), *(mr->rdParam + 2),
 488                  MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 489         break;
 490
 491     case META_SAVEDC:
 492         SaveDC32(hdc);
 493         break;
 494
 495     case META_SETPIXEL:
 496         SetPixel32(hdc, (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 497                    MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 498         break;
 499
 500     case META_OFFSETCLIPRGN:
 501         OffsetClipRgn16( hdc, *(mr->rdParam + 1), *(mr->rdParam) );
 502         break;
 503
 504     case META_TEXTOUT:
 505         s1 = *(mr->rdParam);
 506         TextOut16(hdc, *(mr->rdParam + ((s1 + 1) >> 1) + 2),
 507                   *(mr->rdParam + ((s1 + 1) >> 1) + 1),
 508                   (char *)(mr->rdParam + 1), s1);
 509         break;
 510
 511     case META_POLYGON:
 512         Polygon16(hdc, (LPPOINT16)(mr->rdParam + 1), *(mr->rdParam));
 513         break;
 514
 515     case META_POLYPOLYGON:
 516       PolyPolygon16(hdc, (LPPOINT16)(mr->rdParam + *(mr->rdParam) + 1),
 517                     (LPINT16)(mr->rdParam + 1), *(mr->rdParam));
 518       break;
 519
 520     case META_POLYLINE:
 521         Polyline16(hdc, (LPPOINT16)(mr->rdParam + 1), *(mr->rdParam));
 522         break;
 523
 524     case META_RESTOREDC:
 525         RestoreDC32(hdc, (INT16)*(mr->rdParam));
 526         break;
 527
 528     case META_SELECTOBJECT:
 529         SelectObject32(hdc, *(ht->objectHandle + *(mr->rdParam)));
 530         break;
 531
 532     case META_CHORD:
 533         Chord32(hdc, (INT16)*(mr->rdParam + 7), (INT16)*(mr->rdParam + 6),
 534                 (INT16)*(mr->rdParam+5), (INT16)*(mr->rdParam + 4),
 535                 (INT16)*(mr->rdParam + 3), (INT16)*(mr->rdParam + 2),
 536                (INT16)*(mr->rdParam + 1), (INT16)*(mr->rdParam));
 537         break;
 538
 539     case META_CREATEPATTERNBRUSH:
 540         switch (*(mr->rdParam))
 541         {
 542         case BS_PATTERN:
 543             infohdr = (BITMAPINFOHEADER *)(mr->rdParam + 2);
 544             MF_AddHandle(ht, nHandles,
 545                          CreatePatternBrush32(CreateBitmap32(infohdr->biWidth,
 546                                       infohdr->biHeight,
 547                                       infohdr->biPlanes,
 548                                       infohdr->biBitCount,
 549                                       (LPSTR)(mr->rdParam +
 550                                       (sizeof(BITMAPINFOHEADER) / 2) + 4))));
 551             break;
 552
 553         case BS_DIBPATTERN:
 554             s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
 555             hndl = GlobalAlloc16(GMEM_MOVEABLE, s1);
 556             ptr = GlobalLock16(hndl);
 557             memcpy(ptr, mr->rdParam + 2, s1);
 558             GlobalUnlock16(hndl);
 559             MF_AddHandle(ht, nHandles,
 560                          CreateDIBPatternBrush32(hndl, *(mr->rdParam + 1)));
 561             GlobalFree16(hndl);
 562         }
 563         break;
 564
 565     case META_CREATEPENINDIRECT:
 566         MF_AddHandle(ht, nHandles,
 567                      CreatePenIndirect16((LOGPEN16 *)(&(mr->rdParam))));
 568         break;
 569
 570     case META_CREATEFONTINDIRECT:
 571         MF_AddHandle(ht, nHandles,
 572                      CreateFontIndirect16((LOGFONT16 *)(&(mr->rdParam))));
 573         break;
 574
 575     case META_CREATEBRUSHINDIRECT:
 576         MF_AddHandle(ht, nHandles,
 577                      CreateBrushIndirect16((LOGBRUSH16 *)(&(mr->rdParam))));
 578         break;
 579
 580     /* W. Magro: Some new metafile operations.  Not all debugged. */
 581     case META_CREATEPALETTE:
 582         MF_AddHandle(ht, nHandles,
 583                      CreatePalette16((LPLOGPALETTE)mr->rdParam));
 584         break;
 585
 586     case META_SETTEXTALIGN:
 587         SetTextAlign16(hdc, *(mr->rdParam));
 588         break;
 589
 590     case META_SELECTPALETTE:
 591         SelectPalette16(hdc, *(ht->objectHandle + *(mr->rdParam+1)),*(mr->rdParam));
 592         break;
 593
 594     case META_SETMAPPERFLAGS:
 595         SetMapperFlags16(hdc, *(mr->rdParam));
 596         break;
 597
 598     case META_REALIZEPALETTE:
 599         RealizePalette16(hdc);
 600         break;
 601
 602     case META_ESCAPE:
 603         dprintf_metafile(stddeb,"PlayMetaFileRecord: META_ESCAPE unimplemented.\n");
 604         break;
 605
 606         /* --- Begin of fixed or new metafile operations. July 1996 ----*/
 607     case META_EXTTEXTOUT:
 608       {
 609         LPINT16 dxx;
 610         DWORD len;
 611
 612         s1 = mr->rdParam[2];                              /* String length */
 613         len = sizeof(METARECORD) + (((s1 + 1) >> 1) * 2) + 2 * sizeof(short)
 614          + sizeof(UINT16) + sizeof(RECT16);
 615         if (mr->rdSize == len / 2)
 616           dxx = NULL;                                    /* No array present */
 617         else if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2)
 618           dxx = &mr->rdParam[8+(s1+1)/2];                /* start of array */
 619         else {
 620           fprintf(stderr,
 621            "PlayMetaFileRecord ExtTextOut mr->rdSize = %08lx, count = %x\n",
 622            mr->rdSize, s1);
 623           dxx = NULL;
 624         }
 625         ExtTextOut16( hdc, mr->rdParam[1],              /* X position */
 626                            mr->rdParam[0],              /* Y position */
 627                            mr->rdParam[3],              /* options */
 628                            (LPRECT16) &mr->rdParam[4],  /* rectangle */
 629                            (char *)(mr->rdParam + 8),   /* string */
 630                            s1, dxx);                    /* length, dx array */
 631         if (dxx)
 632           dprintf_metafile(stddeb,"EXTTEXTOUT len: %ld  (%hd %hd)  [%s].\n",
 633             mr->rdSize,dxx[0],dxx[1],(char*) &(mr->rdParam[8]) );
 634        }
 635        break;
 636
 637     case META_STRETCHDIB:
 638       {
 639        LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParam[11]);
 640        LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParam[2] );
 641        StretchDIBits16(hdc,mr->rdParam[10],mr->rdParam[9],mr->rdParam[8],
 642                        mr->rdParam[7],mr->rdParam[6],mr->rdParam[5],
 643                        mr->rdParam[4],mr->rdParam[3],bits,info,
 644                        mr->rdParam[2],MAKELONG(mr->rdParam[0],mr->rdParam[1]));
 645       }
 646       break;
 647
 648     case META_DIBSTRETCHBLT:
 649       {
 650        LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParam[10]);
 651        LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParam[2] );
 652        StretchDIBits16(hdc,mr->rdParam[9],mr->rdParam[8],mr->rdParam[7],
 653                        mr->rdParam[6],mr->rdParam[5],mr->rdParam[4],
 654                        mr->rdParam[3],mr->rdParam[2],bits,info,
 655                        DIB_RGB_COLORS,MAKELONG(mr->rdParam[0],mr->rdParam[1]));
 656       }
 657       break;
 658
 659     case META_STRETCHBLT:
 660       {
 661        HDC16 hdcSrc=CreateCompatibleDC16(hdc);
 662        HBITMAP32 hbitmap=CreateBitmap32(mr->rdParam[10], /*Width */
 663                                         mr->rdParam[11], /*Height*/
 664                                         mr->rdParam[13], /*Planes*/
 665                                         mr->rdParam[14], /*BitsPixel*/
 666                                         (LPSTR)&mr->rdParam[15]);  /*bits*/
 667        SelectObject32(hdcSrc,hbitmap);
 668        StretchBlt16(hdc,mr->rdParam[9],mr->rdParam[8],
 669                     mr->rdParam[7],mr->rdParam[6],
 670                     hdcSrc,mr->rdParam[5],mr->rdParam[4],
 671                     mr->rdParam[3],mr->rdParam[2],
 672                     MAKELONG(mr->rdParam[0],mr->rdParam[1]));
 673        DeleteDC32(hdcSrc);
 674       }
 675       break;
 676
 677     case META_BITBLT:            /* <-- not yet debugged */
 678       {
 679        HDC16 hdcSrc=CreateCompatibleDC16(hdc);
 680        HBITMAP32 hbitmap=CreateBitmap32(mr->rdParam[7]/*Width */,
 681                                         mr->rdParam[8]/*Height*/,
 682                                         mr->rdParam[10]/*Planes*/,
 683                                         mr->rdParam[11]/*BitsPixel*/,
 684                                         (LPSTR)&mr->rdParam[12]/*bits*/);
 685        SelectObject32(hdcSrc,hbitmap);
 686        BitBlt32(hdc,(INT16)mr->rdParam[6],(INT16)mr->rdParam[5],
 687                 (INT16)mr->rdParam[4],(INT16)mr->rdParam[3],
 688                 hdcSrc, (INT16)mr->rdParam[2],(INT16)mr->rdParam[1],
 689                 MAKELONG(0,mr->rdParam[0]));
 690        DeleteDC32(hdcSrc);
 691       }
 692       break;
 693
 694        /* --- Begin of new metafile operations. April, 1997 (ak) ----*/
 695     case META_CREATEREGION:
 696          {
 697             int i;
 698             HRGN32 h1,h2,hrgn=CreateRectRgn32(mr->rdParam[7],mr->rdParam[8],
 699                                               mr->rdParam[9],mr->rdParam[10]);
 700             for (i=0,h1=CreateRectRgn32(0,0,0,0);i<mr->rdParam[5];i++)
 701             {
 702              if (mr->rdParam[11+i*6]==2)
 703              {
 704                h2=CreateRectRgn32(mr->rdParam[14+i*6],mr->rdParam[12+i*6],
 705                                   mr->rdParam[15+i*6],mr->rdParam[13+i*6]);
 706                CombineRgn32(hrgn,h1,h2,mr->rdParam[16+i*6]);    /* e.g. RGN_OR */
 707                h1=hrgn;
 708              }
 709             }
 710             MF_AddHandle(ht, nHandles,hrgn);
 711          }
 712        break;
 713
 714      case META_FILLREGION:
 715         FillRgn16(hdc, *(ht->objectHandle + *(mr->rdParam)),
 716                        *(ht->objectHandle + *(mr->rdParam+1)));
 717         break;
 718
 719      case META_INVERTREGION:
 720         InvertRgn16(hdc, *(ht->objectHandle + *(mr->rdParam)));
 721         break;
 722
 723      case META_PAINTREGION:
 724         PaintRgn16(hdc, *(ht->objectHandle + *(mr->rdParam)));
 725         break;
 726
 727      case META_SELECTCLIPREGION:
 728         SelectClipRgn32(hdc, *(ht->objectHandle + *(mr->rdParam)));
 729         break;
 730
 731      case META_DIBCREATEPATTERNBRUSH:
 732         /*  *(mr->rdParam) may be BS_PATTERN or BS_DIBPATTERN: but there's no difference */
 733         dprintf_metafile(stddeb,"META_DIBCREATEPATTERNBRUSH: %d\n",*(mr->rdParam));
 734         s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
 735         hndl = GlobalAlloc16(GMEM_MOVEABLE, s1);
 736         ptr = GlobalLock16(hndl);
 737         memcpy(ptr, mr->rdParam + 2, s1);
 738         GlobalUnlock16(hndl);
 739         MF_AddHandle(ht, nHandles,CreateDIBPatternBrush16(hndl, *(mr->rdParam + 1)));
 740         GlobalFree16(hndl);
 741         break;
 742
 743 #define META_UNIMP(x) case x: fprintf(stderr,"PlayMetaFileRecord:record type "#x" not implemented.\n");break;
 744     META_UNIMP(META_SETTEXTCHAREXTRA)
 745     META_UNIMP(META_SETTEXTJUSTIFICATION)
 746     META_UNIMP(META_FRAMEREGION)
 747     META_UNIMP(META_DRAWTEXT)
 748     META_UNIMP(META_SETDIBTODEV)
 749     META_UNIMP(META_ANIMATEPALETTE)
 750     META_UNIMP(META_SETPALENTRIES)
 751     META_UNIMP(META_RESIZEPALETTE)
 752     META_UNIMP(META_DIBBITBLT)
 753     META_UNIMP(META_EXTFLOODFILL)
 754     META_UNIMP(META_RESETDC)
 755     META_UNIMP(META_STARTDOC)
 756     META_UNIMP(META_STARTPAGE)
 757     META_UNIMP(META_ENDPAGE)
 758     META_UNIMP(META_ABORTDOC)
 759     META_UNIMP(META_ENDDOC)
 760     META_UNIMP(META_CREATEBRUSH)
 761     META_UNIMP(META_CREATEBITMAPINDIRECT)
 762     META_UNIMP(META_CREATEBITMAP)
 763 #undef META_UNIMP
 764
 765     default:
 766         fprintf(stddeb,"PlayMetaFileRecord: Unknown record type %x\n",
 767                                               mr->rdFunction);
 768     }
 769 }
 770
 771
 772 /******************************************************************
 773  *         GetMetaFileBits   (GDI.159)
 774  *
 775  * Trade in a meta file object handle for a handle to the meta file memory
 776  */
 777
 778 HGLOBAL16 GetMetaFileBits(HMETAFILE16 hmf)
 779 {
 780     dprintf_metafile(stddeb,"GetMetaFileBits: hMem out: %04x\n", hmf);
 781
 782     return hmf;
 783 }
 784
 785 /******************************************************************
 786  *         SetMetaFileBits   (GDI.160)
 787  *
 788  * Trade in a meta file memory handle for a handle to a meta file object
 789  */
 790 HMETAFILE16 SetMetaFileBits( HGLOBAL16 hMem )
 791 {
 792     dprintf_metafile(stddeb,"SetMetaFileBits: hmf out: %04x\n", hMem);
 793
 794     return hMem;
 795 }
 796
 797 /******************************************************************
 798  *         SetMetaFileBitsBetter   (GDI.196)
 799  */
 800 HMETAFILE16 SetMetaFileBitsBetter( HMETAFILE16 hMeta )
 801 {
 802    if( IsValidMetaFile( hMeta ) )
 803        return (HMETAFILE16)GlobalReAlloc16( hMeta, 0,
 804                            GMEM_SHARE | GMEM_NODISCARD | GMEM_MODIFY);
 805    return (HMETAFILE16)0;
 806 }
 807
 808 /******************************************************************
 809  *         MF_WriteRecord
 810  *
 811  * Warning: this function can change the metafile handle.
 812  */
 813
 814 static BOOL32 MF_WriteRecord( DC *dc, METARECORD *mr, WORD rlen)
 815 {
 816     DWORD len;
 817     METAHEADER *mh;
 818     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
 819
 820     switch(physDev->mh->mtType)
 821     {
 822     case METAFILE_MEMORY:
 823         len = physDev->mh->mtSize * 2 + rlen;
 824         mh = HeapReAlloc( SystemHeap, 0, physDev->mh, len );
 825         if (!mh) return FALSE;
 826         physDev->mh = mh;
 827         memcpy((WORD *)physDev->mh + physDev->mh->mtSize, mr, rlen);
 828         break;
 829     case METAFILE_DISK:
 830         dprintf_metafile(stddeb,"Writing record to disk\n");
 831         if (_lwrite32(physDev->mh->mtNoParameters, (char *)mr, rlen) == -1)
 832             return FALSE;
 833         break;
 834     default:
 835         fprintf( stderr, "Unknown metafile type %d\n", physDev->mh->mtType );
 836         return FALSE;
 837     }
 838
 839     physDev->mh->mtSize += rlen / 2;
 840     physDev->mh->mtMaxRecord = MAX(physDev->mh->mtMaxRecord, rlen / 2);
 841     return TRUE;
 842 }
 843
 844
 845 /******************************************************************
 846  *         MF_MetaParam0
 847  */
 848
 849 BOOL32 MF_MetaParam0(DC *dc, short func)
 850 {
 851     char buffer[8];
 852     METARECORD *mr = (METARECORD *)&buffer;
 853
 854     mr->rdSize = 3;
 855     mr->rdFunction = func;
 856     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 857 }
 858
 859
 860 /******************************************************************
 861  *         MF_MetaParam1
 862  */
 863 BOOL32 MF_MetaParam1(DC *dc, short func, short param1)
 864 {
 865     char buffer[8];
 866     METARECORD *mr = (METARECORD *)&buffer;
 867
 868     mr->rdSize = 4;
 869     mr->rdFunction = func;
 870     *(mr->rdParam) = param1;
 871     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 872 }
 873
 874
 875 /******************************************************************
 876  *         MF_MetaParam2
 877  */
 878 BOOL32 MF_MetaParam2(DC *dc, short func, short param1, short param2)
 879 {
 880     char buffer[10];
 881     METARECORD *mr = (METARECORD *)&buffer;
 882
 883     mr->rdSize = 5;
 884     mr->rdFunction = func;
 885     *(mr->rdParam) = param2;
 886     *(mr->rdParam + 1) = param1;
 887     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 888 }
 889
 890
 891 /******************************************************************
 892  *         MF_MetaParam4
 893  */
 894
 895 BOOL32 MF_MetaParam4(DC *dc, short func, short param1, short param2,
 896                    short param3, short param4)
 897 {
 898     char buffer[14];
 899     METARECORD *mr = (METARECORD *)&buffer;
 900
 901     mr->rdSize = 7;
 902     mr->rdFunction = func;
 903     *(mr->rdParam) = param4;
 904     *(mr->rdParam + 1) = param3;
 905     *(mr->rdParam + 2) = param2;
 906     *(mr->rdParam + 3) = param1;
 907     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 908 }
 909
 910
 911 /******************************************************************
 912  *         MF_MetaParam6
 913  */
 914
 915 BOOL32 MF_MetaParam6(DC *dc, short func, short param1, short param2,
 916                    short param3, short param4, short param5, short param6)
 917 {
 918     char buffer[18];
 919     METARECORD *mr = (METARECORD *)&buffer;
 920
 921     mr->rdSize = 9;
 922     mr->rdFunction = func;
 923     *(mr->rdParam) = param6;
 924     *(mr->rdParam + 1) = param5;
 925     *(mr->rdParam + 2) = param4;
 926     *(mr->rdParam + 3) = param3;
 927     *(mr->rdParam + 4) = param2;
 928     *(mr->rdParam + 5) = param1;
 929     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 930 }
 931
 932
 933 /******************************************************************
 934  *         MF_MetaParam8
 935  */
 936 BOOL32 MF_MetaParam8(DC *dc, short func, short param1, short param2,
 937                    short param3, short param4, short param5,
 938                    short param6, short param7, short param8)
 939 {
 940     char buffer[22];
 941     METARECORD *mr = (METARECORD *)&buffer;
 942
 943     mr->rdSize = 11;
 944     mr->rdFunction = func;
 945     *(mr->rdParam) = param8;
 946     *(mr->rdParam + 1) = param7;
 947     *(mr->rdParam + 2) = param6;
 948     *(mr->rdParam + 3) = param5;
 949     *(mr->rdParam + 4) = param4;
 950     *(mr->rdParam + 5) = param3;
 951     *(mr->rdParam + 6) = param2;
 952     *(mr->rdParam + 7) = param1;
 953     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 954 }
 955
 956
 957 /******************************************************************
 958  *         MF_CreateBrushIndirect
 959  */
 960
 961 BOOL32 MF_CreateBrushIndirect(DC *dc, HBRUSH16 hBrush, LOGBRUSH16 *logbrush)
 962 {
 963     int index;
 964     char buffer[sizeof(METARECORD) - 2 + sizeof(*logbrush)];
 965     METARECORD *mr = (METARECORD *)&buffer;
 966
 967     mr->rdSize = (sizeof(METARECORD) + sizeof(*logbrush) - 2) / 2;
 968     mr->rdFunction = META_CREATEBRUSHINDIRECT;
 969     memcpy(&(mr->rdParam), logbrush, sizeof(*logbrush));
 970     if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
 971
 972     mr->rdSize = sizeof(METARECORD) / 2;
 973     mr->rdFunction = META_SELECTOBJECT;
 974
 975     if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
 976     *(mr->rdParam) = index;
 977     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
 978 }
 979
 980
 981 /******************************************************************
 982  *         MF_CreatePatternBrush
 983  */
 984
 985 BOOL32 MF_CreatePatternBrush(DC *dc, HBRUSH16 hBrush, LOGBRUSH16 *logbrush)
 986 {
 987     DWORD len, bmSize, biSize;
 988     HGLOBAL16 hmr;
 989     METARECORD *mr;
 990     BITMAPOBJ *bmp;
 991     BITMAPINFO *info;
 992     BITMAPINFOHEADER *infohdr;
 993     int index;
 994     char buffer[sizeof(METARECORD)];
 995
 996     switch (logbrush->lbStyle)
 997     {
 998     case BS_PATTERN:
 999         bmp = (BITMAPOBJ *)GDI_GetObjPtr((HGDIOBJ16)logbrush->lbHatch, BITMAP_MAGIC);
1000         if (!bmp) return FALSE;
1001         len = sizeof(METARECORD) + sizeof(BITMAPINFOHEADER) +
1002               (bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes) + 6;
1003         if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1004             return FALSE;
1005         mr = (METARECORD *)GlobalLock16(hmr);
1006         memset(mr, 0, len);
1007         mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
1008         mr->rdSize = len / 2;
1009         *(mr->rdParam) = logbrush->lbStyle;
1010         *(mr->rdParam + 1) = DIB_RGB_COLORS;
1011         infohdr = (BITMAPINFOHEADER *)(mr->rdParam + 2);
1012         infohdr->biSize = sizeof(BITMAPINFOHEADER);
1013         infohdr->biWidth = bmp->bitmap.bmWidth;
1014         infohdr->biHeight = bmp->bitmap.bmHeight;
1015         infohdr->biPlanes = bmp->bitmap.bmPlanes;
1016         infohdr->biBitCount = bmp->bitmap.bmBitsPixel;
1017         memcpy(mr->rdParam + (sizeof(BITMAPINFOHEADER) / 2) + 4,
1018                PTR_SEG_TO_LIN(bmp->bitmap.bmBits),
1019                bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes);
1020         break;
1021
1022     case BS_DIBPATTERN:
1023         info = (BITMAPINFO *)GlobalLock16((HGLOBAL16)logbrush->lbHatch);
1024         if (info->bmiHeader.biCompression)
1025             bmSize = info->bmiHeader.biSizeImage;
1026         else
1027             bmSize = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount
1028                     + 31) / 32 * 8 * info->bmiHeader.biHeight;
1029         biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush->lbColor));
1030         len = sizeof(METARECORD) + biSize + bmSize + 2;
1031         if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1032             return FALSE;
1033         mr = (METARECORD *)GlobalLock16(hmr);
1034         memset(mr, 0, len);
1035         mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
1036         mr->rdSize = len / 2;
1037         *(mr->rdParam) = logbrush->lbStyle;
1038         *(mr->rdParam + 1) = LOWORD(logbrush->lbColor);
1039         memcpy(mr->rdParam + 2, info, biSize + bmSize);
1040         break;
1041     default:
1042         return FALSE;
1043     }
1044     if (!(MF_WriteRecord(dc, mr, len)))
1045     {
1046         GlobalFree16(hmr);
1047         return FALSE;
1048     }
1049
1050     GlobalFree16(hmr);
1051
1052     mr = (METARECORD *)&buffer;
1053     mr->rdSize = sizeof(METARECORD) / 2;
1054     mr->rdFunction = META_SELECTOBJECT;
1055
1056     if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1057     *(mr->rdParam) = index;
1058     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1059 }
1060
1061
1062 /******************************************************************
1063  *         MF_CreatePenIndirect
1064  */
1065
1066 BOOL32 MF_CreatePenIndirect(DC *dc, HPEN16 hPen, LOGPEN16 *logpen)
1067 {
1068     int index;
1069     char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
1070     METARECORD *mr = (METARECORD *)&buffer;
1071
1072     mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
1073     mr->rdFunction = META_CREATEPENINDIRECT;
1074     memcpy(&(mr->rdParam), logpen, sizeof(*logpen));
1075     if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1076
1077     mr->rdSize = sizeof(METARECORD) / 2;
1078     mr->rdFunction = META_SELECTOBJECT;
1079
1080     if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1081     *(mr->rdParam) = index;
1082     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1083 }
1084
1085
1086 /******************************************************************
1087  *         MF_CreateFontIndirect
1088  */
1089
1090 BOOL32 MF_CreateFontIndirect(DC *dc, HFONT16 hFont, LOGFONT16 *logfont)
1091 {
1092     int index;
1093     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
1094     METARECORD *mr = (METARECORD *)&buffer;
1095
1096     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
1097     mr->rdFunction = META_CREATEFONTINDIRECT;
1098     memcpy(&(mr->rdParam), logfont, sizeof(LOGFONT16));
1099     if (!(MF_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
1100
1101     mr->rdSize = sizeof(METARECORD) / 2;
1102     mr->rdFunction = META_SELECTOBJECT;
1103
1104     if ((index = MF_AddHandleDC( dc )) == -1) return FALSE;
1105     *(mr->rdParam) = index;
1106     return MF_WriteRecord( dc, mr, mr->rdSize * 2);
1107 }
1108
1109
1110 /******************************************************************
1111  *         MF_TextOut
1112  */
1113 BOOL32 MF_TextOut(DC *dc, short x, short y, LPCSTR str, short count)
1114 {
1115     BOOL32 ret;
1116     DWORD len;
1117     HGLOBAL16 hmr;
1118     METARECORD *mr;
1119
1120     len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 4;
1121     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1122         return FALSE;
1123     mr = (METARECORD *)GlobalLock16(hmr);
1124     memset(mr, 0, len);
1125
1126     mr->rdSize = len / 2;
1127     mr->rdFunction = META_TEXTOUT;
1128     *(mr->rdParam) = count;
1129     memcpy(mr->rdParam + 1, str, count);
1130     *(mr->rdParam + ((count + 1) >> 1) + 1) = y;
1131     *(mr->rdParam + ((count + 1) >> 1) + 2) = x;
1132     ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1133     GlobalFree16(hmr);
1134     return ret;
1135 }
1136
1137 /******************************************************************
1138  *         MF_ExtTextOut
1139  */
1140 BOOL32 MF_ExtTextOut(DC*dc, short x, short y, UINT16 flags, const RECT16 *rect,
1141                      LPCSTR str, short count, const INT16 *lpDx)
1142 {
1143     BOOL32 ret;
1144     DWORD len;
1145     HGLOBAL16 hmr;
1146     METARECORD *mr;
1147
1148     len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 2 * sizeof(short)
1149             + sizeof(UINT16) + sizeof(RECT16);
1150     if (lpDx)
1151      len+=count*sizeof(INT16);
1152     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1153         return FALSE;
1154     mr = (METARECORD *)GlobalLock16(hmr);
1155     memset(mr, 0, len);
1156
1157     mr->rdSize = len / 2;
1158     mr->rdFunction = META_EXTTEXTOUT;
1159     *(mr->rdParam) = y;
1160     *(mr->rdParam + 1) = x;
1161     *(mr->rdParam + 2) = count;
1162     *(mr->rdParam + 3) = flags;
1163     if (rect) memcpy(mr->rdParam + 4, rect, sizeof(RECT16));
1164     memcpy(mr->rdParam + 8, str, count);
1165     if (lpDx)
1166      memcpy(mr->rdParam + 8+ ((count + 1) >> 1),lpDx,count*sizeof(INT16));
1167     ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1168     GlobalFree16(hmr);
1169     return ret;
1170 }
1171
1172 /******************************************************************
1173  *         MF_MetaPoly - implements Polygon and Polyline
1174  */
1175 BOOL32 MF_MetaPoly(DC *dc, short func, LPPOINT16 pt, short count)
1176 {
1177     BOOL32 ret;
1178     DWORD len;
1179     HGLOBAL16 hmr;
1180     METARECORD *mr;
1181
1182     len = sizeof(METARECORD) + (count * 4);
1183     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1184         return FALSE;
1185     mr = (METARECORD *)GlobalLock16(hmr);
1186     memset(mr, 0, len);
1187
1188     mr->rdSize = len / 2;
1189     mr->rdFunction = func;
1190     *(mr->rdParam) = count;
1191     memcpy(mr->rdParam + 1, pt, count * 4);
1192     ret = MF_WriteRecord( dc, mr, mr->rdSize * 2);
1193     GlobalFree16(hmr);
1194     return ret;
1195 }
1196
1197
1198 /******************************************************************
1199  *         MF_BitBlt
1200  */
1201 BOOL32 MF_BitBlt(DC *dcDest, short xDest, short yDest, short width,
1202                  short height, DC *dcSrc, short xSrc, short ySrc, DWORD rop)
1203 {
1204     BOOL32 ret;
1205     DWORD len;
1206     HGLOBAL16 hmr;
1207     METARECORD *mr;
1208     BITMAP16  BM;
1209
1210     GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
1211     len = sizeof(METARECORD) + 12 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
1212     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1213         return FALSE;
1214     mr = (METARECORD *)GlobalLock16(hmr);
1215     mr->rdFunction = META_BITBLT;
1216     *(mr->rdParam + 7) = BM.bmWidth;
1217     *(mr->rdParam + 8) = BM.bmHeight;
1218     *(mr->rdParam + 9) = BM.bmWidthBytes;
1219     *(mr->rdParam +10) = BM.bmPlanes;
1220     *(mr->rdParam +11) = BM.bmBitsPixel;
1221     dprintf_metafile(stddeb,"MF_StretchBlt->len = %ld  rop=%lx  \n",len,rop);
1222     if (GetBitmapBits32(dcSrc->w.hBitmap,BM.bmWidthBytes * BM.bmHeight,
1223                         mr->rdParam +12))
1224     {
1225       mr->rdSize = len / sizeof(INT16);
1226       *(mr->rdParam) = HIWORD(rop);
1227       *(mr->rdParam + 1) = ySrc;
1228       *(mr->rdParam + 2) = xSrc;
1229       *(mr->rdParam + 3) = height;
1230       *(mr->rdParam + 4) = width;
1231       *(mr->rdParam + 5) = yDest;
1232       *(mr->rdParam + 6) = xDest;
1233       ret = MF_WriteRecord( dcDest, mr, mr->rdSize * 2);
1234     }
1235     else
1236         ret = FALSE;
1237     GlobalFree16(hmr);
1238     return ret;
1239 }
1240
1241
1242 /**********************************************************************
1243  *         MF_StretchBlt
1244  * this function contains TWO ways for procesing StretchBlt in metafiles,
1245  * decide between rdFunction values  META_STRETCHBLT or META_DIBSTRETCHBLT
1246  * via #define STRETCH_VIA_DIB
1247  */
1248 #define STRETCH_VIA_DIB
1249 #undef  STRETCH_VIA_DIB
1250 BOOL32 MF_StretchBlt(DC *dcDest, short xDest, short yDest, short widthDest,
1251                      short heightDest, DC *dcSrc, short xSrc, short ySrc,
1252                      short widthSrc, short heightSrc, DWORD rop)
1253 {
1254     BOOL32 ret;
1255     DWORD len;
1256     HGLOBAL16 hmr;
1257     METARECORD *mr;
1258     BITMAP16  BM;
1259 #ifdef STRETCH_VIA_DIB
1260     LPBITMAPINFOHEADER lpBMI;
1261     WORD nBPP;
1262 #endif
1263     GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
1264 #ifdef STRETCH_VIA_DIB
1265     nBPP = BM.bmPlanes * BM.bmBitsPixel;
1266     len = sizeof(METARECORD) + 10 * sizeof(INT16)
1267             + sizeof(BITMAPINFOHEADER) + (nBPP != 24 ? 1 << nBPP: 0) * sizeof(RGBQUAD)
1268               + ((BM.bmWidth * nBPP + 31) / 32) * 4 * BM.bmHeight;
1269     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1270         return FALSE;
1271     mr = (METARECORD *)GlobalLock16(hmr);
1272     mr->rdFunction = META_DIBSTRETCHBLT;
1273     lpBMI=(LPBITMAPINFOHEADER)(mr->rdParam+10);
1274     lpBMI->biSize      = sizeof(BITMAPINFOHEADER);
1275     lpBMI->biWidth     = BM.bmWidth;
1276     lpBMI->biHeight    = BM.bmHeight;
1277     lpBMI->biPlanes    = 1;
1278     lpBMI->biBitCount  = nBPP;                              /* 1,4,8 or 24 */
1279     lpBMI->biClrUsed   = nBPP != 24 ? 1 << nBPP : 0;
1280     lpBMI->biSizeImage = ((lpBMI->biWidth * nBPP + 31) / 32) * 4 * lpBMI->biHeight;
1281     lpBMI->biCompression = BI_RGB;
1282     lpBMI->biXPelsPerMeter = MulDiv32(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSX),3937,100);
1283     lpBMI->biYPelsPerMeter = MulDiv32(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSY),3937,100);
1284     lpBMI->biClrImportant  = 0;                          /* 1 meter  = 39.37 inch */
1285
1286     dprintf_metafile(stddeb,"MF_StretchBltViaDIB->len = %ld  rop=%lx  PixYPM=%ld Caps=%d\n",
1287                len,rop,lpBMI->biYPelsPerMeter,GetDeviceCaps(hdcSrc,LOGPIXELSY));
1288     if (GetDIBits(hdcSrc,dcSrc->w.hBitmap,0,(UINT32)lpBMI->biHeight,
1289                   (LPSTR)lpBMI + DIB_BitmapInfoSize( (BITMAPINFO *)lpBMI,
1290                                                      DIB_RGB_COLORS ),
1291                   (LPBITMAPINFO)lpBMI, DIB_RGB_COLORS))
1292 #else
1293     len = sizeof(METARECORD) + 15 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
1294     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
1295         return FALSE;
1296     mr = (METARECORD *)GlobalLock16(hmr);
1297     mr->rdFunction = META_STRETCHBLT;
1298     *(mr->rdParam +10) = BM.bmWidth;
1299     *(mr->rdParam +11) = BM.bmHeight;
1300     *(mr->rdParam +12) = BM.bmWidthBytes;
1301     *(mr->rdParam +13) = BM.bmPlanes;
1302     *(mr->rdParam +14) = BM.bmBitsPixel;
1303     dprintf_metafile(stddeb,"MF_StretchBlt->len = %ld  rop=%lx  \n",len,rop);
1304     if (GetBitmapBits32( dcSrc->w.hBitmap, BM.bmWidthBytes * BM.bmHeight,
1305                          mr->rdParam +15))
1306 #endif
1307     {
1308       mr->rdSize = len / sizeof(INT16);
1309       *(mr->rdParam) = LOWORD(rop);
1310       *(mr->rdParam + 1) = HIWORD(rop);
1311       *(mr->rdParam + 2) = heightSrc;
1312       *(mr->rdParam + 3) = widthSrc;
1313       *(mr->rdParam + 4) = ySrc;
1314       *(mr->rdParam + 5) = xSrc;
1315       *(mr->rdParam + 6) = heightDest;
1316       *(mr->rdParam + 7) = widthDest;
1317       *(mr->rdParam + 8) = yDest;
1318       *(mr->rdParam + 9) = xDest;
1319       ret = MF_WriteRecord( dcDest, mr, mr->rdSize * 2);
1320     }
1321     else
1322         ret = FALSE;
1323     GlobalFree16(hmr);
1324     return ret;
1325 }
1326
1327