1 /*
2 * Metafile functions
3 *
4 * Copyright David W. Metcalfe, 1994
5 * Copyright Niels de Carpentier, 1996
6 * Copyright Albrecht Kleine, 1996
7 * Copyright Huw Davies, 1996
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25
26 #include <string.h>
27 #include <fcntl.h>
28
29 #include "wine/winbase16.h"
30 #include "wine/wingdi16.h"
31 #include "wownt32.h"
32 #include "winreg.h"
33 #include "winternl.h"
34 #include "gdi_private.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
38
39 /******************************************************************
40 * MF_GetMetaHeader16
41 *
42 * Returns ptr to METAHEADER associated with HMETAFILE16
43 * Should be followed by call to MF_ReleaseMetaHeader16
44 */
45 static METAHEADER *MF_GetMetaHeader16( HMETAFILE16 hmf )
46 {
47 return GlobalLock16(hmf);
48 }
49
50 /******************************************************************
51 * MF_ReleaseMetaHeader16
52 *
53 * Releases METAHEADER associated with HMETAFILE16
54 */
55 static BOOL16 MF_ReleaseMetaHeader16( HMETAFILE16 hmf )
56 {
57 return GlobalUnlock16( hmf );
58 }
59
60 /******************************************************************
61 * DeleteMetaFile (GDI.127)
62 */
63 BOOL16 WINAPI DeleteMetaFile16( HMETAFILE16 hmf )
64 {
65 return !GlobalFree16( hmf );
66 }
67
68 /******************************************************************
69 * GetMetaFile (GDI.124)
70 */
71 HMETAFILE16 WINAPI GetMetaFile16( LPCSTR lpFilename )
72 {
73 METAHEADER *mh;
74 HANDLE hFile;
75
76 TRACE("%s\n", lpFilename);
77
78 if(!lpFilename)
79 return 0;
80
81 if((hFile = CreateFileA(lpFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
82 OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
83 return 0;
84
85 mh = MF_ReadMetaFile(hFile);
86 CloseHandle(hFile);
87 if(!mh) return 0;
88 return MF_Create_HMETAFILE16( mh );
89 }
90
91 /******************************************************************
92 * CopyMetaFile (GDI.151)
93 */
94 HMETAFILE16 WINAPI CopyMetaFile16( HMETAFILE16 hSrcMetaFile, LPCSTR lpFilename)
95 {
96 METAHEADER *mh = MF_GetMetaHeader16( hSrcMetaFile );
97 METAHEADER *mh2 = NULL;
98 HANDLE hFile;
99
100 TRACE("(%08x,%s)\n", hSrcMetaFile, lpFilename);
101
102 if(!mh) return 0;
103
104 if(mh->mtType == METAFILE_DISK)
105 mh2 = MF_LoadDiskBasedMetaFile(mh);
106 else {
107 mh2 = HeapAlloc( GetProcessHeap(), 0, mh->mtSize * 2 );
108 memcpy( mh2, mh, mh->mtSize * 2 );
109 }
110 MF_ReleaseMetaHeader16( hSrcMetaFile );
111
112 if(lpFilename) { /* disk based metafile */
113 DWORD w;
114 if((hFile = CreateFileA(lpFilename, GENERIC_WRITE, 0, NULL,
115 CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) {
116 HeapFree( GetProcessHeap(), 0, mh2 );
117 return 0;
118 }
119 WriteFile(hFile, mh2, mh2->mtSize * 2, &w, NULL);
120 CloseHandle(hFile);
121 mh2 = MF_CreateMetaHeaderDisk(mh2, lpFilename, FALSE);
122 }
123
124 return MF_Create_HMETAFILE16( mh2 );
125 }
126
127 /******************************************************************
128 * IsValidMetaFile (GDI.410)
129 *
130 * Attempts to check if a given metafile is correctly formatted.
131 * Currently, the only things verified are several properties of the
132 * header.
133 *
134 * RETURNS
135 * TRUE if hmf passes some tests for being a valid metafile, FALSE otherwise.
136 *
137 * BUGS
138 * This is not exactly what windows does, see _Undocumented_Windows_
139 * for details.
140 */
141 BOOL16 WINAPI IsValidMetaFile16(HMETAFILE16 hmf)
142 {
143 BOOL16 res=FALSE;
144 METAHEADER *mh = MF_GetMetaHeader16(hmf);
145 if (mh) {
146 if (mh->mtType == METAFILE_MEMORY || mh->mtType == METAFILE_DISK)
147 if (mh->mtHeaderSize == MFHEADERSIZE/sizeof(INT16))
148 if (mh->mtVersion == MFVERSION)
149 res=TRUE;
150 MF_ReleaseMetaHeader16(hmf);
151 }
152 TRACE("IsValidMetaFile %x => %d\n",hmf,res);
153 return res;
154 }
155
156 /******************************************************************
157 * PlayMetaFile (GDI.123)
158 *
159 */
160 BOOL16 WINAPI PlayMetaFile16( HDC16 hdc, HMETAFILE16 hmf )
161 {
162 BOOL16 ret;
163 METAHEADER *mh = MF_GetMetaHeader16( hmf );
164 ret = MF_PlayMetaFile( HDC_32(hdc), mh );
165 MF_ReleaseMetaHeader16( hmf );
166 return ret;
167 }
168
169
170 /******************************************************************
171 * EnumMetaFile (GDI.175)
172 *
173 */
174 BOOL16 WINAPI EnumMetaFile16( HDC16 hdc16, HMETAFILE16 hmf,
175 MFENUMPROC16 lpEnumFunc, LPARAM lpData )
176 {
177 METAHEADER *mh = MF_GetMetaHeader16(hmf);
178 METARECORD *mr;
179 HANDLETABLE16 *ht;
180 HDC hdc = HDC_32(hdc16);
181 HGLOBAL16 hHT;
182 SEGPTR spht;
183 unsigned int offset = 0;
184 WORD i, seg;
185 HPEN hPen;
186 HBRUSH hBrush;
187 HFONT hFont;
188 WORD args[8];
189 BOOL16 result = TRUE, loaded = FALSE;
190
191 TRACE("(%p, %04x, %p, %08lx)\n", hdc, hmf, lpEnumFunc, lpData);
192
193 if(!mh) return FALSE;
194 if(mh->mtType == METAFILE_DISK) { /* Create a memory-based copy */
195 mh = MF_LoadDiskBasedMetaFile(mh);
196 if(!mh) return FALSE;
197 loaded = TRUE;
198 }
199
200 /* save the current pen, brush and font */
201 hPen = GetCurrentObject(hdc, OBJ_PEN);
202 hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
203 hFont = GetCurrentObject(hdc, OBJ_FONT);
204
205 /* create the handle table */
206
207 hHT = GlobalAlloc16(GMEM_MOVEABLE | GMEM_ZEROINIT,
208 sizeof(HANDLETABLE16) * mh->mtNoObjects);
209 spht = WOWGlobalLock16(hHT);
210
211 seg = hmf | 7;
212 offset = mh->mtHeaderSize * 2;
213
214 /* loop through metafile records */
215
216 args[7] = hdc16;
217 args[6] = SELECTOROF(spht);
218 args[5] = OFFSETOF(spht);
219 args[4] = seg + (HIWORD(offset) << __AHSHIFT);
220 args[3] = LOWORD(offset);
221 args[2] = mh->mtNoObjects;
222 args[1] = HIWORD(lpData);
223 args[0] = LOWORD(lpData);
224
225 while (offset < (mh->mtSize * 2))
226 {
227 DWORD ret;
228
229 mr = (METARECORD *)((char *)mh + offset);
230
231 WOWCallback16Ex( (DWORD)lpEnumFunc, WCB16_PASCAL, sizeof(args), args, &ret );
232 if (!LOWORD(ret))
233 {
234 result = FALSE;
235 break;
236 }
237
238 offset += (mr->rdSize * 2);
239 args[4] = seg + (HIWORD(offset) << __AHSHIFT);
240 args[3] = LOWORD(offset);
241 }
242
243 SelectObject(hdc, hBrush);
244 SelectObject(hdc, hPen);
245 SelectObject(hdc, hFont);
246
247 ht = (HANDLETABLE16 *)GlobalLock16(hHT);
248
249 /* free objects in handle table */
250 for(i = 0; i < mh->mtNoObjects; i++)
251 if(*(ht->objectHandle + i) != 0)
252 DeleteObject( (HGDIOBJ)(ULONG_PTR)(*(ht->objectHandle + i) ));
253
254 /* free handle table */
255 GlobalFree16(hHT);
256 if(loaded)
257 HeapFree( GetProcessHeap(), 0, mh );
258 MF_ReleaseMetaHeader16(hmf);
259 return result;
260 }
261
262 /******************************************************************
263 * GetMetaFileBits (GDI.159)
264 *
265 * Trade in a metafile object handle for a handle to the metafile memory.
266 *
267 * PARAMS
268 * hmf [I] metafile handle
269 */
270
271 HGLOBAL16 WINAPI GetMetaFileBits16( HMETAFILE16 hmf )
272 {
273 TRACE("hMem out: %04x\n", hmf);
274 return hmf;
275 }
276
277 /******************************************************************
278 * SetMetaFileBits (GDI.160)
279 *
280 * Trade in a metafile memory handle for a handle to a metafile object.
281 * The memory region should hold a proper metafile, otherwise
282 * problems will occur when it is used. Validity of the memory is not
283 * checked. The function is essentially just the identity function.
284 *
285 * PARAMS
286 * hMem [I] handle to a memory region holding a metafile
287 *
288 * RETURNS
289 * Handle to a metafile on success, NULL on failure..
290 */
291 HMETAFILE16 WINAPI SetMetaFileBits16( HGLOBAL16 hMem )
292 {
293 TRACE("hmf out: %04x\n", hMem);
294
295 return hMem;
296 }
297
298 /******************************************************************
299 * SetMetaFileBitsBetter (GDI.196)
300 *
301 * Trade in a metafile memory handle for a handle to a metafile object,
302 * making a cursory check (using IsValidMetaFile()) that the memory
303 * handle points to a valid metafile.
304 *
305 * RETURNS
306 * Handle to a metafile on success, NULL on failure..
307 */
308 HMETAFILE16 WINAPI SetMetaFileBitsBetter16( HMETAFILE16 hMeta )
309 {
310 if( IsValidMetaFile16( hMeta ) )
311 return GlobalReAlloc16( hMeta, 0, GMEM_SHARE | GMEM_NODISCARD | GMEM_MODIFY);
312 return (HMETAFILE16)0;
313 }
314
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.