]> git.saurik.com Git - wxWidgets.git/blob - src/msw/metafile.cpp
added possibility to throw different objects and crash directly from the main frame...
[wxWidgets.git] / src / msw / metafile.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/metafile.cpp
3 // Purpose: wxMetafileDC etc.
4 // Author: Julian Smart
5 // Modified by: VZ 07.01.00: implemented wxMetaFileDataObject
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "metafile.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/setup.h"
33 #endif
34
35 #ifndef WX_PRECOMP
36 #include "wx/utils.h"
37 #include "wx/app.h"
38 #endif
39
40 #include "wx/metafile.h"
41
42 #if wxUSE_METAFILE && !defined(wxMETAFILE_IS_ENH)
43
44 #include "wx/clipbrd.h"
45 #include "wx/msw/private.h"
46
47 #include <stdio.h>
48 #include <string.h>
49
50 // ----------------------------------------------------------------------------
51 // wxWin macros
52 // ----------------------------------------------------------------------------
53
54 IMPLEMENT_DYNAMIC_CLASS(wxMetafile, wxObject)
55 IMPLEMENT_ABSTRACT_CLASS(wxMetafileDC, wxDC)
56
57 // ============================================================================
58 // implementation
59 // ============================================================================
60
61 // ----------------------------------------------------------------------------
62 // wxMetafileRefData
63 // ----------------------------------------------------------------------------
64
65 /*
66 * Metafiles
67 * Currently, the only purpose for making a metafile is to put
68 * it on the clipboard.
69 */
70
71 wxMetafileRefData::wxMetafileRefData()
72 {
73 m_metafile = 0;
74 m_windowsMappingMode = wxMM_ANISOTROPIC;
75 m_width = m_height = 0;
76 }
77
78 wxMetafileRefData::~wxMetafileRefData()
79 {
80 if (m_metafile)
81 {
82 DeleteMetaFile((HMETAFILE) m_metafile);
83 m_metafile = 0;
84 }
85 }
86
87 // ----------------------------------------------------------------------------
88 // wxMetafile
89 // ----------------------------------------------------------------------------
90
91 wxMetafile::wxMetafile(const wxString& file)
92 {
93 m_refData = new wxMetafileRefData;
94
95 M_METAFILEDATA->m_windowsMappingMode = wxMM_ANISOTROPIC;
96 M_METAFILEDATA->m_metafile = 0;
97 if (!file.empty())
98 M_METAFILEDATA->m_metafile = (WXHANDLE) GetMetaFile(file);
99 }
100
101 wxMetafile::~wxMetafile()
102 {
103 }
104
105 bool wxMetafile::SetClipboard(int width, int height)
106 {
107 #if !wxUSE_CLIPBOARD
108 return false;
109 #else
110 if (!m_refData)
111 return false;
112
113 bool alreadyOpen = wxClipboardOpen();
114 if (!alreadyOpen)
115 {
116 wxOpenClipboard();
117 if (!wxEmptyClipboard())
118 return false;
119 }
120 bool success = wxSetClipboardData(wxDF_METAFILE, this, width,height);
121 if (!alreadyOpen)
122 wxCloseClipboard();
123
124 return success;
125 #endif
126 }
127
128 bool wxMetafile::Play(wxDC *dc)
129 {
130 if (!m_refData)
131 return false;
132
133 dc->BeginDrawing();
134
135 if (dc->GetHDC() && M_METAFILEDATA->m_metafile)
136 {
137 if ( !::PlayMetaFile(GetHdcOf(*dc), (HMETAFILE)
138 M_METAFILEDATA->m_metafile) )
139 {
140 wxLogLastError(_T("PlayMetaFile"));
141 }
142 }
143
144 dc->EndDrawing();
145
146 return true;
147 }
148
149 void wxMetafile::SetHMETAFILE(WXHANDLE mf)
150 {
151 if (!m_refData)
152 m_refData = new wxMetafileRefData;
153
154 M_METAFILEDATA->m_metafile = mf;
155 }
156
157 void wxMetafile::SetWindowsMappingMode(int mm)
158 {
159 if (!m_refData)
160 m_refData = new wxMetafileRefData;
161
162 M_METAFILEDATA->m_windowsMappingMode = mm;
163 }
164
165 // ----------------------------------------------------------------------------
166 // Metafile device context
167 // ----------------------------------------------------------------------------
168
169 // Original constructor that does not takes origin and extent. If you use this,
170 // *DO* give origin/extent arguments to wxMakeMetafilePlaceable.
171 wxMetafileDC::wxMetafileDC(const wxString& file)
172 {
173 m_metaFile = NULL;
174 m_minX = 10000;
175 m_minY = 10000;
176 m_maxX = -10000;
177 m_maxY = -10000;
178 // m_title = NULL;
179
180 if (!file.IsNull() && wxFileExists(file))
181 wxRemoveFile(file);
182
183 if (!file.IsNull() && (file != wxEmptyString))
184 m_hDC = (WXHDC) CreateMetaFile(file);
185 else
186 m_hDC = (WXHDC) CreateMetaFile(NULL);
187
188 m_ok = (m_hDC != (WXHDC) 0) ;
189
190 // Actual Windows mapping mode, for future reference.
191 m_windowsMappingMode = wxMM_TEXT;
192
193 SetMapMode(wxMM_TEXT); // NOTE: does not set HDC mapmode (this is correct)
194 }
195
196 // New constructor that takes origin and extent. If you use this, don't
197 // give origin/extent arguments to wxMakeMetafilePlaceable.
198 wxMetafileDC::wxMetafileDC(const wxString& file, int xext, int yext, int xorg, int yorg)
199 {
200 m_minX = 10000;
201 m_minY = 10000;
202 m_maxX = -10000;
203 m_maxY = -10000;
204 if ( !file.IsEmpty() && wxFileExists(file))
205 wxRemoveFile(file);
206 m_hDC = (WXHDC) CreateMetaFile(file);
207
208 m_ok = true;
209
210 ::SetWindowOrgEx((HDC) m_hDC,xorg,yorg, NULL);
211 ::SetWindowExtEx((HDC) m_hDC,xext,yext, NULL);
212
213 // Actual Windows mapping mode, for future reference.
214 m_windowsMappingMode = wxMM_ANISOTROPIC;
215
216 SetMapMode(wxMM_TEXT); // NOTE: does not set HDC mapmode (this is correct)
217 }
218
219 wxMetafileDC::~wxMetafileDC()
220 {
221 m_hDC = 0;
222 }
223
224 void wxMetafileDC::GetTextExtent(const wxString& string, long *x, long *y,
225 long *descent, long *externalLeading, wxFont *theFont, bool WXUNUSED(use16bit)) const
226 {
227 wxFont *fontToUse = theFont;
228 if (!fontToUse)
229 fontToUse = (wxFont*) &m_font;
230
231 HDC dc = GetDC(NULL);
232
233 SIZE sizeRect;
234 TEXTMETRIC tm;
235 GetTextExtentPoint(dc, WXSTRINGCAST string, wxStrlen(WXSTRINGCAST string), &sizeRect);
236 GetTextMetrics(dc, &tm);
237
238 ReleaseDC(NULL, dc);
239
240 if ( x )
241 *x = sizeRect.cx;
242 if ( y )
243 *y = sizeRect.cy;
244 if ( descent )
245 *descent = tm.tmDescent;
246 if ( externalLeading )
247 *externalLeading = tm.tmExternalLeading;
248 }
249
250 wxMetafile *wxMetafileDC::Close()
251 {
252 SelectOldObjects(m_hDC);
253 HANDLE mf = CloseMetaFile((HDC) m_hDC);
254 m_hDC = 0;
255 if (mf)
256 {
257 wxMetafile *wx_mf = new wxMetafile;
258 wx_mf->SetHMETAFILE((WXHANDLE) mf);
259 wx_mf->SetWindowsMappingMode(m_windowsMappingMode);
260 return wx_mf;
261 }
262 return NULL;
263 }
264
265 void wxMetafileDC::SetMapMode(int mode)
266 {
267 m_mappingMode = mode;
268
269 // int pixel_width = 0;
270 // int pixel_height = 0;
271 // int mm_width = 0;
272 // int mm_height = 0;
273
274 float mm2pixelsX = 10.0;
275 float mm2pixelsY = 10.0;
276
277 switch (mode)
278 {
279 case wxMM_TWIPS:
280 {
281 m_logicalScaleX = (float)(twips2mm * mm2pixelsX);
282 m_logicalScaleY = (float)(twips2mm * mm2pixelsY);
283 break;
284 }
285 case wxMM_POINTS:
286 {
287 m_logicalScaleX = (float)(pt2mm * mm2pixelsX);
288 m_logicalScaleY = (float)(pt2mm * mm2pixelsY);
289 break;
290 }
291 case wxMM_METRIC:
292 {
293 m_logicalScaleX = mm2pixelsX;
294 m_logicalScaleY = mm2pixelsY;
295 break;
296 }
297 case wxMM_LOMETRIC:
298 {
299 m_logicalScaleX = (float)(mm2pixelsX/10.0);
300 m_logicalScaleY = (float)(mm2pixelsY/10.0);
301 break;
302 }
303 default:
304 case wxMM_TEXT:
305 {
306 m_logicalScaleX = 1.0;
307 m_logicalScaleY = 1.0;
308 break;
309 }
310 }
311 }
312
313 // ----------------------------------------------------------------------------
314 // wxMakeMetafilePlaceable
315 // ----------------------------------------------------------------------------
316
317 #ifdef __WIN32__
318 struct RECT32
319 {
320 short left;
321 short top;
322 short right;
323 short bottom;
324 };
325
326 struct mfPLACEABLEHEADER {
327 DWORD key;
328 short hmf;
329 RECT32 bbox;
330 WORD inch;
331 DWORD reserved;
332 WORD checksum;
333 };
334 #else
335 struct mfPLACEABLEHEADER {
336 DWORD key;
337 HANDLE hmf;
338 RECT bbox;
339 WORD inch;
340 DWORD reserved;
341 WORD checksum;
342 };
343 #endif
344
345 /*
346 * Pass filename of existing non-placeable metafile, and bounding box.
347 * Adds a placeable metafile header, sets the mapping mode to anisotropic,
348 * and sets the window origin and extent to mimic the wxMM_TEXT mapping mode.
349 *
350 */
351
352 bool wxMakeMetafilePlaceable(const wxString& filename, float scale)
353 {
354 return wxMakeMetafilePlaceable(filename, 0, 0, 0, 0, scale, false);
355 }
356
357 bool wxMakeMetafilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale, bool useOriginAndExtent)
358 {
359 // I'm not sure if this is the correct way of suggesting a scale
360 // to the client application, but it's the only way I can find.
361 int unitsPerInch = (int)(576/scale);
362
363 mfPLACEABLEHEADER header;
364 header.key = 0x9AC6CDD7L;
365 header.hmf = 0;
366 header.bbox.left = (int)(x1);
367 header.bbox.top = (int)(y1);
368 header.bbox.right = (int)(x2);
369 header.bbox.bottom = (int)(y2);
370 header.inch = unitsPerInch;
371 header.reserved = 0;
372
373 // Calculate checksum
374 WORD *p;
375 mfPLACEABLEHEADER *pMFHead = &header;
376 for (p =(WORD *)pMFHead,pMFHead -> checksum = 0;
377 p < (WORD *)&pMFHead ->checksum; ++p)
378 pMFHead ->checksum ^= *p;
379
380 FILE *fd = wxFopen(filename.fn_str(), _T("rb"));
381 if (!fd) return false;
382
383 wxChar tempFileBuf[256];
384 wxGetTempFileName(wxT("mf"), tempFileBuf);
385 FILE *fHandle = wxFopen(wxFNCONV(tempFileBuf), _T("wb"));
386 if (!fHandle)
387 return false;
388 fwrite((void *)&header, sizeof(unsigned char), sizeof(mfPLACEABLEHEADER), fHandle);
389
390 // Calculate origin and extent
391 int originX = x1;
392 int originY = y1;
393 int extentX = x2 - x1;
394 int extentY = (y2 - y1);
395
396 // Read metafile header and write
397 METAHEADER metaHeader;
398 fread((void *)&metaHeader, sizeof(unsigned char), sizeof(metaHeader), fd);
399
400 if (useOriginAndExtent)
401 metaHeader.mtSize += 15;
402 else
403 metaHeader.mtSize += 5;
404
405 fwrite((void *)&metaHeader, sizeof(unsigned char), sizeof(metaHeader), fHandle);
406
407 // Write SetMapMode, SetWindowOrigin and SetWindowExt records
408 char modeBuffer[8];
409 char originBuffer[10];
410 char extentBuffer[10];
411 METARECORD *modeRecord = (METARECORD *)&modeBuffer;
412
413 METARECORD *originRecord = (METARECORD *)&originBuffer;
414 METARECORD *extentRecord = (METARECORD *)&extentBuffer;
415
416 modeRecord->rdSize = 4;
417 modeRecord->rdFunction = META_SETMAPMODE;
418 modeRecord->rdParm[0] = MM_ANISOTROPIC;
419
420 originRecord->rdSize = 5;
421 originRecord->rdFunction = META_SETWINDOWORG;
422 originRecord->rdParm[0] = originY;
423 originRecord->rdParm[1] = originX;
424
425 extentRecord->rdSize = 5;
426 extentRecord->rdFunction = META_SETWINDOWEXT;
427 extentRecord->rdParm[0] = extentY;
428 extentRecord->rdParm[1] = extentX;
429
430 fwrite((void *)modeBuffer, sizeof(char), 8, fHandle);
431
432 if (useOriginAndExtent)
433 {
434 fwrite((void *)originBuffer, sizeof(char), 10, fHandle);
435 fwrite((void *)extentBuffer, sizeof(char), 10, fHandle);
436 }
437
438 int ch = -2;
439 while (ch != EOF)
440 {
441 ch = getc(fd);
442 if (ch != EOF)
443 {
444 putc(ch, fHandle);
445 }
446 }
447 fclose(fHandle);
448 fclose(fd);
449 wxRemoveFile(filename);
450 wxCopyFile(tempFileBuf, filename);
451 wxRemoveFile(tempFileBuf);
452 return true;
453 }
454
455
456 #if wxUSE_DRAG_AND_DROP
457
458 // ----------------------------------------------------------------------------
459 // wxMetafileDataObject
460 // ----------------------------------------------------------------------------
461
462 size_t wxMetafileDataObject::GetDataSize() const
463 {
464 return sizeof(METAFILEPICT);
465 }
466
467 bool wxMetafileDataObject::GetDataHere(void *buf) const
468 {
469 METAFILEPICT *mfpict = (METAFILEPICT *)buf;
470 const wxMetafile& mf = GetMetafile();
471
472 wxCHECK_MSG( mf.GetHMETAFILE(), false, _T("copying invalid metafile") );
473
474 // doesn't seem to work with any other mapping mode...
475 mfpict->mm = MM_ANISOTROPIC; //mf.GetWindowsMappingMode();
476 mfpict->xExt = mf.GetWidth();
477 mfpict->yExt = mf.GetHeight();
478
479 // transform the picture size to HIMETRIC units (0.01mm) - as we don't know
480 // what DC the picture will be rendered to, use the default display one
481 PixelToHIMETRIC(&mfpict->xExt, &mfpict->yExt);
482
483 mfpict->hMF = CopyMetaFile((HMETAFILE)mf.GetHMETAFILE(), NULL);
484
485 return true;
486 }
487
488 bool wxMetafileDataObject::SetData(size_t WXUNUSED(len), const void *buf)
489 {
490 const METAFILEPICT *mfpict = (const METAFILEPICT *)buf;
491
492 wxMetafile mf;
493 mf.SetWindowsMappingMode(mfpict->mm);
494
495 LONG w = mfpict->xExt,
496 h = mfpict->yExt;
497 if ( mfpict->mm == MM_ANISOTROPIC )
498 {
499 // in this case xExt and yExt contain suggested size in HIMETRIC units
500 // (0.01 mm) - transform this to something more reasonable (pixels)
501 HIMETRICToPixel(&w, &h);
502 }
503
504 mf.SetWidth(w);
505 mf.SetHeight(h);
506 mf.SetHMETAFILE((WXHANDLE)mfpict->hMF);
507
508 wxCHECK_MSG( mfpict->hMF, false, _T("pasting invalid metafile") );
509
510 SetMetafile(mf);
511
512 return true;
513 }
514
515 #endif // wxUSE_DRAG_AND_DROP
516
517 #endif // wxUSE_METAFILE
518