graphics/metafiledrv/init.c

   1 /*
   2  * Metafile driver initialisation functions
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include "metafiledrv.h"
   8 #include "dc.h"
   9 #include "heap.h"
  10 #include "global.h"
  11 #include "metafile.h"
  12 #include "debug.h"
  13
  14 #include <string.h>
  15
  16 static const DC_FUNCTIONS MFDRV_Funcs =
  17 {
  18     MFDRV_Arc,                       /* pArc */
  19     MFDRV_BitBlt,                    /* pBitBlt */
  20     MFDRV_Chord,                     /* pChord */
  21     NULL, /* no implementation */    /* pCreateDC */
  22     NULL, /* no implementation */    /* pDeleteDC */
  23     NULL,                            /* pDeleteObject */
  24     MFDRV_Ellipse,                   /* pEllipse */
  25     NULL,                            /* pEnumDeviceFonts */
  26     NULL,                            /* pEscape */
  27     NULL,                            /* pExcludeClipRect */
  28     NULL,                            /* pExcludeVisRect */
  29     MFDRV_ExtFloodFill,              /* pExtFloodFill */
  30     MFDRV_ExtTextOut,                /* pExtTextOut */
  31     NULL,                            /* pGetCharWidth */
  32     NULL, /* no implementation */    /* pGetPixel */
  33     NULL,                            /* pGetTextExtentPoint */
  34     NULL,                            /* pGetTextMetrics */
  35     NULL,                            /* pIntersectClipRect */
  36     NULL,                            /* pIntersectVisRect */
  37     MFDRV_LineTo,                    /* pLineTo */
  38     MFDRV_MoveToEx,                  /* pMoveToEx */
  39     NULL,                            /* pOffsetClipRgn */
  40     MFDRV_OffsetViewportOrg,         /* pOffsetViewportOrg */
  41     MFDRV_OffsetWindowOrg,           /* pOffsetWindowOrg */
  42     MFDRV_PaintRgn,                  /* pPaintRgn */
  43     MFDRV_PatBlt,                    /* pPatBlt */
  44     MFDRV_Pie,                       /* pPie */
  45     MFDRV_PolyPolygon,               /* pPolyPolygon */
  46     NULL,                            /* pPolyPolyline */
  47     MFDRV_Polygon,                   /* pPolygon */
  48     MFDRV_Polyline,                  /* pPolyline */
  49     NULL,                            /* pRealizePalette */
  50     MFDRV_Rectangle,                 /* pRectangle */
  51     NULL,                            /* pRestoreDC */
  52     MFDRV_RoundRect,                 /* pRoundRect */
  53     NULL,                            /* pSaveDC */
  54     MFDRV_ScaleViewportExt,          /* pScaleViewportExt */
  55     MFDRV_ScaleWindowExt,            /* pScaleWindowExt */
  56     NULL,                            /* pSelectClipRgn */
  57     MFDRV_SelectObject,              /* pSelectObject */
  58     NULL,                            /* pSelectPalette */
  59     NULL,                            /* pSetBkColor */
  60     NULL,                            /* pSetBkMode */
  61     NULL,                            /* pSetDeviceClipping */
  62     NULL,                            /* pSetDIBitsToDevice */
  63     MFDRV_SetMapMode,                /* pSetMapMode */
  64     NULL,                            /* pSetMapperFlags */
  65     MFDRV_SetPixel,                  /* pSetPixel */
  66     NULL,                            /* pSetPolyFillMode */
  67     NULL,                            /* pSetROP2 */
  68     NULL,                            /* pSetRelAbs */
  69     NULL,                            /* pSetStretchBltMode */
  70     NULL,                            /* pSetTextAlign */
  71     NULL,                            /* pSetTextCharacterExtra */
  72     NULL,                            /* pSetTextColor */
  73     NULL,                            /* pSetTextJustification */
  74     MFDRV_SetViewportExt,            /* pSetViewportExt */
  75     MFDRV_SetViewportOrg,            /* pSetViewportOrg */
  76     MFDRV_SetWindowExt,              /* pSetWindowExt */
  77     MFDRV_SetWindowOrg,              /* pSetWindowOrg */
  78     MFDRV_StretchBlt,                /* pStretchBlt */
  79     NULL                             /* pStretchDIBits */
  80 };
  81
  82
  83
  84 /**********************************************************************
  85  *           MFDRV_AllocMetaFile
  86  */
  87 static DC *MFDRV_AllocMetaFile(void)
  88 {
  89     DC *dc;
  90     METAFILEDRV_PDEVICE *physDev;
  91
  92     if (!(dc = DC_AllocDC( &MFDRV_Funcs ))) return NULL;
  93     dc->header.wMagic = METAFILE_DC_MAGIC;
  94
  95     physDev = (METAFILEDRV_PDEVICE *)HeapAlloc(SystemHeap,0,sizeof(*physDev));
  96     if (!physDev)
  97     {
  98         GDI_HEAP_FREE( dc->hSelf );
  99         return NULL;
 100     }
 101     dc->physDev = physDev;
 102
 103     if (!(physDev->mh = HeapAlloc( SystemHeap, 0, sizeof(*physDev->mh) )))
 104     {
 105         HeapFree( SystemHeap, 0, physDev );
 106         GDI_HEAP_FREE( dc->hSelf );
 107         return NULL;
 108     }
 109
 110     physDev->nextHandle = 0;
 111
 112     physDev->mh->mtHeaderSize   = sizeof(METAHEADER) / sizeof(WORD);
 113     physDev->mh->mtVersion      = 0x0300;
 114     physDev->mh->mtSize         = physDev->mh->mtHeaderSize;
 115     physDev->mh->mtNoObjects    = 0;
 116     physDev->mh->mtMaxRecord    = 0;
 117     physDev->mh->mtNoParameters = 0;
 118
 119 /*    DC_InitDC( dc ); */
 120     return dc;
 121 }
 122
 123
 124 /**********************************************************************
 125 *            MFDRV_DeleteDC
 126  */
 127 static BOOL32 MFDRV_DeleteDC( DC *dc )
 128 {
 129     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
 130
 131     if (physDev->mh) HeapFree( SystemHeap, 0, physDev->mh );
 132     HeapFree( SystemHeap, 0, physDev );
 133     dc->physDev = NULL;
 134     GDI_FreeObject(dc->hSelf);
 135     return TRUE;
 136 }
 137
 138
 139 /**********************************************************************
 140  *           CreateMetaFile16   (GDI.125)
 141  *
 142  *  Create a new DC and associate it with a metafile. Pass a filename
 143  *  to create a disk-based metafile, NULL to create a memory metafile.
 144  *
 145  * RETURNS
 146  *  A handle to the metafile DC if successful, NULL on failure.
 147  */
 148 HDC16 WINAPI CreateMetaFile16(
 149                               LPCSTR filename /* Filename of disk metafile */
 150 )
 151 {
 152     DC *dc;
 153     METAFILEDRV_PDEVICE *physDev;
 154     HFILE32 hFile;
 155
 156     TRACE(metafile, "'%s'\n", filename );
 157
 158     if (!(dc = MFDRV_AllocMetaFile())) return 0;
 159     physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
 160
 161     if (filename)  /* disk based metafile */
 162     {
 163         physDev->mh->mtType = METAFILE_DISK;
 164         if ((hFile = _lcreat32( filename, 0 )) == HFILE_ERROR32)
 165         {
 166             MFDRV_DeleteDC( dc );
 167             return 0;
 168         }
 169         if (_lwrite32( hFile, (LPSTR)physDev->mh,
 170                        sizeof(*physDev->mh)) == HFILE_ERROR32)
 171         {
 172             MFDRV_DeleteDC( dc );
 173             return 0;
 174         }
 175         physDev->mh->mtNoParameters = hFile; /* store file descriptor here */
 176                                     /* windows probably uses this too*/
 177     }
 178     else  /* memory based metafile */
 179         physDev->mh->mtType = METAFILE_MEMORY;
 180
 181     TRACE(metafile, "returning %04x\n", dc->hSelf);
 182     return dc->hSelf;
 183 }
 184
 185 /**********************************************************************
 186  *           CreateMetaFile32A   (GDI32.51)
 187  */
 188 HDC32 WINAPI CreateMetaFile32A(
 189                               LPCSTR filename /* Filename of disk metafile */
 190 )
 191 {
 192   return CreateMetaFile16( filename );
 193 }
 194
 195 static DC *METAFILE_CloseMetaFile( HDC32 hdc )
 196 {
 197     DC *dc;
 198     HFILE32 hFile;
 199     METAFILEDRV_PDEVICE *physDev;
 200
 201     TRACE(metafile, "(%04x)\n", hdc );
 202
 203     if (!(dc = (DC *) GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC ))) return 0;
 204     physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
 205
 206     /* Construct the end of metafile record - this is documented
 207      * in SDK Knowledgebase Q99334.
 208      */
 209
 210     if (!MF_MetaParam0(dc, META_EOF))
 211     {
 212         MFDRV_DeleteDC( dc );
 213         return 0;
 214     }
 215
 216     if (physDev->mh->mtType == METAFILE_DISK)  /* disk based metafile */
 217     {
 218         hFile = physDev->mh->mtNoParameters;
 219         physDev->mh->mtNoParameters = 0;
 220         if (_llseek32(hFile, 0L, 0) == HFILE_ERROR32)
 221         {
 222             MFDRV_DeleteDC( dc );
 223             return 0;
 224         }
 225         if (_lwrite32( hFile, (LPSTR)physDev->mh,
 226                        sizeof(*physDev->mh)) == HFILE_ERROR32)
 227         {
 228             MFDRV_DeleteDC( dc );
 229             return 0;
 230         }
 231         _lclose32(hFile);
 232     }
 233
 234     return dc;
 235 }
 236
 237 /******************************************************************
 238  *           CloseMetaFile16   (GDI.126)
 239  */
 240 HMETAFILE16 WINAPI CloseMetaFile16(
 241                                    HDC16 hdc /* Metafile DC to close */
 242 )
 243 {
 244     HMETAFILE16 hmf;
 245     METAFILEDRV_PDEVICE *physDev;
 246     DC *dc = METAFILE_CloseMetaFile(hdc);
 247     if (!dc) return 0;
 248     physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
 249
 250     /* Now allocate a global handle for the metafile */
 251
 252     hmf = GLOBAL_CreateBlock( GMEM_MOVEABLE, physDev->mh,
 253                               physDev->mh->mtSize * sizeof(WORD),
 254                               GetCurrentPDB(), FALSE, FALSE, FALSE, NULL );
 255     physDev->mh = NULL;  /* So it won't be deleted */
 256     MFDRV_DeleteDC( dc );
 257     return hmf;
 258 }
 259
 260 /******************************************************************
 261  *           CloseMetaFile32   (GDI32.17)
 262  *
 263  *  Stop recording graphics operations in metafile associated with
 264  *  hdc and retrieve metafile.
 265  *
 266  * RETURNS
 267  *  Handle of newly created metafile on success, NULL on failure.
 268  */
 269 HMETAFILE32 WINAPI CloseMetaFile32(
 270                                    HDC32 hdc /* Metafile DC to close */
 271 )
 272 {
 273   return CloseMetaFile32(hdc);
 274 }
 275
 276
 277 /******************************************************************
 278  *           DeleteMetaFile16   (GDI.127)
 279  */
 280 BOOL16 WINAPI DeleteMetaFile16(
 281                                HMETAFILE16 hmf
 282                                /* Handle of memory metafile to delete */
 283 )
 284 {
 285     return !GlobalFree16( hmf );
 286 }
 287
 288 /******************************************************************
 289  *          DeleteMetaFile32  (GDI32.69)
 290  *
 291  *  Delete a memory-based metafile.
 292  */
 293
 294 BOOL32 WINAPI DeleteMetaFile32(
 295               HMETAFILE32 hmf
 296 ) {
 297   return !GlobalFree16( hmf );
 298 }
 299
 300 /********************************************************************
 301
 302        Enhanced Metafile driver initializations
 303
 304        This possibly  should be moved to their own file/directory
 305        at some point.
 306
 307 **********************************************************************/
 308
 309 /*
 310   need wide version as well
 311 */
 312 HDC32 CreateEnhMetaFile32A(
 313     HDC32 hdc, /* optional reference DC */
 314     LPCSTR filename, /* optional filename for disk metafiles */
 315     const RECT32 *rect, /* optional bounding rectangle */
 316     LPCSTR description /* optional description */
 317     )
 318 {
 319 #if 0
 320     DC *dc;
 321     METAFILEDRV_PDEVICE *physDev;
 322     HFILE32 hFile;
 323
 324     if (!(dc = MFDRV_AllocMetaFile())) return 0;
 325     physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
 326
 327     if (filename)  /* disk based metafile */
 328     {
 329         physDev->mh->mtType = METAFILE_DISK;
 330         if ((hFile = _lcreat32( filename, 0 )) == HFILE_ERROR32)
 331         {
 332             MFDRV_DeleteDC( dc );
 333             return 0;
 334         }
 335         if (_lwrite32( hFile, (LPSTR)physDev->mh,
 336                        sizeof(*physDev->mh)) == HFILE_ERROR32)
 337         {
 338             MFDRV_DeleteDC( dc );
 339             return 0;
 340         }
 341         physDev->mh->mtNoParameters = hFile; /* store file descriptor here */
 342                                     /* windows probably uses this too*/
 343     }
 344     else  /* memory based metafile */
 345         physDev->mh->mtType = METAFILE_MEMORY;
 346
 347     TRACE(metafile, "returning %04x\n", dc->hSelf);
 348     return dc->hSelf;
 349 #endif
 350     return 0;
 351 }
 352
 353 HENHMETAFILE32 CloseEnhMetaFile32(
 354                HDC32 hdc  /* metafile DC */
 355                )
 356 {
 357   /* write EMR_EOF(0x0, 0x10, 0x14) */
 358   return 0;
 359 }
 360
 361