objects/metafile.c

   1 /*
   2  * Metafile functions
   3  *
   4  * Copyright  David W. Metcalfe, 1994
   5  */
   6
   7 static char Copyright[] = "Copyright  David W. Metcalfe, 1994";
   8
   9 #include <string.h>
  10 #include "windows.h"
  11 #include "gdi.h"
  12 #include "metafile.h"
  13 #include "prototypes.h"
  14 #include "stddebug.h"
  15 /* #define DEBUG_METAFILE /* */
  16 /* #undef  DEBUG_METAFILE /* */
  17 #include "debug.h"
  18
  19 #define HTINCR  10      /* handle table allocation size increment */
  20
  21 static HANDLE hHT;      /* handle of the handle table */
  22 static int HTLen;       /* allocated length of handle table */
  23
  24 /******************************************************************
  25  *         CreateMetafile         GDI.125
  26  */
  27 HANDLE CreateMetaFile(LPSTR lpFilename)
  28 {
  29     DC *dc;
  30     HANDLE handle;
  31     METAFILE *mf;
  32     METAHEADER *mh;
  33     HANDLETABLE *ht;
  34
  35     dprintf_metafile(stddeb,"CreateMetaFile: %s\n", lpFilename);
  36
  37     handle = GDI_AllocObject(sizeof(DC), METAFILE_DC_MAGIC);
  38     if (!handle) return 0;
  39     dc = (DC *)GDI_HEAP_ADDR(handle);
  40
  41     if (!(dc->w.hMetaFile = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILE))))
  42         return 0;
  43     mf = (METAFILE *)GlobalLock(dc->w.hMetaFile);
  44     if (!(mf->hMetaHdr = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAHEADER))))
  45     {
  46         GlobalFree(dc->w.hMetaFile);
  47         return 0;
  48     }
  49     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
  50
  51     mf->wMagic = METAFILE_MAGIC;
  52     mh->mtHeaderSize = MFHEADERSIZE / 2;
  53     mh->mtVersion = MFVERSION;
  54     mh->mtSize = MFHEADERSIZE / 2;
  55     mh->mtNoObjects = 0;
  56     mh->mtMaxRecord = 0;
  57     mh->mtNoParameters = 0;
  58
  59     if (lpFilename)          /* disk based metafile */
  60     {
  61         mh->mtType = 1;
  62         strcpy(mf->Filename, lpFilename);
  63         mf->hFile = _lcreat(lpFilename, 0);
  64         if (_lwrite(mf->hFile, (char *)mh, MFHEADERSIZE) == -1)
  65         {
  66             GlobalFree(mf->hMetaHdr);
  67             GlobalFree(dc->w.hMetaFile);
  68             return 0;
  69         }
  70     }
  71     else                     /* memory based metafile */
  72         mh->mtType = 0;
  73
  74     /* create the handle table */
  75     HTLen = HTINCR;
  76     hHT = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,
  77                       sizeof(HANDLETABLE) * HTLen);
  78     ht = (HANDLETABLE *)GlobalLock(hHT);
  79
  80     GlobalUnlock(mf->hMetaHdr);
  81     GlobalUnlock(dc->w.hMetaFile);
  82     return handle;
  83 }
  84
  85
  86 /******************************************************************
  87  *         CloseMetafile         GDI.126
  88  */
  89 HMETAFILE CloseMetaFile(HDC hdc)
  90 {
  91     DC *dc;
  92     METAFILE *mf;
  93     METAHEADER *mh;
  94     HMETAFILE hmf;
  95     char buffer[15];
  96     METARECORD *mr = (METARECORD *)&buffer;
  97
  98     dprintf_metafile(stddeb,"CloseMetaFile\n");
  99
 100     dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 101     if (!dc) return 0;
 102     mf = (METAFILE *)GlobalLock(dc->w.hMetaFile);
 103     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 104
 105     /* Construct the end of metafile record - this is documented
 106      * in SDK Knowledgebase Q99334.
 107      */
 108     if (!MF_MetaParam0(dc, META_EOF))
 109     {
 110         GlobalFree(mf->hMetaHdr);
 111         GlobalFree(dc->w.hMetaFile);
 112         return 0;
 113     }
 114
 115     if (mh->mtType == 1)        /* disk based metafile */
 116     {
 117         if (_llseek(mf->hFile, 0L, 0) == -1)
 118         {
 119             GlobalFree(mf->hMetaHdr);
 120             GlobalFree(dc->w.hMetaFile);
 121             return 0;
 122         }
 123         if (_lwrite(mf->hFile, (char *)mh, MFHEADERSIZE) == -1)
 124         {
 125             GlobalFree(mf->hMetaHdr);
 126             GlobalFree(dc->w.hMetaFile);
 127             return 0;
 128         }
 129         _lclose(mf->hFile);
 130     }
 131
 132     /* delete the handle table */
 133     GlobalFree(hHT);
 134
 135     GlobalUnlock(mf->hMetaHdr);
 136     hmf = dc->w.hMetaFile;
 137     GlobalUnlock(hmf);
 138     GDI_FreeObject(hdc);
 139     return hmf;
 140 }
 141
 142
 143 /******************************************************************
 144  *         DeleteMetafile         GDI.127
 145  */
 146 BOOL DeleteMetaFile(HMETAFILE hmf)
 147 {
 148     METAFILE *mf = (METAFILE *)GlobalLock(hmf);
 149
 150     if (mf->wMagic != METAFILE_MAGIC)
 151         return FALSE;
 152
 153     GlobalFree(mf->hMetaHdr);
 154     GlobalFree(hmf);
 155     return TRUE;
 156 }
 157
 158
 159 /******************************************************************
 160  *         PlayMetafile         GDI.123
 161  */
 162 BOOL PlayMetaFile(HDC hdc, HMETAFILE hmf)
 163 {
 164     METAFILE *mf = (METAFILE *)GlobalLock(hmf);
 165     METAHEADER *mh;
 166     METARECORD *mr;
 167     HANDLETABLE *ht;
 168     char *buffer;
 169
 170     if (mf->wMagic != METAFILE_MAGIC)
 171         return FALSE;
 172
 173     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 174     if (mh->mtType == 1)       /* disk based metafile */
 175     {
 176         mf->hFile = _lopen(mf->Filename, OF_READ);
 177         mf->hBuffer = GlobalAlloc(GMEM_MOVEABLE, mh->mtMaxRecord * 2);
 178         buffer = (char *)GlobalLock(mf->hBuffer);
 179         _llseek(mf->hFile, mh->mtHeaderSize * 2, 0);
 180         mf->MetaOffset = mh->mtHeaderSize * 2;
 181     }
 182     else if (mh->mtType == 0)   /* memory based metafile */
 183         mf->MetaOffset = mh->mtHeaderSize * 2;
 184     else                       /* not a valid metafile type */
 185         return FALSE;
 186
 187     /* create the handle table */
 188     hHT = GlobalAlloc(GMEM_MOVEABLE, sizeof(HANDLETABLE) * mh->mtNoObjects);
 189     ht = (HANDLETABLE *)GlobalLock(hHT);
 190
 191     /* loop through metafile playing records */
 192     while (mf->MetaOffset < mh->mtSize * 2)
 193     {
 194         if (mh->mtType == 1)   /* disk based metafile */
 195         {
 196             _lread(mf->hFile, buffer, sizeof(METARECORD));
 197             mr = (METARECORD *)&buffer;
 198             _lread(mf->hFile, (char *)(mr->rdParam + 1), (mr->rdSize * 2) -
 199                                                        sizeof(METARECORD));
 200             mf->MetaOffset += mr->rdSize * 2;
 201         }
 202         else                   /* memory based metafile */
 203         {
 204             mr = (METARECORD *)((char *)mh + mf->MetaOffset);
 205             mf->MetaOffset += mr->rdSize * 2;
 206         }
 207         PlayMetaFileRecord(hdc, ht, mr, mh->mtNoObjects);
 208     }
 209
 210     /* close disk based metafile and free buffer */
 211     if (mh->mtType == 1)
 212     {
 213         GlobalFree(mf->hBuffer);
 214         _lclose(mf->hFile);
 215     }
 216
 217     /* free handle table */
 218     GlobalFree(hHT);
 219
 220     return TRUE;
 221 }
 222
 223
 224 /******************************************************************
 225  *         PlayMetaFileRecord      GDI.176
 226  */
 227 void PlayMetaFileRecord(HDC hdc, HANDLETABLE *ht, METARECORD *mr,
 228                                                    WORD nHandles)
 229 {
 230     short s1;
 231     HANDLE hndl;
 232     char *ptr;
 233     BITMAPINFOHEADER *infohdr;
 234
 235     switch (mr->rdFunction)
 236     {
 237     case META_SETBKCOLOR:
 238         SetBkColor(hdc, *(mr->rdParam));
 239         break;
 240
 241     case META_SETBKMODE:
 242         SetBkMode(hdc, *(mr->rdParam));
 243         break;
 244
 245     case META_SETMAPMODE:
 246         SetMapMode(hdc, *(mr->rdParam));
 247         break;
 248
 249     case META_SETROP2:
 250         SetROP2(hdc, *(mr->rdParam));
 251         break;
 252
 253     case META_SETRELABS:
 254         SetRelAbs(hdc, *(mr->rdParam));
 255         break;
 256
 257     case META_SETPOLYFILLMODE:
 258         SetPolyFillMode(hdc, *(mr->rdParam));
 259         break;
 260
 261     case META_SETSTRETCHBLTMODE:
 262         SetStretchBltMode(hdc, *(mr->rdParam));
 263         break;
 264
 265     case META_SETTEXTCOLOR:
 266         SetTextColor(hdc, MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 267         break;
 268
 269     case META_SETWINDOWORG:
 270         SetWindowOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 271         break;
 272
 273     case META_SETWINDOWEXT:
 274         SetWindowExt(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 275         break;
 276
 277     case META_SETVIEWPORTORG:
 278         SetViewportOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 279         break;
 280
 281     case META_SETVIEWPORTEXT:
 282         SetViewportExt(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 283         break;
 284
 285     case META_OFFSETWINDOWORG:
 286         OffsetWindowOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 287         break;
 288
 289     case META_SCALEWINDOWEXT:
 290         ScaleWindowExt(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 291                        *(mr->rdParam + 1), *(mr->rdParam));
 292         break;
 293
 294     case META_OFFSETVIEWPORTORG:
 295         OffsetViewportOrg(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 296         break;
 297
 298     case META_SCALEVIEWPORTEXT:
 299         ScaleViewportExt(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 300                          *(mr->rdParam + 1), *(mr->rdParam));
 301         break;
 302
 303     case META_LINETO:
 304         LineTo(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 305         break;
 306
 307     case META_MOVETO:
 308         MoveTo(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 309         break;
 310
 311     case META_EXCLUDECLIPRECT:
 312         ExcludeClipRect(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 313                         *(mr->rdParam + 1), *(mr->rdParam));
 314         break;
 315
 316     case META_INTERSECTCLIPRECT:
 317         IntersectClipRect(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 318                         *(mr->rdParam + 1), *(mr->rdParam));
 319         break;
 320
 321     case META_ARC:
 322         Arc(hdc, *(mr->rdParam + 7), *(mr->rdParam + 6), *(mr->rdParam + 5),
 323             *(mr->rdParam + 4), *(mr->rdParam + 3), *(mr->rdParam + 2),
 324             *(mr->rdParam + 1), *(mr->rdParam));
 325         break;
 326
 327     case META_ELLIPSE:
 328         Ellipse(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 329                 *(mr->rdParam + 1), *(mr->rdParam));
 330         break;
 331
 332     case META_FLOODFILL:
 333         FloodFill(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 334                   MAKELONG(*(mr->rdParam + 1), *(mr->rdParam)));
 335         break;
 336
 337     case META_PIE:
 338         Pie(hdc, *(mr->rdParam + 7), *(mr->rdParam + 6), *(mr->rdParam + 5),
 339             *(mr->rdParam + 4), *(mr->rdParam + 3), *(mr->rdParam + 2),
 340             *(mr->rdParam + 1), *(mr->rdParam));
 341         break;
 342
 343     case META_RECTANGLE:
 344         Ellipse(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 345                 *(mr->rdParam + 1), *(mr->rdParam));
 346         break;
 347
 348     case META_ROUNDRECT:
 349         RoundRect(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
 350                   *(mr->rdParam + 3), *(mr->rdParam + 2),
 351                   *(mr->rdParam + 1), *(mr->rdParam));
 352         break;
 353
 354     case META_PATBLT:
 355         PatBlt(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
 356                *(mr->rdParam + 3), *(mr->rdParam + 2),
 357                MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 358         break;
 359
 360     case META_SAVEDC:
 361         SaveDC(hdc);
 362         break;
 363
 364     case META_SETPIXEL:
 365         SetPixel(hdc, *(mr->rdParam + 3), *(mr->rdParam + 2),
 366                  MAKELONG(*(mr->rdParam + 1), *(mr->rdParam)));
 367         break;
 368
 369     case META_OFFSETCLIPRGN:
 370         OffsetClipRgn(hdc, *(mr->rdParam + 1), *(mr->rdParam));
 371         break;
 372
 373     case META_TEXTOUT:
 374         s1 = *(mr->rdParam);
 375         TextOut(hdc, *(mr->rdParam + ((s1 + 1) >> 1) + 2),
 376                 *(mr->rdParam + ((s1 + 1) >> 1) + 1),
 377                 (char *)(mr->rdParam + 1), s1);
 378         break;
 379
 380     case META_POLYGON:
 381         Polygon(hdc, (LPPOINT)(mr->rdParam + 1), *(mr->rdParam));
 382         break;
 383
 384     case META_POLYLINE:
 385         Polyline(hdc, (LPPOINT)(mr->rdParam + 1), *(mr->rdParam));
 386         break;
 387
 388     case META_RESTOREDC:
 389         RestoreDC(hdc, *(mr->rdParam));
 390         break;
 391
 392     case META_SELECTOBJECT:
 393         SelectObject(hdc, *(ht->objectHandle + *(mr->rdParam)));
 394         break;
 395
 396     case META_CHORD:
 397         Chord(hdc, *(mr->rdParam + 7), *(mr->rdParam + 6), *(mr->rdParam + 5),
 398               *(mr->rdParam + 4), *(mr->rdParam + 3), *(mr->rdParam + 2),
 399               *(mr->rdParam + 1), *(mr->rdParam));
 400         break;
 401
 402     case META_CREATEPATTERNBRUSH:
 403         switch (*(mr->rdParam))
 404         {
 405         case BS_PATTERN:
 406             infohdr = (BITMAPINFOHEADER *)(mr->rdParam + 2);
 407             MF_AddHandle(ht, nHandles,
 408                          CreatePatternBrush(CreateBitmap(infohdr->biWidth,
 409                                       infohdr->biHeight,
 410                                       infohdr->biPlanes,
 411                                       infohdr->biBitCount,
 412                                       (LPSTR)(mr->rdParam +
 413                                       (sizeof(BITMAPINFOHEADER) / 2) + 4))));
 414             break;
 415
 416         case BS_DIBPATTERN:
 417             s1 = mr->rdSize * 2 - sizeof(METARECORD) - 2;
 418             hndl = GlobalAlloc(GMEM_MOVEABLE, s1);
 419             ptr = GlobalLock(hndl);
 420             memcpy(ptr, mr->rdParam + 2, s1);
 421             GlobalUnlock(hndl);
 422             MF_AddHandle(ht, nHandles,
 423                          CreateDIBPatternBrush(hndl, *(mr->rdParam + 1)));
 424             GlobalFree(hndl);
 425         }
 426         break;
 427
 428     case META_CREATEPENINDIRECT:
 429         MF_AddHandle(ht, nHandles,
 430                      CreatePenIndirect((LOGPEN *)(&(mr->rdParam))));
 431         break;
 432
 433     case META_CREATEFONTINDIRECT:
 434         MF_AddHandle(ht, nHandles,
 435                      CreateFontIndirect((LOGFONT *)(&(mr->rdParam))));
 436         break;
 437
 438     case META_CREATEBRUSHINDIRECT:
 439         MF_AddHandle(ht, nHandles,
 440                      CreateBrushIndirect((LOGBRUSH *)(&(mr->rdParam))));
 441         break;
 442
 443     default:
 444         fprintf(stderr,"PlayMetaFileRecord: Unknown record type %x\n",
 445                                               mr->rdFunction);
 446     }
 447 }
 448
 449
 450 /******************************************************************
 451  *         MF_WriteRecord
 452  */
 453 BOOL MF_WriteRecord(HMETAFILE hmf, METARECORD *mr, WORD rlen)
 454 {
 455     DWORD len;
 456     METAFILE *mf = (METAFILE *)GlobalLock(hmf);
 457     METAHEADER *mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 458
 459     if (mh->mtType == 0)          /* memory based metafile */
 460     {
 461         len = mh->mtSize * 2 + rlen;
 462         GlobalUnlock(mf->hMetaHdr);
 463         mf->hMetaHdr = GlobalReAlloc(mf->hMetaHdr, len, GMEM_MOVEABLE);
 464         mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 465         memcpy(mh + mh->mtSize * 2, mr, rlen);
 466     }
 467     else if (mh->mtType == 1)     /* disk based metafile */
 468     {
 469         if (_lwrite(mf->hFile, (char *)mr, rlen) == -1)
 470         {
 471             GlobalUnlock(mf->hMetaHdr);
 472             return FALSE;
 473         }
 474     }
 475     else
 476     {
 477         GlobalUnlock(mf->hMetaHdr);
 478         return FALSE;
 479     }
 480
 481     mh->mtSize += rlen / 2;
 482     mh->mtMaxRecord = max(mh->mtMaxRecord, rlen / 2);
 483     GlobalUnlock(mf->hMetaHdr);
 484     return TRUE;
 485 }
 486
 487
 488 /******************************************************************
 489  *         MF_AddHandle
 490  *
 491  *    Add a handle to an external handle table and return the index
 492  */
 493 int MF_AddHandle(HANDLETABLE *ht, WORD htlen, HANDLE hobj)
 494 {
 495     int i;
 496
 497     for (i = 0; i < htlen; i++)
 498     {
 499         if (*(ht->objectHandle + i) == 0)
 500         {
 501             *(ht->objectHandle + i) = hobj;
 502             return i;
 503         }
 504     }
 505     return -1;
 506 }
 507
 508
 509 /******************************************************************
 510  *         MF_AddHandleInternal
 511  *
 512  *    Add a handle to the internal handle table and return the index
 513  */
 514 int MF_AddHandleInternal(HANDLE hobj)
 515 {
 516     int i;
 517     HANDLETABLE *ht = (HANDLETABLE *)GlobalLock(hHT);
 518
 519     for (i = 0; i < HTLen; i++)
 520     {
 521         if (*(ht->objectHandle + i) == 0)
 522         {
 523             *(ht->objectHandle + i) = hobj;
 524             GlobalUnlock(hHT);
 525             return i;
 526         }
 527     }
 528     GlobalUnlock(hHT);
 529     if (!(hHT = GlobalReAlloc(hHT, HTINCR, GMEM_MOVEABLE | GMEM_ZEROINIT)))
 530         return -1;
 531     HTLen += HTINCR;
 532     ht = (HANDLETABLE *)GlobalLock(hHT);
 533     *(ht->objectHandle + i) = hobj;
 534     GlobalUnlock(hHT);
 535     return i;
 536 }
 537
 538
 539 /******************************************************************
 540  *         MF_MetaParam0
 541  */
 542 BOOL MF_MetaParam0(DC *dc, short func)
 543 {
 544     char buffer[8];
 545     METARECORD *mr = (METARECORD *)&buffer;
 546
 547     mr->rdSize = 3;
 548     mr->rdFunction = func;
 549     return MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 550 }
 551
 552
 553 /******************************************************************
 554  *         MF_MetaParam1
 555  */
 556 BOOL MF_MetaParam1(DC *dc, short func, short param1)
 557 {
 558     char buffer[8];
 559     METARECORD *mr = (METARECORD *)&buffer;
 560
 561     mr->rdSize = 4;
 562     mr->rdFunction = func;
 563     *(mr->rdParam) = param1;
 564     return MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 565 }
 566
 567
 568 /******************************************************************
 569  *         MF_MetaParam2
 570  */
 571 BOOL MF_MetaParam2(DC *dc, short func, short param1, short param2)
 572 {
 573     char buffer[10];
 574     METARECORD *mr = (METARECORD *)&buffer;
 575
 576     mr->rdSize = 5;
 577     mr->rdFunction = func;
 578     *(mr->rdParam) = param2;
 579     *(mr->rdParam + 1) = param1;
 580     return MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 581 }
 582
 583
 584 /******************************************************************
 585  *         MF_MetaParam4
 586  */
 587 BOOL MF_MetaParam4(DC *dc, short func, short param1, short param2,
 588                    short param3, short param4)
 589 {
 590     char buffer[14];
 591     METARECORD *mr = (METARECORD *)&buffer;
 592
 593     mr->rdSize = 7;
 594     mr->rdFunction = func;
 595     *(mr->rdParam) = param4;
 596     *(mr->rdParam + 1) = param3;
 597     *(mr->rdParam + 2) = param2;
 598     *(mr->rdParam + 3) = param1;
 599     return MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 600 }
 601
 602
 603 /******************************************************************
 604  *         MF_MetaParam6
 605  */
 606 BOOL MF_MetaParam6(DC *dc, short func, short param1, short param2,
 607                    short param3, short param4, short param5, short param6)
 608 {
 609     char buffer[18];
 610     METARECORD *mr = (METARECORD *)&buffer;
 611
 612     mr->rdSize = 9;
 613     mr->rdFunction = func;
 614     *(mr->rdParam) = param6;
 615     *(mr->rdParam + 1) = param5;
 616     *(mr->rdParam + 2) = param4;
 617     *(mr->rdParam + 3) = param3;
 618     *(mr->rdParam + 4) = param2;
 619     *(mr->rdParam + 5) = param1;
 620     return MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 621 }
 622
 623
 624 /******************************************************************
 625  *         MF_MetaParam8
 626  */
 627 BOOL MF_MetaParam8(DC *dc, short func, short param1, short param2,
 628                    short param3, short param4, short param5,
 629                    short param6, short param7, short param8)
 630 {
 631     char buffer[22];
 632     METARECORD *mr = (METARECORD *)&buffer;
 633
 634     mr->rdSize = 11;
 635     mr->rdFunction = func;
 636     *(mr->rdParam) = param8;
 637     *(mr->rdParam + 1) = param7;
 638     *(mr->rdParam + 2) = param6;
 639     *(mr->rdParam + 3) = param5;
 640     *(mr->rdParam + 4) = param4;
 641     *(mr->rdParam + 5) = param3;
 642     *(mr->rdParam + 6) = param2;
 643     *(mr->rdParam + 7) = param1;
 644     return MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 645 }
 646
 647
 648 /******************************************************************
 649  *         MF_CreateBrushIndirect
 650  */
 651 BOOL MF_CreateBrushIndirect(DC *dc, HBRUSH hBrush, LOGBRUSH *logbrush)
 652 {
 653     int index;
 654     BOOL rc;
 655     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGBRUSH)];
 656     METARECORD *mr = (METARECORD *)&buffer;
 657     METAFILE *mf;
 658     METAHEADER *mh;
 659
 660     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGBRUSH) - 2) / 2;
 661     mr->rdFunction = META_CREATEBRUSHINDIRECT;
 662     memcpy(&(mr->rdParam), logbrush, sizeof(LOGBRUSH));
 663     if (!MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2))
 664         return FALSE;
 665
 666     mr->rdSize = sizeof(METARECORD) / 2;
 667     mr->rdFunction = META_SELECTOBJECT;
 668     if ((index = MF_AddHandleInternal(hBrush)) == -1)
 669         return FALSE;
 670
 671     mf = (METAFILE *)GlobalLock(dc->w.hMetaFile);
 672     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 673     *(mr->rdParam) = index;
 674     if (index >= mh->mtNoObjects)
 675         mh->mtNoObjects++;
 676     rc = MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 677     GlobalUnlock(mf->hMetaHdr);
 678     GlobalUnlock(dc->w.hMetaFile);
 679     return rc;
 680 }
 681
 682
 683 /******************************************************************
 684  *         MF_CreatePatternBrush
 685  */
 686 BOOL MF_CreatePatternBrush(DC *dc, HBRUSH hBrush, LOGBRUSH *logbrush)
 687 {
 688     DWORD len, bmSize, biSize;
 689     HANDLE hmr;
 690     METARECORD *mr;
 691     BITMAPOBJ *bmp;
 692     BITMAPINFO *info;
 693     BITMAPINFOHEADER *infohdr;
 694     int index;
 695     BOOL rc;
 696     char buffer[sizeof(METARECORD)];
 697     METAFILE *mf;
 698     METAHEADER *mh;
 699
 700     switch (logbrush->lbStyle)
 701     {
 702     case BS_PATTERN:
 703         bmp = (BITMAPOBJ *)GDI_GetObjPtr(logbrush->lbHatch, BITMAP_MAGIC);
 704         if (!bmp) return FALSE;
 705         len = sizeof(METARECORD) + sizeof(BITMAPINFOHEADER) +
 706               (bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes) + 6;
 707         if (!(hmr = GlobalAlloc(GMEM_MOVEABLE, len)))
 708             return FALSE;
 709         mr = (METARECORD *)GlobalLock(hmr);
 710         memset(mr, 0, len);
 711         mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 712         mr->rdSize = len / 2;
 713         *(mr->rdParam) = logbrush->lbStyle;
 714         *(mr->rdParam + 1) = DIB_RGB_COLORS;
 715         infohdr = (BITMAPINFOHEADER *)(mr->rdParam + 2);
 716         infohdr->biSize = sizeof(BITMAPINFOHEADER);
 717         infohdr->biWidth = bmp->bitmap.bmWidth;
 718         infohdr->biHeight = bmp->bitmap.bmHeight;
 719         infohdr->biPlanes = bmp->bitmap.bmPlanes;
 720         infohdr->biBitCount = bmp->bitmap.bmBitsPixel;
 721         memcpy(mr->rdParam + (sizeof(BITMAPINFOHEADER) / 2) + 4,
 722                bmp->bitmap.bmBits,
 723                bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes);
 724         break;
 725
 726     case BS_DIBPATTERN:
 727         info = (BITMAPINFO *)GlobalLock(logbrush->lbHatch);
 728         bmSize = info->bmiHeader.biSizeImage;
 729         if (!bmSize)
 730             bmSize = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount
 731                     + 31) / 32 * 8 * info->bmiHeader.biHeight;
 732         biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush->lbColor));
 733         len = sizeof(METARECORD) + biSize + bmSize + 2;
 734         if (!(hmr = GlobalAlloc(GMEM_MOVEABLE, len)))
 735             return FALSE;
 736         mr = (METARECORD *)GlobalLock(hmr);
 737         memset(mr, 0, len);
 738         mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 739         mr->rdSize = len / 2;
 740         *(mr->rdParam) = logbrush->lbStyle;
 741         *(mr->rdParam + 1) = LOWORD(logbrush->lbColor);
 742         memcpy(mr->rdParam + 2, info, biSize + bmSize);
 743         break;
 744     }
 745     if (!MF_WriteRecord(dc->w.hMetaFile, mr, len))
 746     {
 747         GlobalFree(hmr);
 748         return FALSE;
 749     }
 750
 751     GlobalFree(hmr);
 752     mr = (METARECORD *)&buffer;
 753     mr->rdSize = sizeof(METARECORD) / 2;
 754     mr->rdFunction = META_SELECTOBJECT;
 755     if ((index = MF_AddHandleInternal(hBrush)) == -1)
 756         return FALSE;
 757
 758     mf = (METAFILE *)GlobalLock(dc->w.hMetaFile);
 759     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 760     *(mr->rdParam) = index;
 761     if (index >= mh->mtNoObjects)
 762         mh->mtNoObjects++;
 763     rc = MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 764     GlobalUnlock(mf->hMetaHdr);
 765     GlobalUnlock(dc->w.hMetaFile);
 766     return rc;
 767 }
 768
 769
 770 /******************************************************************
 771  *         MF_CreatePenIndirect
 772  */
 773 BOOL MF_CreatePenIndirect(DC *dc, HPEN hPen, LOGPEN *logpen)
 774 {
 775     int index;
 776     BOOL rc;
 777     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGPEN)];
 778     METARECORD *mr = (METARECORD *)&buffer;
 779     METAFILE *mf;
 780     METAHEADER *mh;
 781
 782     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGPEN) - 2) / 2;
 783     mr->rdFunction = META_CREATEPENINDIRECT;
 784     memcpy(&(mr->rdParam), logpen, sizeof(LOGPEN));
 785     if (!MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2))
 786         return FALSE;
 787
 788     mr->rdSize = sizeof(METARECORD) / 2;
 789     mr->rdFunction = META_SELECTOBJECT;
 790     if ((index = MF_AddHandleInternal(hPen)) == -1)
 791         return FALSE;
 792
 793     mf = (METAFILE *)GlobalLock(dc->w.hMetaFile);
 794     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 795     *(mr->rdParam) = index;
 796     if (index >= mh->mtNoObjects)
 797         mh->mtNoObjects++;
 798     rc = MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 799     GlobalUnlock(mf->hMetaHdr);
 800     GlobalUnlock(dc->w.hMetaFile);
 801     return rc;
 802 }
 803
 804
 805 /******************************************************************
 806  *         MF_CreateFontIndirect
 807  */
 808 BOOL MF_CreateFontIndirect(DC *dc, HFONT hFont, LOGFONT *logfont)
 809 {
 810     int index;
 811     BOOL rc;
 812     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT)];
 813     METARECORD *mr = (METARECORD *)&buffer;
 814     METAFILE *mf;
 815     METAHEADER *mh;
 816
 817     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT) - 2) / 2;
 818     mr->rdFunction = META_CREATEFONTINDIRECT;
 819     memcpy(&(mr->rdParam), logfont, sizeof(LOGFONT));
 820     if (!MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2))
 821         return FALSE;
 822
 823     mr->rdSize = sizeof(METARECORD) / 2;
 824     mr->rdFunction = META_SELECTOBJECT;
 825     if ((index = MF_AddHandleInternal(hFont)) == -1)
 826         return FALSE;
 827
 828     mf = (METAFILE *)GlobalLock(dc->w.hMetaFile);
 829     mh = (METAHEADER *)GlobalLock(mf->hMetaHdr);
 830     *(mr->rdParam) = index;
 831     if (index >= mh->mtNoObjects)
 832         mh->mtNoObjects++;
 833     rc = MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 834     GlobalUnlock(mf->hMetaHdr);
 835     GlobalUnlock(dc->w.hMetaFile);
 836     return rc;
 837 }
 838
 839
 840 /******************************************************************
 841  *         MF_TextOut
 842  */
 843 BOOL MF_TextOut(DC *dc, short x, short y, LPSTR str, short count)
 844 {
 845     BOOL rc;
 846     DWORD len;
 847     HANDLE hmr;
 848     METARECORD *mr;
 849
 850     len = sizeof(METARECORD) + (((count + 1) >> 1) * 2) + 4;
 851     if (!(hmr = GlobalAlloc(GMEM_MOVEABLE, len)))
 852         return FALSE;
 853     mr = (METARECORD *)GlobalLock(hmr);
 854     memset(mr, 0, len);
 855
 856     mr->rdSize = len / 2;
 857     mr->rdFunction = META_TEXTOUT;
 858     *(mr->rdParam) = count;
 859     memcpy(mr->rdParam + 1, str, count);
 860     *(mr->rdParam + ((count + 1) >> 1) + 1) = y;
 861     *(mr->rdParam + ((count + 1) >> 1) + 2) = x;
 862     rc = MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 863     GlobalFree(hmr);
 864     return rc;
 865 }
 866
 867
 868 /******************************************************************
 869  *         MF_MetaPoly - implements Polygon and Polyline
 870  */
 871 BOOL MF_MetaPoly(DC *dc, short func, LPPOINT pt, short count)
 872 {
 873     BOOL rc;
 874     DWORD len;
 875     HANDLE hmr;
 876     METARECORD *mr;
 877
 878     len = sizeof(METARECORD) + (count * 4);
 879     if (!(hmr = GlobalAlloc(GMEM_MOVEABLE, len)))
 880         return FALSE;
 881     mr = (METARECORD *)GlobalLock(hmr);
 882     memset(mr, 0, len);
 883
 884     mr->rdSize = len / 2;
 885     mr->rdFunction = func;
 886     *(mr->rdParam) = count;
 887     memcpy(mr->rdParam + 1, pt, count * 4);
 888     rc = MF_WriteRecord(dc->w.hMetaFile, mr, mr->rdSize * 2);
 889     GlobalFree(hmr);
 890     return rc;
 891 }
 892
 893
 894 /******************************************************************
 895  *         MF_BitBlt
 896  */
 897 BOOL MF_BitBlt(DC *dcDest, short xDest, short yDest, short width,
 898                short height, HDC hdcSrc, short xSrc, short ySrc, DWORD rop)
 899 {
 900     fprintf(stdnimp,"MF_BitBlt: not implemented yet\n");
 901 }
 902
 903
 904 /******************************************************************
 905  *         MF_StretchBlt
 906  */
 907 BOOL MF_StretchBlt(DC *dcDest, short xDest, short yDest, short widthDest,
 908                    short heightDest, HDC hdcSrc, short xSrc, short ySrc,
 909                    short widthSrc, short heightSrc, DWORD rop)
 910 {
 911     fprintf(stdnimp,"MF_StretchBlt: not implemented yet\n");
 912 }