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