?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20050930.
[wine/gsoc-2012-control.git] / dlls / gdi / mfdrv / init.c
blobdfeafcf53ec1ba7924b481097322de2019e228e5
1 /*
2 * Metafile driver initialisation functions
3 *
4 * Copyright 1996 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include <stdarg.h>
22 #include <string.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wine/winbase16.h"
27 #include "gdi.h"
28 #include "wownt32.h"
29 #include "gdi_private.h"
30 #include "mfdrv/metafiledrv.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
34
35 static const DC_FUNCTIONS MFDRV_Funcs =
36 {
37 NULL, /* pAbortDoc */
38 MFDRV_AbortPath, /* pAbortPath */
39 NULL, /* pAlphaBlend */
40 NULL, /* pAngleArc */
41 MFDRV_Arc, /* pArc */
42 NULL, /* pArcTo */
43 MFDRV_BeginPath, /* pBeginPath */
44 MFDRV_BitBlt, /* pBitBlt */
45 NULL, /* pChoosePixelFormat */
46 MFDRV_Chord, /* pChord */
47 MFDRV_CloseFigure, /* pCloseFigure */
48 NULL, /* pCreateBitmap */
49 NULL, /* pCreateDC */
50 NULL, /* pCreateDIBSection */
51 NULL, /* pDeleteBitmap */
52 NULL, /* pDeleteDC */
53 MFDRV_DeleteObject, /* pDeleteObject */
54 NULL, /* pDescribePixelFormat */
55 NULL, /* pDeviceCapabilities */
56 MFDRV_Ellipse, /* pEllipse */
57 NULL, /* pEndDoc */
58 NULL, /* pEndPage */
59 MFDRV_EndPath, /* pEndPath */
60 NULL, /* pEnumDeviceFonts */
61 MFDRV_ExcludeClipRect, /* pExcludeClipRect */
62 NULL, /* pExtDeviceMode */
63 MFDRV_ExtEscape, /* pExtEscape */
64 MFDRV_ExtFloodFill, /* pExtFloodFill */
65 MFDRV_ExtSelectClipRgn, /* pExtSelectClipRgn */
66 MFDRV_ExtTextOut, /* pExtTextOut */
67 MFDRV_FillPath, /* pFillPath */
68 MFDRV_FillRgn, /* pFillRgn */
69 MFDRV_FlattenPath, /* pFlattenPath */
70 MFDRV_FrameRgn, /* pFrameRgn */
71 NULL, /* pGdiComment */
72 NULL, /* pGetBitmapBits */
73 NULL, /* pGetCharWidth */
74 NULL, /* pGetDCOrgEx */
75 NULL, /* pGetDIBColorTable */
76 NULL, /* pGetDIBits */
77 MFDRV_GetDeviceCaps, /* pGetDeviceCaps */
78 NULL, /* pGetDeviceGammaRamp */
79 NULL, /* pGetNearestColor */
80 NULL, /* pGetPixel */
81 NULL, /* pGetPixelFormat */
82 NULL, /* pGetSystemPaletteEntries */
83 NULL, /* pGetTextExtentPoint */
84 NULL, /* pGetTextMetrics */
85 MFDRV_IntersectClipRect, /* pIntersectClipRect */
86 MFDRV_InvertRgn, /* pInvertRgn */
87 MFDRV_LineTo, /* pLineTo */
88 NULL, /* pModifyWorldTransform */
89 MFDRV_MoveTo, /* pMoveTo */
90 MFDRV_OffsetClipRgn, /* pOffsetClipRgn */
91 MFDRV_OffsetViewportOrg, /* pOffsetViewportOrg */
92 MFDRV_OffsetWindowOrg, /* pOffsetWindowOrg */
93 MFDRV_PaintRgn, /* pPaintRgn */
94 MFDRV_PatBlt, /* pPatBlt */
95 MFDRV_Pie, /* pPie */
96 MFDRV_PolyBezier, /* pPolyBezier */
97 MFDRV_PolyBezierTo, /* pPolyBezierTo */
98 NULL, /* pPolyDraw */
99 MFDRV_PolyPolygon, /* pPolyPolygon */
100 NULL, /* pPolyPolyline */
101 MFDRV_Polygon, /* pPolygon */
102 MFDRV_Polyline, /* pPolyline */
103 NULL, /* pPolylineTo */
104 NULL, /* pRealizeDefaultPalette */
105 MFDRV_RealizePalette, /* pRealizePalette */
106 MFDRV_Rectangle, /* pRectangle */
107 NULL, /* pResetDC */
108 MFDRV_RestoreDC, /* pRestoreDC */
109 MFDRV_RoundRect, /* pRoundRect */
110 MFDRV_SaveDC, /* pSaveDC */
111 MFDRV_ScaleViewportExt, /* pScaleViewportExt */
112 MFDRV_ScaleWindowExt, /* pScaleWindowExt */
113 MFDRV_SelectBitmap, /* pSelectBitmap */
114 MFDRV_SelectBrush, /* pSelectBrush */
115 MFDRV_SelectClipPath, /* pSelectClipPath */
116 MFDRV_SelectFont, /* pSelectFont */
117 MFDRV_SelectPalette, /* pSelectPalette */
118 MFDRV_SelectPen, /* pSelectPen */
119 NULL, /* pSetArcDirection */
120 NULL, /* pSetBitmapBits */
121 MFDRV_SetBkColor, /* pSetBkColor */
122 MFDRV_SetBkMode, /* pSetBkMode */
123 NULL, /* pSetDCBrushColor*/
124 NULL, /* pSetDCOrg */
125 NULL, /* pSetDCPenColor*/
126 NULL, /* pSetDIBColorTable */
127 NULL, /* pSetDIBits */
128 MFDRV_SetDIBitsToDevice, /* pSetDIBitsToDevice */
129 NULL, /* pSetDeviceClipping */
130 NULL, /* pSetDeviceGammaRamp */
131 MFDRV_SetMapMode, /* pSetMapMode */
132 MFDRV_SetMapperFlags, /* pSetMapperFlags */
133 MFDRV_SetPixel, /* pSetPixel */
134 NULL, /* pSetPixelFormat */
135 MFDRV_SetPolyFillMode, /* pSetPolyFillMode */
136 MFDRV_SetROP2, /* pSetROP2 */
137 MFDRV_SetRelAbs, /* pSetRelAbs */
138 MFDRV_SetStretchBltMode, /* pSetStretchBltMode */
139 MFDRV_SetTextAlign, /* pSetTextAlign */
140 MFDRV_SetTextCharacterExtra, /* pSetTextCharacterExtra */
141 MFDRV_SetTextColor, /* pSetTextColor */
142 MFDRV_SetTextJustification, /* pSetTextJustification */
143 MFDRV_SetViewportExt, /* pSetViewportExt */
144 MFDRV_SetViewportOrg, /* pSetViewportOrg */
145 MFDRV_SetWindowExt, /* pSetWindowExt */
146 MFDRV_SetWindowOrg, /* pSetWindowOrg */
147 NULL, /* pSetWorldTransform */
148 NULL, /* pStartDoc */
149 NULL, /* pStartPage */
150 MFDRV_StretchBlt, /* pStretchBlt */
151 MFDRV_StretchDIBits, /* pStretchDIBits */
152 MFDRV_StrokeAndFillPath, /* pStrokeAndFillPath */
153 MFDRV_StrokePath, /* pStrokePath */
154 NULL, /* pSwapBuffers */
155 MFDRV_WidenPath /* pWidenPath */
156 };
157
158
159
160 /**********************************************************************
161 * MFDRV_AllocMetaFile
162 */
163 static DC *MFDRV_AllocMetaFile(void)
164 {
165 DC *dc;
166 METAFILEDRV_PDEVICE *physDev;
167
168 if (!(dc = DC_AllocDC( &MFDRV_Funcs, METAFILE_DC_MAGIC ))) return NULL;
169
170 physDev = HeapAlloc(GetProcessHeap(),0,sizeof(*physDev));
171 if (!physDev)
172 {
173 GDI_FreeObject( dc->hSelf, dc );
174 return NULL;
175 }
176 dc->physDev = (PHYSDEV)physDev;
177 physDev->hdc = dc->hSelf;
178 physDev->dc = dc;
179
180 if (!(physDev->mh = HeapAlloc( GetProcessHeap(), 0, sizeof(*physDev->mh) )))
181 {
182 HeapFree( GetProcessHeap(), 0, physDev );
183 GDI_FreeObject( dc->hSelf, dc );
184 return NULL;
185 }
186
187 physDev->handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, HANDLE_LIST_INC * sizeof(physDev->handles[0]));
188 physDev->handles_size = HANDLE_LIST_INC;
189 physDev->cur_handles = 0;
190
191 physDev->hFile = 0;
192
193 physDev->mh->mtHeaderSize = sizeof(METAHEADER) / sizeof(WORD);
194 physDev->mh->mtVersion = 0x0300;
195 physDev->mh->mtSize = physDev->mh->mtHeaderSize;
196 physDev->mh->mtNoObjects = 0;
197 physDev->mh->mtMaxRecord = 0;
198 physDev->mh->mtNoParameters = 0;
199
200 return dc;
201 }
202
203
204 /**********************************************************************
205 * MFDRV_DeleteDC
206 */
207 static BOOL MFDRV_DeleteDC( PHYSDEV dev )
208 {
209 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
210 DC *dc = physDev->dc;
211 DWORD index;
212
213 HeapFree( GetProcessHeap(), 0, physDev->mh );
214 for(index = 0; index < physDev->handles_size; index++)
215 if(physDev->handles[index])
216 GDI_hdc_not_using_object(physDev->handles[index], physDev->hdc);
217 HeapFree( GetProcessHeap(), 0, physDev->handles );
218 HeapFree( GetProcessHeap(), 0, physDev );
219 dc->physDev = NULL;
220 GDI_FreeObject( dc->hSelf, dc );
221 return TRUE;
222 }
223
224
225 /**********************************************************************
226 * CreateMetaFileW (GDI32.@)
227 *
228 * Create a new DC and associate it with a metafile. Pass a filename
229 * to create a disk-based metafile, NULL to create a memory metafile.
230 *
231 * PARAMS
232 * filename [I] Filename of disk metafile
233 *
234 * RETURNS
235 * A handle to the metafile DC if successful, NULL on failure.
236 */
237 HDC WINAPI CreateMetaFileW( LPCWSTR filename )
238 {
239 HDC ret;
240 DC *dc;
241 METAFILEDRV_PDEVICE *physDev;
242 HANDLE hFile;
243
244 TRACE("'%s'\n", debugstr_w(filename) );
245
246 if (!(dc = MFDRV_AllocMetaFile())) return 0;
247 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
248
249 if (filename) /* disk based metafile */
250 {
251 physDev->mh->mtType = METAFILE_DISK;
252 if ((hFile = CreateFileW(filename, GENERIC_WRITE, 0, NULL,
253 CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) {
254 MFDRV_DeleteDC( dc->physDev );
255 return 0;
256 }
257 if (!WriteFile( hFile, physDev->mh, sizeof(*physDev->mh), NULL,
258 NULL )) {
259 MFDRV_DeleteDC( dc->physDev );
260 return 0;
261 }
262 physDev->hFile = hFile;
263
264 /* Grow METAHEADER to include filename */
265 physDev->mh = MF_CreateMetaHeaderDisk(physDev->mh, filename, TRUE);
266 }
267 else /* memory based metafile */
268 physDev->mh->mtType = METAFILE_MEMORY;
269
270 TRACE("returning %p\n", dc->hSelf);
271 ret = dc->hSelf;
272 GDI_ReleaseObj( dc->hSelf );
273 return ret;
274 }
275
276 /**********************************************************************
277 * CreateMetaFileA (GDI32.@)
278 */
279 HDC WINAPI CreateMetaFileA(LPCSTR filename)
280 {
281 LPWSTR filenameW;
282 DWORD len;
283 HDC hReturnDC;
284
285 if (!filename) return CreateMetaFileW(NULL);
286
287 len = MultiByteToWideChar( CP_ACP, 0, filename, -1, NULL, 0 );
288 filenameW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
289 MultiByteToWideChar( CP_ACP, 0, filename, -1, filenameW, len );
290
291 hReturnDC = CreateMetaFileW(filenameW);
292
293 HeapFree( GetProcessHeap(), 0, filenameW );
294
295 return hReturnDC;
296 }
297
298
299 /**********************************************************************
300 * MFDRV_CloseMetaFile
301 */
302 static DC *MFDRV_CloseMetaFile( HDC hdc )
303 {
304 DC *dc;
305 METAFILEDRV_PDEVICE *physDev;
306
307 TRACE("(%p)\n", hdc );
308
309 if (!(dc = (DC *) GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC ))) return 0;
310 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
311
312 /* Construct the end of metafile record - this is documented
313 * in SDK Knowledgebase Q99334.
314 */
315
316 if (!MFDRV_MetaParam0(dc->physDev, META_EOF))
317 {
318 MFDRV_DeleteDC( dc->physDev );
319 return 0;
320 }
321
322 if (physDev->mh->mtType == METAFILE_DISK) /* disk based metafile */
323 {
324 if (SetFilePointer(physDev->hFile, 0, NULL, FILE_BEGIN) != 0) {
325 MFDRV_DeleteDC( dc->physDev );
326 return 0;
327 }
328
329 physDev->mh->mtType = METAFILE_MEMORY; /* This is what windows does */
330 if (!WriteFile(physDev->hFile, (LPSTR)physDev->mh,
331 sizeof(*physDev->mh), NULL, NULL)) {
332 MFDRV_DeleteDC( dc->physDev );
333 return 0;
334 }
335 CloseHandle(physDev->hFile);
336 physDev->mh->mtType = METAFILE_DISK;
337 }
338
339 return dc;
340 }
341
342 /******************************************************************
343 * CloseMetaFile (GDI.126)
344 *
345 * PARAMS
346 * hdc [I] Metafile DC to close
347 */
348 HMETAFILE16 WINAPI CloseMetaFile16(HDC16 hdc)
349 {
350 HMETAFILE16 hmf;
351 METAFILEDRV_PDEVICE *physDev;
352 DC *dc = MFDRV_CloseMetaFile(HDC_32(hdc));
353 if (!dc) return 0;
354 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
355
356 /* Now allocate a global handle for the metafile */
357
358 hmf = MF_Create_HMETAFILE16( physDev->mh );
359
360 physDev->mh = NULL; /* So it won't be deleted */
361 MFDRV_DeleteDC( dc->physDev );
362 return hmf;
363 }
364
365 /******************************************************************
366 * CloseMetaFile (GDI32.@)
367 *
368 * Stop recording graphics operations in metafile associated with
369 * hdc and retrieve metafile.
370 *
371 * PARAMS
372 * hdc [I] Metafile DC to close
373 *
374 * RETURNS
375 * Handle of newly created metafile on success, NULL on failure.
376 */
377 HMETAFILE WINAPI CloseMetaFile(HDC hdc)
378 {
379 HMETAFILE hmf;
380 METAFILEDRV_PDEVICE *physDev;
381 DC *dc = MFDRV_CloseMetaFile(hdc);
382 if (!dc) return 0;
383 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
384
385 /* Now allocate a global handle for the metafile */
386
387 hmf = MF_Create_HMETAFILE( physDev->mh );
388
389 physDev->mh = NULL; /* So it won't be deleted */
390 MFDRV_DeleteDC( dc->physDev );
391 return hmf;
392 }
393
394
395 /******************************************************************
396 * MFDRV_WriteRecord
397 *
398 * Warning: this function can change the pointer to the metafile header.
399 */
400 BOOL MFDRV_WriteRecord( PHYSDEV dev, METARECORD *mr, DWORD rlen)
401 {
402 DWORD len, size;
403 METAHEADER *mh;
404 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
405
406 switch(physDev->mh->mtType)
407 {
408 case METAFILE_MEMORY:
409 len = physDev->mh->mtSize * 2 + rlen;
410 /* reallocate memory if needed */
411 size = HeapSize( GetProcessHeap(), 0, physDev->mh );
412 if (len > size)
413 {
414 /*expand size*/
415 size += size / 2 + rlen;
416 mh = HeapReAlloc( GetProcessHeap(), 0, physDev->mh, size);
417 if (!mh) return FALSE;
418 physDev->mh = mh;
419 TRACE("Reallocated metafile: new size is %ld\n",size);
420 }
421 memcpy((WORD *)physDev->mh + physDev->mh->mtSize, mr, rlen);
422 break;
423 case METAFILE_DISK:
424 TRACE("Writing record to disk\n");
425 if (!WriteFile(physDev->hFile, (char *)mr, rlen, NULL, NULL))
426 return FALSE;
427 break;
428 default:
429 ERR("Unknown metafile type %d\n", physDev->mh->mtType );
430 return FALSE;
431 }
432
433 physDev->mh->mtSize += rlen / 2;
434 physDev->mh->mtMaxRecord = max(physDev->mh->mtMaxRecord, rlen / 2);
435 return TRUE;
436 }
437
438
439 /******************************************************************
440 * MFDRV_MetaParam0
441 */
442
443 BOOL MFDRV_MetaParam0(PHYSDEV dev, short func)
444 {
445 char buffer[8];
446 METARECORD *mr = (METARECORD *)&buffer;
447
448 mr->rdSize = 3;
449 mr->rdFunction = func;
450 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
451 }
452
453
454 /******************************************************************
455 * MFDRV_MetaParam1
456 */
457 BOOL MFDRV_MetaParam1(PHYSDEV dev, short func, short param1)
458 {
459 char buffer[8];
460 METARECORD *mr = (METARECORD *)&buffer;
461
462 mr->rdSize = 4;
463 mr->rdFunction = func;
464 *(mr->rdParm) = param1;
465 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
466 }
467
468
469 /******************************************************************
470 * MFDRV_MetaParam2
471 */
472 BOOL MFDRV_MetaParam2(PHYSDEV dev, short func, short param1, short param2)
473 {
474 char buffer[10];
475 METARECORD *mr = (METARECORD *)&buffer;
476
477 mr->rdSize = 5;
478 mr->rdFunction = func;
479 *(mr->rdParm) = param2;
480 *(mr->rdParm + 1) = param1;
481 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
482 }
483
484
485 /******************************************************************
486 * MFDRV_MetaParam4
487 */
488
489 BOOL MFDRV_MetaParam4(PHYSDEV dev, short func, short param1, short param2,
490 short param3, short param4)
491 {
492 char buffer[14];
493 METARECORD *mr = (METARECORD *)&buffer;
494
495 mr->rdSize = 7;
496 mr->rdFunction = func;
497 *(mr->rdParm) = param4;
498 *(mr->rdParm + 1) = param3;
499 *(mr->rdParm + 2) = param2;
500 *(mr->rdParm + 3) = param1;
501 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
502 }
503
504
505 /******************************************************************
506 * MFDRV_MetaParam6
507 */
508
509 BOOL MFDRV_MetaParam6(PHYSDEV dev, short func, short param1, short param2,
510 short param3, short param4, short param5, short param6)
511 {
512 char buffer[18];
513 METARECORD *mr = (METARECORD *)&buffer;
514
515 mr->rdSize = 9;
516 mr->rdFunction = func;
517 *(mr->rdParm) = param6;
518 *(mr->rdParm + 1) = param5;
519 *(mr->rdParm + 2) = param4;
520 *(mr->rdParm + 3) = param3;
521 *(mr->rdParm + 4) = param2;
522 *(mr->rdParm + 5) = param1;
523 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
524 }
525
526
527 /******************************************************************
528 * MFDRV_MetaParam8
529 */
530 BOOL MFDRV_MetaParam8(PHYSDEV dev, short func, short param1, short param2,
531 short param3, short param4, short param5,
532 short param6, short param7, short param8)
533 {
534 char buffer[22];
535 METARECORD *mr = (METARECORD *)&buffer;
536
537 mr->rdSize = 11;
538 mr->rdFunction = func;
539 *(mr->rdParm) = param8;
540 *(mr->rdParm + 1) = param7;
541 *(mr->rdParm + 2) = param6;
542 *(mr->rdParm + 3) = param5;
543 *(mr->rdParm + 4) = param4;
544 *(mr->rdParm + 5) = param3;
545 *(mr->rdParm + 6) = param2;
546 *(mr->rdParm + 7) = param1;
547 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
548 }
549
550
551 /**********************************************************************
552 * MFDRV_ExtEscape
553 */
554 INT MFDRV_ExtEscape( PHYSDEV dev, INT nEscape, INT cbInput, LPCVOID in_data,
555 INT cbOutput, LPVOID out_data )
556 {
557 METARECORD *mr;
558 DWORD len;
559 INT ret;
560
561 len = sizeof(*mr) + sizeof(WORD) + ((cbInput + 1) & ~1);
562 mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
563 mr->rdSize = len / 2;
564 mr->rdFunction = META_ESCAPE;
565 mr->rdParm[0] = nEscape;
566 mr->rdParm[1] = cbInput;
567 memcpy(&(mr->rdParm[2]), in_data, cbInput);
568 ret = MFDRV_WriteRecord( dev, mr, len);
569 HeapFree(GetProcessHeap(), 0, mr);
570 return ret;
571 }
572
573
574 /******************************************************************
575 * MFDRV_GetDeviceCaps
576 *
577 *A very simple implementation that returns DT_METAFILE
578 */
579 INT MFDRV_GetDeviceCaps(PHYSDEV dev, INT cap)
580 {
581 switch(cap)
582 {
583 case TECHNOLOGY:
584 return DT_METAFILE;
585 case TEXTCAPS:
586 return 0;
587 default:
588 TRACE(" unsupported capability %d, will return 0\n", cap );
589 }
590 return 0;
591 }
GSOC 2012 project to enhance the control panel