EMF  1.0
libemf.h
1 /* -*- c++ -*-
2  * EMF: A library for generating ECMA-234 Enhanced Metafiles
3  * Copyright (C) 2002, 2003 lignum Computing, Inc. <dallenbarnett@users.sourceforge.net>
4  * $Id: libemf.h 73 2015-11-22 14:21:46Z dallenbarnett $
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 #ifndef _LIBEMF_H
22 #define _LIBEMF_H 1
23 
24 #include <cmath>
25 #include <vector>
26 #include <map>
27 #include <functional>
28 #include <algorithm>
29 #include <stdexcept>
30 
31 #include <config.h>
32 #include <libEMF/emf.h>
33 
34 #include <libEMF/wine/w16.h>
35 
36 #ifdef ENABLE_EDITING
37 #include <iconv.h>
38 #include <errno.h>
39 #endif
40 
41 #define EMF_UNUSED(x) (void)x;
42 
43 namespace EMF {
48 #if 1
49  const int XMAX_PIXELS = 1024; /*(INT_MAX)*/
50 #else
51  const int XMAX_PIXELS = 1280; /*(INT_MAX)*/
52 #endif
53 
57 #if 1
58  const int YMAX_PIXELS = 768; /*(INT_MAX)*/
59 #else
60  const int YMAX_PIXELS = 1024; /*(INT_MAX)*/
61 #endif
62 
67  const int XMAX_MM = 320;
73  const int YMAX_MM = 240;
77  const int RESOLUTION = 96;
81  static inline int ROUND_TO_LONG ( int n ) { return ((n+3)/4)*4; }
82 
84 
89  struct WCHARSTR {
90  WCHAR *const string_;
91  const int length_;
92 
97  WCHARSTR ( WCHAR *const string, const int length )
98  : string_( string ), length_( length ) {}
99  };
100 
102 
107  struct CHARSTR {
108  CHAR *const string_;
109  const int length_;
110 
115  CHARSTR ( CHAR *const string, const int length )
116  : string_( string ), length_( length ) {}
117  };
118 
120 
124  struct BYTEARRAY {
125  BYTE *const array_;
126  const int n_;
127 
132  BYTEARRAY ( BYTE *const array, const int n )
133  : array_( array ), n_( n ) {}
134  };
135 
137 
140  struct POINTLARRAY {
141  POINTL *const points_;
142  const DWORD n_;
143 
148  POINTLARRAY ( POINTL *const points, const DWORD n )
149  : points_( points ), n_( n ) {}
150  };
151 
153 
156  struct POINT16ARRAY {
157  POINT16 *const points_;
158  const DWORD n_;
159 
164  POINT16ARRAY ( POINT16 *const points, const DWORD n )
165  : points_( points ), n_( n ) {}
166  };
167 
169 
172  struct INTARRAY {
173  INT *const ints_;
174  const DWORD n_;
175 
180  INTARRAY ( INT *const ints, const DWORD n )
181  : ints_( ints ), n_( n ) {}
182  };
183 
185 
188  struct DWORDARRAY {
189  DWORD *const dwords_;
190  const DWORD n_;
191 
196  DWORDARRAY ( DWORD *const dwords, const DWORD n )
197  : dwords_( dwords ), n_( n ) {}
198  };
199 
201 
204  struct PADDING {
205  static const char padding_[4];
206  const int size_;
207 
211  PADDING ( const int size ) : size_( size ) {}
212  };
213 
215 
222  class DATASTREAM {
223  bool swap_;
224  ::FILE* fp_;
225 
226  static bool bigEndian ( void );
227  public:
233  DATASTREAM ( ::FILE* fp = 0 ) : swap_( bigEndian() ), fp_( fp ) {}
238  void setStream ( ::FILE* fp ) { fp_ = fp; }
243  DATASTREAM& operator<< ( const BYTE& byte )
244  {
245  fwrite( &byte, sizeof(BYTE), 1, fp_ );
246  return *this;
247  }
252  DATASTREAM& operator>> ( BYTE& byte )
253  {
254  fread( &byte, sizeof(BYTE), 1, fp_ );
255  return *this;
256  }
261  DATASTREAM& operator<< ( const WORD& word )
262  {
263  if ( swap_ ) {
264  unsigned char const * p = (unsigned char const*)&word;
265  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
266  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
267  }
268  else
269  fwrite( &word, sizeof(WORD), 1, fp_ );
270  return *this;
271  }
276  DATASTREAM& operator>> ( WORD& word )
277  {
278  if ( swap_ ) {
279  unsigned char* p = (unsigned char*)&word;
280  fread( &p[1], sizeof(unsigned char), 1, fp_ );
281  fread( &p[0], sizeof(unsigned char), 1, fp_ );
282  }
283  else
284  fread( &word, sizeof(WORD), 1, fp_ );
285  return *this;
286  }
291  DATASTREAM& operator<< ( const INT16& word )
292  {
293  if ( swap_ ) {
294  unsigned char const * p = (unsigned char const*)&word;
295  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
296  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
297  }
298  else
299  fwrite( &word, sizeof(INT16), 1, fp_ );
300  return *this;
301  }
306  DATASTREAM& operator>> ( INT16& word )
307  {
308  if ( swap_ ) {
309  unsigned char* p = (unsigned char*)&word;
310  fread( &p[1], sizeof(unsigned char), 1, fp_ );
311  fread( &p[0], sizeof(unsigned char), 1, fp_ );
312  }
313  else
314  fread( &word, sizeof(INT16), 1, fp_ );
315  return *this;
316  }
321  DATASTREAM& operator<< ( const DWORD& dword )
322  {
323  if ( swap_ ) {
324  unsigned char const* p = (unsigned char const*)&dword;
325  fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
326  fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
327  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
328  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
329  }
330  else
331  fwrite( &dword, sizeof(DWORD), 1, fp_ );
332  return *this;
333  }
338  DATASTREAM& operator>> ( DWORD& dword )
339  {
340  if ( swap_ ) {
341  unsigned char* p = (unsigned char*)&dword;
342  fread( &p[3], sizeof(unsigned char), 1, fp_ );
343  fread( &p[2], sizeof(unsigned char), 1, fp_ );
344  fread( &p[1], sizeof(unsigned char), 1, fp_ );
345  fread( &p[0], sizeof(unsigned char), 1, fp_ );
346  }
347  else
348  fread( &dword, sizeof(DWORD), 1, fp_ );
349  return *this;
350  }
351 #if !defined( __LP64__ )
352 
356  DATASTREAM& operator<< ( const LONG& long_ )
357  {
358  if ( swap_ ) {
359  unsigned char const* p = (unsigned char const*)&long_;
360  fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
361  fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
362  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
363  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
364  }
365  else
366  fwrite( &long_, sizeof(LONG), 1, fp_ );
367  return *this;
368  }
373  DATASTREAM& operator>> ( LONG& long_ )
374  {
375  if ( swap_ ) {
376  unsigned char* p = (unsigned char*)&long_;
377  fread( &p[3], sizeof(unsigned char), 1, fp_ );
378  fread( &p[2], sizeof(unsigned char), 1, fp_ );
379  fread( &p[1], sizeof(unsigned char), 1, fp_ );
380  fread( &p[0], sizeof(unsigned char), 1, fp_ );
381  }
382  else
383  fread( &long_, sizeof(LONG), 1, fp_ );
384  return *this;
385  }
386 #endif /* __x86_64__ */
387 
391  DATASTREAM& operator<< ( const INT& int_ )
392  {
393  if ( swap_ ) {
394  unsigned char const* p = (unsigned char const*)&int_;
395  fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
396  fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
397  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
398  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
399  }
400  else
401  fwrite( &int_, sizeof(INT), 1, fp_ );
402  return *this;
403  }
408  DATASTREAM& operator>> ( INT& int_ )
409  {
410  if ( swap_ ) {
411  unsigned char* p = (unsigned char*)&int_;
412  fread( &p[3], sizeof(unsigned char), 1, fp_ );
413  fread( &p[2], sizeof(unsigned char), 1, fp_ );
414  fread( &p[1], sizeof(unsigned char), 1, fp_ );
415  fread( &p[0], sizeof(unsigned char), 1, fp_ );
416  }
417  else
418  fread( &int_, sizeof(INT), 1, fp_ );
419  return *this;
420  }
421 #if !defined(__LP64__)
422 
426  DATASTREAM& operator<< ( const UINT& uint )
427  {
428  if ( swap_ ) {
429  unsigned char const* p = (unsigned char const*)&uint;
430  fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
431  fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
432  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
433  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
434  }
435  else
436  fwrite( &uint, sizeof(UINT), 1, fp_ );
437  return *this;
438  }
443  DATASTREAM& operator>> ( UINT& uint )
444  {
445  if ( swap_ ) {
446  unsigned char* p = (unsigned char*)&uint;
447  fread( &p[3], sizeof(unsigned char), 1, fp_ );
448  fread( &p[2], sizeof(unsigned char), 1, fp_ );
449  fread( &p[1], sizeof(unsigned char), 1, fp_ );
450  fread( &p[0], sizeof(unsigned char), 1, fp_ );
451  }
452  else
453  fread( &uint, sizeof(UINT), 1, fp_ );
454  return *this;
455  }
456 #endif /* !__x86_64__ */
457 
461  DATASTREAM& operator<< ( const FLOAT& float_ )
462  {
463  if ( swap_ ) {
464  unsigned char const* p = (unsigned char const*)&float_;
465  fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
466  fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
467  fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
468  fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
469  }
470  else
471  fwrite( &float_, sizeof(FLOAT), 1, fp_ );
472  return *this;
473  }
478  DATASTREAM& operator>> ( FLOAT& float_ )
479  {
480  if ( swap_ ) {
481  unsigned char* p = (unsigned char*)&float_;
482  fread( &p[3], sizeof(unsigned char), 1, fp_ );
483  fread( &p[2], sizeof(unsigned char), 1, fp_ );
484  fread( &p[1], sizeof(unsigned char), 1, fp_ );
485  fread( &p[0], sizeof(unsigned char), 1, fp_ );
486  }
487  else
488  fread( &float_, sizeof(FLOAT), 1, fp_ );
489  return *this;
490  }
495  DATASTREAM& operator<< ( const PADDING& padding )
496  {
497  if ( padding.size_ != 0 )
498  fwrite( &padding.padding_, sizeof(CHAR), padding.size_, fp_ );
499  return *this;
500  }
505  DATASTREAM& operator<< ( const RECTL& rectl )
506  {
507  *this << rectl.left << rectl.top << rectl.right << rectl.bottom;
508  return *this;
509  }
514  DATASTREAM& operator>> ( RECTL& rectl )
515  {
516  *this >> rectl.left >> rectl.top >> rectl.right >> rectl.bottom;
517  return *this;
518  }
523  DATASTREAM& operator<< ( const SIZEL& sizel )
524  {
525  *this << sizel.cx << sizel.cy;
526  return *this;
527  }
532  DATASTREAM& operator>> ( SIZEL& sizel )
533  {
534  *this >> sizel.cx >> sizel.cy;
535  return *this;
536  }
541  DATASTREAM& operator<< ( const WCHARSTR& wcharstr )
542  {
543  for ( int i = 0; i < wcharstr.length_; i++ )
544  *this << wcharstr.string_[i];
545  return *this;
546  }
551  DATASTREAM& operator>> ( WCHARSTR& wcharstr )
552  {
553  for ( int i = 0; i < wcharstr.length_; i++ )
554  *this >> wcharstr.string_[i];
555  return *this;
556  }
561  DATASTREAM& operator<< ( const CHARSTR& charstr )
562  {
563  fwrite( charstr.string_, sizeof(CHAR), charstr.length_, fp_ );
564  return *this;
565  }
570  DATASTREAM& operator>> ( CHARSTR& charstr )
571  {
572  fread( charstr.string_, sizeof(CHAR), charstr.length_, fp_ );
573  return *this;
574  }
579  DATASTREAM& operator<< ( const ::EMR& emr )
580  {
581  *this << emr.iType << emr.nSize;
582  return *this;
583  }
588  DATASTREAM& operator>> ( ::EMR& emr )
589  {
590  *this >> emr.iType >> emr.nSize;
591  return *this;
592  }
597  DATASTREAM& operator<< ( const POINT& point )
598  {
599  *this << point.x << point.y;
600  return *this;
601  }
606  DATASTREAM& operator>> ( POINT& point )
607  {
608  *this >> point.x >> point.y;
609  return *this;
610  }
615  DATASTREAM& operator<< ( const POINTL& pointl )
616  {
617  *this << pointl.x << pointl.y;
618  return *this;
619  }
624  DATASTREAM& operator>> ( POINTL& pointl )
625  {
626  *this >> pointl.x >> pointl.y;
627  return *this;
628  }
633  DATASTREAM& operator<< ( const POINT16& point )
634  {
635  *this << point.x << point.y;
636  return *this;
637  }
642  DATASTREAM& operator>> ( POINT16& point )
643  {
644  *this >> point.x >> point.y;
645  return *this;
646  }
651  DATASTREAM& operator<< ( const XFORM& xform )
652  {
653  *this << xform.eM11 << xform.eM12 << xform.eM21 << xform.eM22
654  << xform.eDx << xform.eDy;
655  return *this;
656  }
661  DATASTREAM& operator>> ( XFORM& xform )
662  {
663  *this >> xform.eM11 >> xform.eM12 >> xform.eM21 >> xform.eM22
664  >> xform.eDx >> xform.eDy;
665  return *this;
666  }
671  DATASTREAM& operator<< ( const BYTEARRAY& array )
672  {
673  fwrite( array.array_, sizeof(BYTE), array.n_, fp_ );
674  return *this;
675  }
680  DATASTREAM& operator>> ( BYTEARRAY& array )
681  {
682  fread( array.array_, sizeof(BYTE), array.n_, fp_ );
683  return *this;
684  }
689  DATASTREAM& operator<< ( const POINTLARRAY& array )
690  {
691  for ( unsigned int i = 0; i < array.n_; i++ )
692  *this << array.points_[i];
693  return *this;
694  }
699  DATASTREAM& operator>> ( POINTLARRAY& array )
700  {
701  for ( unsigned int i = 0; i < array.n_; i++ )
702  *this >> array.points_[i];
703  return *this;
704  }
709  DATASTREAM& operator<< ( const POINT16ARRAY& array )
710  {
711  for ( unsigned int i = 0; i < array.n_; i++ )
712  *this << array.points_[i];
713  return *this;
714  }
719  DATASTREAM& operator>> ( POINT16ARRAY& array )
720  {
721  for ( unsigned int i = 0; i < array.n_; i++ )
722  *this >> array.points_[i];
723  return *this;
724  }
729  DATASTREAM& operator<< ( const INTARRAY& array )
730  {
731  for ( unsigned int i = 0; i < array.n_; i++ )
732  *this << array.ints_[i];
733  return *this;
734  }
739  DATASTREAM& operator>> ( INTARRAY& array )
740  {
741  for ( unsigned int i = 0; i < array.n_; i++ )
742  *this >> array.ints_[i];
743  return *this;
744  }
749  DATASTREAM& operator<< ( const DWORDARRAY& array )
750  {
751  for ( unsigned int i = 0; i < array.n_; i++ )
752  *this << array.dwords_[i];
753  return *this;
754  }
759  DATASTREAM& operator>> ( DWORDARRAY& array )
760  {
761  for ( unsigned int i = 0; i < array.n_; i++ )
762  *this >> array.dwords_[i];
763  return *this;
764  }
769  DATASTREAM& operator<< ( const ::EMRTEXT& text )
770  {
771  *this << text.ptlReference << text.nChars << text.offString << text.fOptions
772  << text.rcl << text.offDx;
773  return *this;
774  }
779  DATASTREAM& operator>> ( ::EMRTEXT& text )
780  {
781  *this >> text.ptlReference >> text.nChars >> text.offString >> text.fOptions
782  >> text.rcl >> text.offDx;
783  return *this;
784  }
789  DATASTREAM& operator<< ( const LOGPEN& pen )
790  {
791  *this << pen.lopnStyle << pen.lopnWidth << pen.lopnColor;
792  return *this;
793  }
798  DATASTREAM& operator>> ( LOGPEN& pen )
799  {
800  *this >> pen.lopnStyle >> pen.lopnWidth >> pen.lopnColor;
801  return *this;
802  }
807  DATASTREAM& operator<< ( const EXTLOGPEN& pen )
808  {
809  // *** How big is this structure if there are no style entries? ***
810  *this << pen.elpPenStyle << pen.elpWidth << pen.elpBrushStyle << pen.elpColor
811  << pen.elpHatch << pen.elpNumEntries;
812  return *this;
813  }
818  DATASTREAM& operator>> ( EXTLOGPEN& pen )
819  {
820  // *** How big is this structure if there are no style entries? ***
821  *this >> pen.elpPenStyle >> pen.elpWidth >> pen.elpBrushStyle >> pen.elpColor
822  >> pen.elpHatch >> pen.elpNumEntries;
823  return *this;
824  }
829  DATASTREAM& operator<< ( const LOGBRUSH& brush )
830  {
831  *this << brush.lbStyle << brush.lbColor << brush.lbHatch;
832  return *this;
833  }
838  DATASTREAM& operator>> ( LOGBRUSH& brush )
839  {
840  *this >> brush.lbStyle >> brush.lbColor >> brush.lbHatch;
841  return *this;
842  }
847  DATASTREAM& operator<< ( const LOGFONTW& font )
848  {
849  *this << font.lfHeight << font.lfWidth << font.lfEscapement
850  << font.lfOrientation << font.lfWeight << font.lfItalic
851  << font.lfUnderline << font.lfStrikeOut << font.lfCharSet
852  << font.lfOutPrecision << font.lfClipPrecision << font.lfQuality
853  << font.lfPitchAndFamily
854  << WCHARSTR( const_cast<WCHAR*const>(font.lfFaceName), LF_FACESIZE );
855  return *this;
856  }
861  DATASTREAM& operator>> ( LOGFONTW& font )
862  {
863  WCHARSTR wFaceName( font.lfFaceName, LF_FACESIZE );
864 
865  *this >> font.lfHeight >> font.lfWidth >> font.lfEscapement
866  >> font.lfOrientation >> font.lfWeight >> font.lfItalic
867  >> font.lfUnderline >> font.lfStrikeOut >> font.lfCharSet
868  >> font.lfOutPrecision >> font.lfClipPrecision >> font.lfQuality
869  >> font.lfPitchAndFamily
870  >> wFaceName;
871  return *this;
872  }
877  DATASTREAM& operator<< ( const PANOSE& panose )
878  {
879  fwrite( &panose, sizeof(PANOSE), 1, fp_ );
880  return *this;
881  }
886  DATASTREAM& operator>> ( PANOSE& panose )
887  {
888  fread( &panose, sizeof(PANOSE), 1, fp_ );
889  return *this;
890  }
895  DATASTREAM& operator<< ( const EXTLOGFONTW& font )
896  {
897  *this << font.elfLogFont
898  << WCHARSTR( const_cast<WCHAR*const>(font.elfFullName),
899  LF_FULLFACESIZE )
900  << WCHARSTR( const_cast<WCHAR*const>(font.elfStyle), LF_FACESIZE )
901  << font.elfVersion << font.elfStyleSize << font.elfMatch
902  << font.elfReserved
903  << BYTEARRAY( const_cast<BYTE*const>(font.elfVendorId),
904  ELF_VENDOR_SIZE )
905  << font.elfCulture << font.elfPanose;
906  return *this;
907  }
912  DATASTREAM& operator>> ( EXTLOGFONTW& font )
913  {
914  WCHARSTR wFullName( font.elfFullName, LF_FULLFACESIZE );
915  WCHARSTR wStyle( font.elfStyle, LF_FACESIZE );
916  BYTEARRAY bVendorId( font.elfVendorId, ELF_VENDOR_SIZE );
917  *this >> font.elfLogFont
918  >> wFullName >> wStyle
919  >> font.elfVersion >> font.elfStyleSize >> font.elfMatch
920  >> font.elfReserved >> bVendorId
921  >> font.elfCulture >> font.elfPanose;
922  return *this;
923  }
928  DATASTREAM& operator<< ( const LOGPALETTE& palette )
929  {
930  // *** How big is this structure if the palette is empty? ***
931  *this << palette.palVersion << palette.palNumEntries;
932  return *this;
933  }
938  DATASTREAM& operator>> ( LOGPALETTE& palette )
939  {
940  // *** How big is this structure if the palette is empty? ***
941  *this >> palette.palVersion >> palette.palNumEntries;
942  return *this;
943  }
944  private:
955  void fread ( void* ptr, size_t size, size_t nmemb, FILE* stream )
956  {
957  size_t res = ::fread( ptr, size, nmemb, stream );
958  if ( res < nmemb ) {
959  if ( ! feof( stream ) ) {
960  throw std::runtime_error( "error reading EMF stream" );
961  }
962  }
963  }
973  void fwrite ( const void* ptr, size_t size, size_t nmemb, FILE* stream )
974  {
975  size_t res = ::fwrite( ptr, size, nmemb, stream );
976  if ( res < nmemb ) {
977  throw std::runtime_error( "error writing EMF stream" );
978  }
979  }
980  };
981 
982  class METAFILEDEVICECONTEXT;
983 
985 
991  class METARECORD {
992  public:
999  virtual void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const = 0;
1006  virtual bool serialize ( DATASTREAM ds ) = 0;
1012  virtual int size ( void ) const = 0;
1018  virtual ~METARECORD( ) { }
1019 #ifdef ENABLE_EDITING
1020 
1024  virtual void edit ( void ) const {}
1025 #endif
1026  };
1027 
1028 #ifdef ENABLE_EDITING
1029  /* Miscellaneous editing routines */
1030  inline void edit_rectl ( const char* tag, const RECTL& rectl )
1031  {
1032 #if defined(__LP64__)
1033  const char* FMT = "\t%s\t: (%d, %d) - (%d, %d)\n";
1034 #else
1035  const char* FMT = "\t%s\t: (%ld, %ld) - (%ld, %ld)\n";
1036 #endif /* __x86_64__ */
1037  printf( FMT, tag, rectl.left, rectl.top, rectl.right, rectl.bottom );
1038  }
1039 
1040  inline void edit_xform ( const char* tag, const XFORM& xform )
1041  {
1042  printf( "\t%s.eM11\t: %f\n", tag, xform.eM11 );
1043  printf( "\t%s.eM12\t: %f\n", tag, xform.eM12 );
1044  printf( "\t%s.eM21\t: %f\n", tag, xform.eM21 );
1045  printf( "\t%s.eM22\t: %f\n", tag, xform.eM22 );
1046  printf( "\t%s.eDx\t: %f\n", tag, xform.eDx );
1047  printf( "\t%s.eDy\t: %f\n", tag, xform.eDy );
1048  }
1049 
1050  inline void edit_color ( const char* tag, const COLORREF& color )
1051  {
1052 #if defined(__LP64__)
1053  const char* FMT = "\t%s\t: R(0x%02x) G(0x%02x) B(0x%02x)\n";
1054 #else
1055  const char* FMT = "\t%s\t: R(0x%02lx) G(0x%02lx) B(0x%02lx)\n";
1056 #endif /* __x86_64__ */
1057  printf( FMT, tag,
1058  GetRValue( color ), GetGValue( color ), GetBValue( color ) );
1059  }
1060 
1061  inline void edit_sizel ( const char* tag, const SIZEL& size )
1062  {
1063 #if defined(__LP64__)
1064  const char* FMT = "\t%s\t: (%d, %d)\n";
1065 #else
1066  const char* FMT = "\t%s\t: (%ld, %ld)\n";
1067 #endif /* __x86_64__ */
1068  printf( FMT, tag, size.cx, size.cy );
1069  }
1070 
1071  inline void edit_pointl ( const char* tag, const POINTL& point )
1072  {
1073 #if defined(__LP64__)
1074  const char* FMT = "\t%s\t: (%d, %d)\n";
1075 #else
1076  const char* FMT = "\t%s\t: (%ld, %ld)\n";
1077 #endif /* __x86_64__ */
1078  printf( FMT, tag, point.x, point.y );
1079  }
1080 
1081  inline void edit_pointlarray ( const char* tag, const DWORD cptl,
1082  const POINTL* points )
1083  {
1084 #if defined(__LP64__)
1085  const char* FMT0 = "\tcptl%s\t: %d\n";
1086  const char* FMT1 = "%d, %d\n";
1087  const char* FMT2 = "\t\t%s %d, %d\n";
1088 #else
1089  const char* FMT0 = "\tcptl%s\t: %ld\n";
1090  const char* FMT1 = "%ld, %ld\n";
1091  const char* FMT2 = "\t\t%s %ld, %ld\n";
1092 #endif /* __x86_64__ */
1093  printf( FMT0, tag, cptl );
1094  printf( "\taptl%s\t: ", tag );
1095  if ( cptl > 0 )
1096  printf( FMT1, points[0].x, points[0].y );
1097  else
1098  puts( "" );
1099  for ( DWORD i = 1; i < cptl; i++ )
1100  printf( FMT2, tag, points[i].x, points[i].y );
1101  }
1102 
1103  inline void edit_point16array ( const char* tag, const unsigned int cpts,
1104  const POINT16* points )
1105  {
1106  printf( "\tcpts%s\t: %d\n", tag, cpts );
1107  printf( "\tapts%s\t: ", tag );
1108  if ( cpts > 0 )
1109  printf( "%d, %d\n", points[0].x, points[0].y );
1110  else
1111  puts( "" );
1112  for ( unsigned int i = 1; i < cpts; i++ )
1113  printf( "\t\t%s %d, %d\n", tag, points[i].x, points[i].y );
1114  }
1115 
1116  inline void edit_pen_style ( const char* tag, DWORD style )
1117  {
1118  printf( "\t%s\t: ", tag );
1119  switch ( style & PS_STYLE_MASK ) {
1120  case PS_SOLID: printf( "PS_SOLID" ); break;
1121  case PS_DASH: printf( "PS_DASH" ); break;
1122  case PS_DOT: printf( "PS_DOT" ); break;
1123  case PS_DASHDOT: printf( "PS_DASHDOT" ); break;
1124  case PS_DASHDOTDOT: printf( "PS_DASHDOTDOT" ); break;
1125  case PS_NULL: printf( "PS_NULL" ); break;
1126  case PS_INSIDEFRAME: printf( "PS_INSIDEFRAME" ); break;
1127  case PS_USERSTYLE: printf( "PS_USERSTYLE" ); break;
1128  case PS_ALTERNATE: printf( "PS_ALTERNATE" ); break;
1129  }
1130  switch ( style & PS_ENDCAP_MASK ) {
1131  case PS_ENDCAP_ROUND: printf( " | PS_ENDCAP_ROUND" ); break;
1132  case PS_ENDCAP_SQUARE: printf( " | PS_ENDCAP_SQUARE" ); break;
1133  case PS_ENDCAP_FLAT: printf( " | PS_ENDCAP_FLAT" ); break;
1134  }
1135  switch ( style & PS_JOIN_MASK ) {
1136  case PS_JOIN_ROUND: printf( " | PS_JOIN_ROUND" ); break;
1137  case PS_JOIN_BEVEL: printf( " | PS_JOIN_BEVEL" ); break;
1138  case PS_JOIN_MITER: printf( " | PS_JOIN_MITER" ); break;
1139  }
1140  switch ( style & PS_TYPE_MASK ) {
1141  case PS_COSMETIC: printf( " | PS_COSMETIC" ); break;
1142  case PS_GEOMETRIC: printf( " | PS_GEOMETRIC" ); break;
1143  }
1144  printf( "\n" );
1145  }
1146 
1147  inline void edit_brush_style ( const char* tag, DWORD style )
1148  {
1149 #if defined(__LP64__)
1150  const char* FMT = "unknown(%d)";
1151 #else
1152  const char* FMT = "unknown(%ld)";
1153 #endif /* __x86_64__ */
1154  printf( "\t%s\t: ", tag );
1155  switch ( style ) {
1156  case BS_SOLID: printf( "BS_SOLID" ); break;
1157  case BS_NULL: printf( "BS_NULL" ); break;
1158  case BS_HATCHED: printf( "BS_HATCHED" ); break;
1159  case BS_PATTERN: printf( "BS_PATTERN" ); break;
1160  case BS_INDEXED: printf( "BS_INDEXED" ); break;
1161  case BS_DIBPATTERN: printf( "BS_DIBPATTERN" ); break;
1162  case BS_DIBPATTERNPT: printf( "BS_DIBPATTERNPT" ); break;
1163  case BS_PATTERN8X8: printf( "BS_PATTERN8X8" ); break;
1164  case BS_DIBPATTERN8X8: printf( "BS_DIBPATTERN8X8" ); break;
1165  case BS_MONOPATTERN: printf( "BS_DIBPATTERN8X8" ); break;
1166  default: printf( FMT, style );
1167  }
1168  printf( "\n" );
1169  }
1170 
1171  inline void edit_brush_hatch ( const char* tag, DWORD hatch )
1172  {
1173 #if defined(__LP64__)
1174  const char* FMT = "unknown(%d)";
1175 #else
1176  const char* FMT = "unknown(%ld)";
1177 #endif /* __x86_64__ */
1178  printf( "\t%s\t: ", tag );
1179  switch ( hatch ) {
1180  case HS_HORIZONTAL: printf( "HS_HORIZONTAL" ); break;
1181  case HS_VERTICAL: printf( "HS_VERTICAL" ); break;
1182  case HS_FDIAGONAL: printf( "HS_FDIAGONAL" ); break;
1183  case HS_BDIAGONAL: printf( "HS_BDIAGONAL" ); break;
1184  case HS_CROSS: printf( "HS_CROSS" ); break;
1185  case HS_DIAGCROSS: printf( "HS_DIAGCROSS" ); break;
1186  default: printf( FMT, hatch );
1187  }
1188  printf( "\n" );
1189  }
1190 #endif
1191 
1198  enum OBJECTTYPE { O_METAFILEDEVICECONTEXT = OBJ_METADC,
1199  O_FONT = OBJ_FONT,
1200  O_PEN = OBJ_PEN,
1201  O_EXTPEN = OBJ_EXTPEN,
1202  O_BRUSH = OBJ_BRUSH,
1203  O_PALETTE = OBJ_PAL };
1204 #if 0
1205 
1208  static char* typStr ( OBJECTTYPE type )
1209  {
1210  switch (type) {
1211  case O_METAFILEDEVICECONTEXT:
1212  return "metafile device context";
1213  case O_FONT:
1214  return "font";
1215  case O_PEN:
1216  return "pen";
1217  case O_EXTPEN:
1218  return "extended pen";
1219  case O_BRUSH:
1220  return "brush";
1221  case O_PALETTE:
1222  return "palette";
1223  }
1224  return "unknown object";
1225  }
1226 #endif
1227 
1233  class OBJECT {
1234  public:
1235  HGDIOBJ handle;
1236  virtual ~OBJECT () {}
1242  OBJECT ( void ) : handle( 0 ) {}
1246  virtual OBJECTTYPE getType ( void ) const = 0;
1247  };
1248 
1250 
1255  class GRAPHICSOBJECT : public OBJECT {
1256  public:
1258  virtual ~GRAPHICSOBJECT () {}
1263  std::map< HDC, HGDIOBJ > contexts;
1270  virtual METARECORD* newEMR ( HDC dc, HGDIOBJ handle ) = 0;
1271  };
1272 
1273  typedef METARECORD*(*METARECORDCTOR)(DATASTREAM&);
1274 
1282  std::vector<OBJECT*> objects;
1283 
1290  std::map< DWORD, METARECORDCTOR > new_records;
1291 
1292  public:
1293  GLOBALOBJECTS ( void );
1294  ~GLOBALOBJECTS ( void );
1295  HGDIOBJ add ( OBJECT* object );
1296  OBJECT* find ( const HGDIOBJ handle );
1297  void remove ( const OBJECT* object );
1298 
1302  std::vector<EMF::OBJECT*>::const_iterator begin ( void ) const
1303  { return objects.begin(); }
1307  std::vector<EMF::OBJECT*>::const_iterator end ( void ) const
1308  { return objects.end(); }
1309 
1310  METARECORDCTOR newRecord ( DWORD iType ) const;
1311 
1313  static EMF::METARECORD* new_eof ( DATASTREAM& ds );
1315  static EMF::METARECORD* new_setviewportorgex ( DATASTREAM& ds );
1317  static EMF::METARECORD* new_setwindoworgex ( DATASTREAM& ds );
1319  static EMF::METARECORD* new_setviewportextex ( DATASTREAM& ds );
1321  static EMF::METARECORD* new_setwindowextex ( DATASTREAM& ds );
1323  static EMF::METARECORD* new_scaleviewportextex ( DATASTREAM& ds );
1325  static EMF::METARECORD* new_scalewindowextex ( DATASTREAM& ds );
1327  static EMF::METARECORD* new_modifyworldtransform ( DATASTREAM& ds );
1329  static EMF::METARECORD* new_setworldtransform ( DATASTREAM& ds );
1331  static EMF::METARECORD* new_settextalign ( DATASTREAM& ds );
1333  static EMF::METARECORD* new_settextcolor ( DATASTREAM& ds );
1335  static EMF::METARECORD* new_setbkcolor ( DATASTREAM& ds );
1337  static EMF::METARECORD* new_setbkmode ( DATASTREAM& ds );
1339  static EMF::METARECORD* new_setpolyfillmode ( DATASTREAM& ds );
1341  static EMF::METARECORD* new_setmapmode ( DATASTREAM& ds );
1343  static EMF::METARECORD* new_selectobject ( DATASTREAM& ds );
1345  static EMF::METARECORD* new_deleteobject ( DATASTREAM& ds );
1347  static EMF::METARECORD* new_movetoex ( DATASTREAM& ds );
1349  static EMF::METARECORD* new_lineto ( DATASTREAM& ds );
1351  static EMF::METARECORD* new_arc ( DATASTREAM& ds );
1353  static EMF::METARECORD* new_arcto ( DATASTREAM& ds );
1355  static EMF::METARECORD* new_rectangle ( DATASTREAM& ds );
1357  static EMF::METARECORD* new_ellipse ( DATASTREAM& ds );
1359  static EMF::METARECORD* new_polyline ( DATASTREAM& ds );
1361  static EMF::METARECORD* new_polyline16 ( DATASTREAM& ds );
1363  static EMF::METARECORD* new_polygon ( DATASTREAM& ds );
1365  static EMF::METARECORD* new_polygon16 ( DATASTREAM& ds );
1367  static EMF::METARECORD* new_polypolygon ( DATASTREAM& ds );
1369  static EMF::METARECORD* new_polypolygon16 ( DATASTREAM& ds );
1371  static EMF::METARECORD* new_polybezier ( DATASTREAM& ds );
1373  static EMF::METARECORD* new_polybezier16 ( DATASTREAM& ds );
1375  static EMF::METARECORD* new_polybezierto ( DATASTREAM& ds );
1377  static EMF::METARECORD* new_polybezierto16 ( DATASTREAM& ds );
1379  static EMF::METARECORD* new_polylineto ( DATASTREAM& ds );
1381  static EMF::METARECORD* new_polylineto16 ( DATASTREAM& ds );
1383  static EMF::METARECORD* new_exttextouta ( DATASTREAM& ds );
1385  static EMF::METARECORD* new_exttextoutw ( DATASTREAM& ds );
1387  static EMF::METARECORD* new_setpixelv ( DATASTREAM& ds );
1389  static EMF::METARECORD* new_createpen ( DATASTREAM& ds );
1391  static EMF::METARECORD* new_extcreatepen ( DATASTREAM& ds );
1393  static EMF::METARECORD* new_createbrushindirect ( DATASTREAM& ds );
1395  static EMF::METARECORD* new_extcreatefontindirectw ( DATASTREAM& ds );
1397  static EMF::METARECORD* new_fillpath ( DATASTREAM& ds );
1399  static EMF::METARECORD* new_strokepath ( DATASTREAM& ds );
1401  static EMF::METARECORD* new_strokeandfillpath ( DATASTREAM& ds );
1403  static EMF::METARECORD* new_beginpath ( DATASTREAM& ds );
1405  static EMF::METARECORD* new_endpath ( DATASTREAM& ds );
1407  static EMF::METARECORD* new_closefigure ( DATASTREAM& ds );
1409  static EMF::METARECORD* new_savedc ( DATASTREAM& ds );
1411  static EMF::METARECORD* new_restoredc ( DATASTREAM& ds );
1413  static EMF::METARECORD* new_setmetargn ( DATASTREAM& ds );
1415  static EMF::METARECORD* new_setmiterlimit ( DATASTREAM& ds );
1416  };
1417 
1418  extern GLOBALOBJECTS globalObjects;
1419 
1421 
1427  class ENHMETAHEADER : public METARECORD, public ::ENHMETAHEADER {
1428 
1429  LPWSTR description_w;
1430  int description_size;
1431 
1432  public:
1439  ENHMETAHEADER ( LPCWSTR description = 0 )
1440  : description_w( 0 ), description_size( 0 )
1441  {
1442  iType = EMR_HEADER;
1443  nSize = sizeof( ::ENHMETAHEADER );
1444 
1445  // Compute the bounds
1446  RECTL default_bounds = { 0, 0, 0, 0 };
1447  rclBounds = default_bounds;
1448  RECTL default_frame = { 0, 0, 0, 0 };
1449  rclFrame = default_frame;
1450  dSignature = ENHMETA_SIGNATURE;
1451  nVersion = 0x10000;
1452  nBytes = nSize;
1453  nRecords = 1;
1454  nHandles = 0;
1455  sReserved = 0;
1456  nDescription = 0;
1457  offDescription = 0;
1458  nPalEntries = 0;
1459  szlDevice.cx = XMAX_PIXELS;
1460  szlDevice.cy = YMAX_PIXELS;
1461  szlMillimeters.cx = XMAX_MM;
1462  szlMillimeters.cy = YMAX_MM;
1463  //
1464  cbPixelFormat = 0;
1465  offPixelFormat = 0;
1466  bOpenGL = FALSE;
1467  //
1468 #if 1
1469  szlMicrometers.cx = 1000 * szlMillimeters.cx;
1470  szlMicrometers.cy = 1000 * szlMillimeters.cy;
1471 #endif
1472  if ( description ) {
1473  // Count the number of characters in the description
1474  int description_count = 0, nulls = 0;
1475  LPCWSTR description_p = description;
1476  while ( nulls < 3 ) {
1477  description_count++;
1478  if ( (*description_p++) == 0 ) nulls++;
1479  }
1480 
1481  // Make sure that the TOTAL record length will be a multiple of 4
1482 
1483  int record_size = ROUND_TO_LONG( sizeof( ::ENHMETAHEADER ) +
1484  sizeof( WCHAR ) * description_count );
1485  description_size =
1486  (record_size - sizeof( ::ENHMETAHEADER )) / sizeof( WCHAR );
1487 
1488  description_w = new WCHAR[ description_size ];
1489 
1490  memset( description_w, 0, sizeof(WCHAR) * description_size );
1491 
1492  for ( int i=0; i<description_count; i++ )
1493  description_w[i] = *description++;
1494 
1495  nSize = nBytes = record_size;
1496  nDescription = description_count;
1497  offDescription = sizeof( ::ENHMETAHEADER );
1498  }
1499  }
1500 
1505  {
1506  if ( description_w ) delete[] description_w;
1507  }
1512  bool serialize ( DATASTREAM ds )
1513  {
1514  ds << iType << nSize
1515  << rclBounds << rclFrame
1516  << dSignature << nVersion << nBytes << nRecords << nHandles << sReserved
1517  << nDescription << offDescription << nPalEntries
1518  << szlDevice << szlMillimeters
1519  << cbPixelFormat << offPixelFormat << bOpenGL
1520 #if 1
1521  << szlMicrometers
1522 #endif
1523  << WCHARSTR( description_w, description_size );
1524  return true;
1525  }
1530  {
1531  ds >> iType >> nSize
1532  >> rclBounds >> rclFrame
1533  >> dSignature >> nVersion >> nBytes >> nRecords >> nHandles >> sReserved
1534  >> nDescription >> offDescription >> nPalEntries
1535  >> szlDevice >> szlMillimeters;
1536 
1537  // Some elements of the metafile header were added at later dates
1538 
1539 #define OffsetOf( a, b ) ((unsigned int)(((char*)&(((::ENHMETAHEADER*)a)->b)) - \
1540 (char*)((::ENHMETAHEADER*)a)))
1541 #if 1
1542  if ( OffsetOf( this, szlMicrometers ) <= offDescription )
1543  ds >> cbPixelFormat >> offPixelFormat >> bOpenGL;
1544 #else
1545  if ( sizeof(::ENHMETAHEADER) <= offDescription )
1546  ds >> cbPixelFormat >> offPixelFormat >> bOpenGL;
1547 #endif
1548 #undef OffsetOf
1549 #if 1
1550  if ( sizeof(::ENHMETAHEADER) <= offDescription )
1551  ds >> szlMicrometers;
1552 #endif
1553  // Should now probably check that the offset is correct...
1554 
1555  description_size = ( nSize - offDescription ) / sizeof(WCHAR);
1556  description_w = new WCHAR[ description_size ];
1557 
1558  WCHARSTR description( description_w, description_size );
1559 
1560  ds >> description;
1561 
1562  return true;
1563  }
1567  int size ( void ) const { return nSize; }
1573  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
1574  {
1575  // Actually handled by the destination device context.
1576  EMF_UNUSED(source);
1577  EMF_UNUSED(dc);
1578  }
1579 #ifdef ENABLE_EDITING
1580 
1583  void edit ( void ) const
1584  {
1585 #if defined(__LP64__)
1586  const char* FMT0 = "\tiType\t\t\t: %d\n";
1587  const char* FMT1 = "\tnSize\t\t\t: %d\n";
1588  const char* FMT2 = "\tnBytes\t\t\t: %d\n";
1589  const char* FMT3 = "\tnRecords\t\t: %d\n";
1590  const char* FMT4 = "\tnDescription\t\t: %d\n";
1591  const char* FMT5 = "\toffDescription\t\t: %d\n";
1592  const char* FMT6 = "\tnPalEntries\t\t: %d\n";
1593  const char* FMT7 = "\tcbPixelFormat\t\t: %d\n";
1594  const char* FMT8 = "\toffPixelFormat\t\t: %d\n";
1595  const char* FMT9 = "\tbOpenGL\t\t\t: %d\n";
1596 #else
1597  const char* FMT0 = "\tiType\t\t\t: %ld\n";
1598  const char* FMT1 = "\tnSize\t\t\t: %ld\n";
1599  const char* FMT2 = "\tnBytes\t\t\t: %ld\n";
1600  const char* FMT3 = "\tnRecords\t\t: %ld\n";
1601  const char* FMT4 = "\tnDescription\t\t: %ld\n";
1602  const char* FMT5 = "\toffDescription\t\t: %ld\n";
1603  const char* FMT6 = "\tnPalEntries\t\t: %ld\n";
1604  const char* FMT7 = "\tcbPixelFormat\t\t: %ld\n";
1605  const char* FMT8 = "\toffPixelFormat\t\t: %ld\n";
1606  const char* FMT9 = "\tbOpenGL\t\t\t: %ld\n";
1607 #endif
1608  printf( "*HEADER*\n" );
1609  printf( FMT0, iType );
1610  printf( FMT1, nSize );
1611  edit_rectl( "rclBounds\t", rclBounds );
1612  edit_rectl( "rclFrame\t", rclFrame );
1613  printf( "\tdSignature\t\t: %.4s\n", (const char*)&dSignature );
1614  printf( "\tnVersion\t\t: 0x%x\n", (unsigned int)nVersion );
1615  printf( FMT2, nBytes );
1616  printf( FMT3, nRecords );
1617  printf( "\tnHandles\t\t: %d\n", nHandles );
1618  printf( FMT4, nDescription );
1619  printf( FMT5, offDescription );
1620  printf( FMT6, nPalEntries );
1621  edit_sizel( "szlDevice\t", szlDevice );
1622  edit_sizel( "szlMillimeters\t", szlMillimeters );
1623 
1624  /* Make a crude guess as to the age of this file */
1625 #define OffsetOf( a, b ) ((unsigned int)(((const char*)&(((const ::ENHMETAHEADER*)a)->b)) - \
1626 (const char*)((const ::ENHMETAHEADER*)a)))
1627 
1628  if ( OffsetOf( this, cbPixelFormat ) <= offDescription ) {
1629  printf( FMT7, cbPixelFormat );
1630  printf( FMT8, offPixelFormat );
1631  printf( FMT9, bOpenGL );
1632 #if 1
1633  if ( sizeof(::ENHMETAHEADER) <= offDescription ) {
1634  edit_sizel( "szlMicrometers\t", szlMicrometers );
1635  }
1636 #endif
1637  }
1638 
1639 #undef OffsetOf
1640 
1641  if ( nDescription != 0 ) {
1642 
1643  wchar_t last_w = 0;
1644  WCHAR* description = description_w;
1645 
1646  printf( "\tDescription:" );
1647 
1648  for ( DWORD i = 0; i < nDescription; i++ ) {
1649 
1650  wchar_t w = *description++; /* This is not true, really. UNICODE is not
1651  * glibc's wide character representation */
1652 
1653  if ( w != 0 ) {
1654  if ( last_w == 0 ) printf( "\n\t\t" );
1655  putchar( w );
1656  }
1657 
1658  last_w = w;
1659  }
1660  printf( "\n" );
1661  }
1662  }
1663 #endif /* ENABLE_EDITING */
1664  };
1665 
1667 
1672  class EMREOF : public METARECORD, ::EMREOF {
1673  public:
1677  EMREOF ( void )
1678  {
1679  emr.iType = EMR_EOF;
1680  emr.nSize = sizeof( ::EMREOF );
1681  nPalEntries = 0;
1682  offPalEntries = 0;
1683  nSizeLast = 0;
1684  }
1685 
1691  {
1692  ds >> emr >> nPalEntries >> offPalEntries >> nSizeLast;
1693  }
1694 
1698  bool serialize ( DATASTREAM ds )
1699  {
1700  ds << emr << nPalEntries << offPalEntries << nSizeLast;
1701  return true;
1702  }
1706  int size ( void ) const { return emr.nSize; }
1712  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
1713  {
1714  // Actually handled by the destination device context.
1715  EMF_UNUSED(source);
1716  EMF_UNUSED(dc);
1717  }
1718 #ifdef ENABLE_EDITING
1719 
1722  void edit ( void ) const
1723  {
1724  printf( "*EOF*\n" );
1725  }
1726 #endif /* ENABLE_EDITING */
1727  };
1728 
1730 
1736  public:
1741  EMRSETVIEWPORTORGEX ( INT x, INT y )
1742  {
1743  emr.iType = EMR_SETVIEWPORTORGEX;
1744  emr.nSize = sizeof( ::EMRSETVIEWPORTORGEX );
1745  ptlOrigin.x = x;
1746  ptlOrigin.y = y;
1747  }
1753  {
1754  ds >> emr >> ptlOrigin;
1755  }
1759  bool serialize ( DATASTREAM ds )
1760  {
1761  ds << emr << ptlOrigin;
1762  return true;
1763  }
1767  int size ( void ) const { return emr.nSize; }
1773  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
1774  {
1775  EMF_UNUSED(source);
1776  SetViewportOrgEx( dc, ptlOrigin.x, ptlOrigin.y, 0 );
1777  }
1778 #ifdef ENABLE_EDITING
1779 
1782  void edit ( void ) const
1783  {
1784  printf( "*SETVIEWPORTORGEX*\n" );
1785  edit_pointl( "ptlOrigin", ptlOrigin );
1786  }
1787 #endif /* ENABLE_EDITING */
1788  };
1789 
1791 
1799  public:
1804  EMRSETWINDOWORGEX ( INT x, INT y )
1805  {
1806  emr.iType = EMR_SETWINDOWORGEX;
1807  emr.nSize = sizeof( ::EMRSETWINDOWORGEX );
1808  ptlOrigin.x = x;
1809  ptlOrigin.y = y;
1810  }
1816  {
1817  ds >> emr >> ptlOrigin;
1818  }
1822  bool serialize ( DATASTREAM ds )
1823  {
1824  ds << emr << ptlOrigin;
1825  return true;
1826  }
1830  int size ( void ) const { return emr.nSize; }
1836  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
1837  {
1838  EMF_UNUSED(source);
1839  SetWindowOrgEx( dc, ptlOrigin.x, ptlOrigin.y, 0 );
1840  }
1841 #ifdef ENABLE_EDITING
1842 
1845  void edit ( void ) const
1846  {
1847  printf( "*SETWINDOWORGEX*\n" );
1848  edit_pointl( "ptlOrigin", ptlOrigin );
1849  }
1850 #endif /* ENABLE_EDITING */
1851  };
1852 
1854 
1860  public:
1865  EMRSETVIEWPORTEXTEX ( INT cx, INT cy )
1866  {
1867  emr.iType = EMR_SETVIEWPORTEXTEX;
1868  emr.nSize = sizeof( ::EMRSETVIEWPORTEXTEX );
1869  szlExtent.cx = cx;
1870  szlExtent.cy = cy;
1871  }
1877  {
1878  ds >> emr >> szlExtent;
1879  }
1883  bool serialize ( DATASTREAM ds )
1884  {
1885  ds << emr << szlExtent;
1886  return true;
1887  }
1891  int size ( void ) const { return emr.nSize; }
1897  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
1898  {
1899  EMF_UNUSED(source);
1900  SetViewportExtEx( dc, szlExtent.cx, szlExtent.cy, 0 );
1901  }
1902 #ifdef ENABLE_EDITING
1903 
1906  void edit ( void ) const
1907  {
1908  printf( "*SETVIEWPORTEXTEX*\n" );
1909  edit_sizel( "szlExtent", szlExtent );
1910  }
1911 #endif /* ENABLE_EDITING */
1912  };
1913 
1915 
1921  public:
1928  EMRSCALEVIEWPORTEXTEX ( LONG x_num, LONG x_den, LONG y_num, LONG y_den )
1929  {
1930  emr.iType = EMR_SCALEVIEWPORTEXTEX;
1931  emr.nSize = sizeof( ::EMRSCALEVIEWPORTEXTEX );
1932  xNum = x_num;
1933  xDenom = x_den;
1934  yNum = y_num;
1935  yDenom = y_den;
1936  }
1942  {
1943  ds >> emr >> xNum >> xDenom >> yNum >> yDenom;
1944  }
1948  bool serialize ( DATASTREAM ds )
1949  {
1950  ds << emr << xNum << xDenom << yNum << yDenom;
1951  return true;
1952  }
1956  int size ( void ) const { return emr.nSize; }
1962  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
1963  {
1964  EMF_UNUSED(source);
1965  ScaleViewportExtEx( dc, xNum, xDenom, yNum, yDenom, 0 );
1966  }
1967 #ifdef ENABLE_EDITING
1968 
1971  void edit ( void ) const
1972  {
1973 #if defined(__LP64__)
1974  const char* FMT0 = "\txNum\t: %d\n";
1975  const char* FMT1 = "\txDenom\t: %d\n";
1976  const char* FMT2 = "\tyNum\t: %d\n";
1977  const char* FMT3 = "\tyDenom\t: %d\n";
1978 #else
1979  const char* FMT0 = "\txNum\t: %ld\n";
1980  const char* FMT1 = "\txDenom\t: %ld\n";
1981  const char* FMT2 = "\tyNum\t: %ld\n";
1982  const char* FMT3 = "\tyDenom\t: %ld\n";
1983 #endif
1984  printf( "*SCALEVIEWPORTEXTEX*\n" );
1985  printf( FMT0, xNum );
1986  printf( FMT1, xDenom );
1987  printf( FMT2, yNum );
1988  printf( FMT3, yDenom );
1989  }
1990 #endif /* ENABLE_EDITING */
1991  };
1992 
1994 
2000  public:
2005  EMRSETWINDOWEXTEX ( INT cx, INT cy )
2006  {
2007  emr.iType = EMR_SETWINDOWEXTEX;
2008  emr.nSize = sizeof( ::EMRSETWINDOWEXTEX );
2009  szlExtent.cx = cx;
2010  szlExtent.cy = cy;
2011  }
2017  {
2018  ds >> emr >> szlExtent;
2019  }
2023  bool serialize ( DATASTREAM ds )
2024  {
2025  ds << emr << szlExtent;
2026  return true;
2027  }
2031  int size ( void ) const { return emr.nSize; }
2037  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2038  {
2039  EMF_UNUSED(source);
2040  SetWindowExtEx( dc, szlExtent.cx, szlExtent.cy, 0 );
2041  }
2042 #ifdef ENABLE_EDITING
2043 
2046  void edit ( void ) const
2047  {
2048  printf( "*SETWINDOWEXTEX*\n" );
2049  edit_sizel( "szlExtent", szlExtent );
2050  }
2051 #endif /* ENABLE_EDITING */
2052  };
2053 
2055 
2061  public:
2068  EMRSCALEWINDOWEXTEX ( LONG x_num, LONG x_den, LONG y_num, LONG y_den )
2069  {
2070  emr.iType = EMR_SCALEWINDOWEXTEX;
2071  emr.nSize = sizeof( ::EMRSCALEWINDOWEXTEX );
2072  xNum = x_num;
2073  xDenom = x_den;
2074  yNum = y_num;
2075  yDenom = y_den;
2076  }
2082  {
2083  ds >> emr >> xNum >> xDenom >> yNum >> yDenom;
2084  }
2088  bool serialize ( DATASTREAM ds )
2089  {
2090  ds << emr << xNum << xDenom << yNum << yDenom;
2091  return true;
2092  }
2096  int size ( void ) const { return emr.nSize; }
2102  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2103  {
2104  EMF_UNUSED(source);
2105  ScaleWindowExtEx( dc, xNum, xDenom, yNum, yDenom, 0 );
2106  }
2107 #ifdef ENABLE_EDITING
2108 
2111  void edit ( void ) const
2112  {
2113 #if defined(__LP64__)
2114  const char* FMT0 = "\txNum\t: %d\n";
2115  const char* FMT1 = "\txDenom\t: %d\n";
2116  const char* FMT2 = "\tyNum\t: %d\n";
2117  const char* FMT3 = "\tyDenom\t: %d\n";
2118 #else
2119  const char* FMT0 = "\txNum\t: %ld\n";
2120  const char* FMT1 = "\txDenom\t: %ld\n";
2121  const char* FMT2 = "\tyNum\t: %ld\n";
2122  const char* FMT3 = "\tyDenom\t: %ld\n";
2123 #endif
2124  printf( "*SCALEWINDOWEXTEX*\n" );
2125  printf( FMT0, xNum );
2126  printf( FMT1, xDenom );
2127  printf( FMT2, yNum );
2128  printf( FMT3, yDenom );
2129  }
2130 #endif /* ENABLE_EDITING */
2131  };
2132 
2134 
2141  public:
2147  EMRMODIFYWORLDTRANSFORM ( const XFORM* transform, DWORD mode )
2148  {
2149  emr.iType = EMR_MODIFYWORLDTRANSFORM;
2150  emr.nSize = sizeof( ::EMRMODIFYWORLDTRANSFORM );
2151  xform = *transform;
2152  iMode = mode;
2153  }
2159  {
2160  ds >> emr >> xform >> iMode;
2161  }
2165  bool serialize ( DATASTREAM ds )
2166  {
2167  ds << emr << xform << iMode;
2168  return true;
2169  }
2173  int size ( void ) const { return emr.nSize; }
2179  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2180  {
2181  EMF_UNUSED(source);
2182  ModifyWorldTransform( dc, &xform, iMode );
2183  }
2184 #ifdef ENABLE_EDITING
2185 
2188  void edit ( void ) const
2189  {
2190 #if defined(__LP64__)
2191  const char* FMT = "unknown(%d)\n";
2192 #else
2193  const char* FMT = "unknown(%ld)\n";
2194 #endif /* __x86_64__ */
2195  printf( "*MODIFYWORLDTRANSFORM*\n" );
2196  edit_xform( "xform", xform );
2197  printf( "\tiMode\t\t: " );
2198  switch ( iMode ) {
2199  case MWT_IDENTITY: printf( "MWT_IDENTITY\n" ); break;
2200  case MWT_LEFTMULTIPLY: printf( "MWT_LEFTMULTIPLY\n" ); break;
2201  case MWT_RIGHTMULTIPLY: printf( "MWT_RIGHTMULTIPLY\n" ); break;
2202  default: printf( FMT, iMode );
2203  }
2204  }
2205 #endif /* ENABLE_EDITING */
2206  };
2207 
2209 
2216  public:
2220  EMRSETWORLDTRANSFORM ( const XFORM* transform )
2221  {
2222  emr.iType = EMR_SETWORLDTRANSFORM;
2223  emr.nSize = sizeof( ::EMRSETWORLDTRANSFORM );
2224  xform = *transform;
2225  }
2231  {
2232  ds >> emr >> xform;
2233  }
2237  bool serialize ( DATASTREAM ds )
2238  {
2239  ds << emr << xform;
2240  return true;
2241  }
2245  int size ( void ) const { return emr.nSize; }
2251  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2252  {
2253  EMF_UNUSED(source);
2254  SetWorldTransform( dc, &xform );
2255  }
2256 #ifdef ENABLE_EDITING
2257 
2260  void edit ( void ) const
2261  {
2262  printf( "*SETWORLDTRANSFORM*\n" );
2263  edit_xform( "xform", xform );
2264  }
2265 #endif /* ENABLE_EDITING */
2266  };
2267 
2269 
2273  public:
2277  EMRSETTEXTALIGN ( UINT mode )
2278  {
2279  emr.iType = EMR_SETTEXTALIGN;
2280  emr.nSize = sizeof( ::EMRSETTEXTALIGN );
2281  iMode = mode;
2282  }
2288  {
2289  ds >> emr >> iMode;
2290  }
2294  bool serialize ( DATASTREAM ds )
2295  {
2296  ds << emr << iMode;
2297  return true;
2298  }
2302  int size ( void ) const { return emr.nSize; }
2308  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2309  {
2310  EMF_UNUSED(source);
2311  SetTextAlign( dc, iMode );
2312  }
2313 #ifdef ENABLE_EDITING
2314 
2317  void edit ( void ) const
2318  {
2319 #if defined(__LP64__)
2320  const char* FMT = "| unknown bits(0x%x)";
2321 #else
2322  const char* FMT = "| unknown bits(0x%lx)";
2323 #endif /* __x86_64__ */
2324  unsigned int known_bits = TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING;
2325  unsigned int unknown_bits = ~known_bits;
2326 
2327  printf( "*SETTEXTALIGN*\n" );
2328  printf( "\tiMode\t: " );
2329  if ( iMode & TA_UPDATECP )
2330  printf( "TA_UPDATECP" );
2331  else
2332  printf( "TA_NOUPDATECP" );
2333  if ( iMode & TA_CENTER )
2334  printf( " | TA_CENTER" );
2335  else if ( iMode & TA_RIGHT )
2336  printf( " | TA_RIGHT" );
2337  else
2338  printf( " | TA_LEFT" );
2339  if ( iMode & TA_BASELINE )
2340  printf( " | TA_BASELINE" );
2341  else if ( iMode & TA_BOTTOM )
2342  printf( " | TA_BOTTOM" );
2343  else
2344  printf( " | TA_TOP" );
2345  if ( iMode & TA_RTLREADING )
2346  printf( " | TA_RTLREADING" );
2347  if ( iMode & unknown_bits )
2348  printf( FMT, iMode & unknown_bits );
2349  printf( "\n" );
2350  }
2351 #endif /* ENABLE_EDITING */
2352  };
2353 
2355 
2359  public:
2363  EMRSETTEXTCOLOR ( COLORREF color )
2364  {
2365  emr.iType = EMR_SETTEXTCOLOR;
2366  emr.nSize = sizeof( ::EMRSETTEXTCOLOR );
2367  crColor = color;
2368  }
2374  {
2375  ds >> emr >> crColor;
2376  }
2380  bool serialize ( DATASTREAM ds )
2381  {
2382  ds << emr << crColor;
2383  return true;
2384  }
2388  int size ( void ) const { return emr.nSize; }
2394  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2395  {
2396  EMF_UNUSED(source);
2397  SetTextColor( dc, crColor );
2398  }
2399 #ifdef ENABLE_EDITING
2400 
2403  void edit ( void ) const
2404  {
2405  printf( "*SETTEXTCOLOR*\n" );
2406  edit_color( "crColor", crColor );
2407  }
2408 #endif /* ENABLE_EDITING */
2409  };
2410 
2412 
2416  public:
2420  EMRSETBKCOLOR ( COLORREF color )
2421  {
2422  emr.iType = EMR_SETBKCOLOR;
2423  emr.nSize = sizeof( ::EMRSETBKCOLOR );
2424  crColor = color;
2425  }
2431  {
2432  ds >> emr >> crColor;
2433  }
2437  bool serialize ( DATASTREAM ds )
2438  {
2439  ds << emr << crColor;
2440  return true;
2441  }
2445  int size ( void ) const { return emr.nSize; }
2451  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2452  {
2453  EMF_UNUSED(source);
2454  SetBkColor( dc, crColor );
2455  }
2456 #ifdef ENABLE_EDITING
2457 
2460  void edit ( void ) const
2461  {
2462  printf( "*SETBKCOLOR*\n" );
2463  edit_color( "crColor", crColor );
2464  }
2465 #endif /* ENABLE_EDITING */
2466  };
2467 
2469 
2474  public:
2478  EMRSETBKMODE ( DWORD mode )
2479  {
2480  emr.iType = EMR_SETBKMODE;
2481  emr.nSize = sizeof( ::EMRSETBKMODE );
2482  iMode = mode;
2483  }
2489  {
2490  ds >> emr >> iMode;
2491  }
2495  bool serialize ( DATASTREAM ds )
2496  {
2497  ds << emr << iMode;
2498  return true;
2499  }
2503  int size ( void ) const { return emr.nSize; }
2509  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2510  {
2511  EMF_UNUSED(source);
2512  SetBkMode( dc, iMode );
2513  }
2514 #ifdef ENABLE_EDITING
2515 
2518  void edit ( void ) const
2519  {
2520 #if defined(__LP64__)
2521  const char* FMT = "unknown(%d)\n";
2522 #else
2523  const char* FMT = "unknown(%ld)\n";
2524 #endif /* __x86_64__ */
2525  printf( "*SETBKMODE*\n" );
2526  printf( "\tiMode\t: " );
2527  switch ( iMode ) {
2528  case TRANSPARENT: printf( "TRANSPARENT\n" ); break;
2529  case OPAQUE: printf( "OPAQUE\n" ); break;
2530  default: printf( FMT, iMode );
2531  }
2532  }
2533 #endif /* ENABLE_EDITING */
2534  };
2535 
2537 
2541  public:
2545  EMRSETPOLYFILLMODE ( DWORD mode )
2546  {
2547  emr.iType = EMR_SETPOLYFILLMODE;
2548  emr.nSize = sizeof( ::EMRSETPOLYFILLMODE );
2549  iMode = mode;
2550  }
2556  {
2557  ds >> emr >> iMode;
2558  }
2562  bool serialize ( DATASTREAM ds )
2563  {
2564  ds << emr << iMode;
2565  return true;
2566  }
2570  int size ( void ) const { return emr.nSize; }
2576  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2577  {
2578  EMF_UNUSED(source);
2579  SetPolyFillMode( dc, iMode );
2580  }
2581 #ifdef ENABLE_EDITING
2582 
2585  void edit ( void ) const
2586  {
2587 #if defined(__LP64__)
2588  const char* FMT = "unknown(%d)\n";
2589 #else
2590  const char* FMT = "unknown(%ld)\n";
2591 #endif /* __x86_64__ */
2592  printf( "*SETPOLYFILLMODE*\n" );
2593  printf( "\tiMode: " );
2594  switch ( iMode ) {
2595  case ALTERNATE: printf( "ALTERNATE\n" ); break;
2596  case WINDING: printf( "WINDING\n" ); break;
2597  default: printf( FMT, iMode );
2598  }
2599  }
2600 #endif /* ENABLE_EDITING */
2601  };
2602 
2604 
2609  public:
2613  EMRSETMAPMODE ( DWORD mode )
2614  {
2615  emr.iType = EMR_SETMAPMODE;
2616  emr.nSize = sizeof( ::EMRSETMAPMODE );
2617  iMode = mode;
2618  }
2624  {
2625  ds >> emr >> iMode;
2626  }
2630  bool serialize ( DATASTREAM ds )
2631  {
2632  ds << emr << iMode;
2633  return true;
2634  }
2638  int size ( void ) const { return emr.nSize; }
2644  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2645  {
2646  EMF_UNUSED(source);
2647  SetMapMode( dc, iMode );
2648  }
2649 #ifdef ENABLE_EDITING
2650 
2653  void edit ( void ) const
2654  {
2655 #if defined(__LP64__)
2656  const char* FMT = "unknown(%d)\n";
2657 #else
2658  const char* FMT = "unknown(%ld)\n";
2659 #endif /* __x86_64__ */
2660  printf( "*SETMAPMODE*\n" );
2661  printf( "\tiMode\t: " );
2662  switch ( iMode ) {
2663  case MM_TEXT: printf( "MM_TEXT\n" ); break;
2664  case MM_LOMETRIC: printf( "MM_LOMETRIC\n" ); break;
2665  case MM_HIMETRIC: printf( "MM_HIMETRIC\n" ); break;
2666  case MM_LOENGLISH: printf( "MM_LOENGLISH\n" ); break;
2667  case MM_HIENGLISH: printf( "MM_HIENGLISH\n" ); break;
2668  case MM_TWIPS: printf( "MM_TWIPS\n" ); break;
2669  case MM_ISOTROPIC: printf( "MM_ISOTROPIC\n" ); break;
2670  case MM_ANISOTROPIC: printf( "MM_ANISOTROPIC\n" ); break;
2671  default: printf( FMT, iMode );
2672  }
2673  }
2674 #endif /* ENABLE_EDITING */
2675  };
2676 
2678 
2682  public:
2686  EMRSELECTOBJECT ( HGDIOBJ object )
2687  {
2688  emr.iType = EMR_SELECTOBJECT;
2689  emr.nSize = sizeof( ::EMRSELECTOBJECT );
2690  ihObject = object;
2691  }
2697  {
2698  ds >> emr >> ihObject;
2699  }
2703  bool serialize ( DATASTREAM ds )
2704  {
2705  ds << emr << ihObject;
2706  return true;
2707  }
2711  int size ( void ) const { return emr.nSize; }
2717  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
2718 #ifdef ENABLE_EDITING
2719 
2722  void edit ( void ) const
2723  {
2724 #if defined(__LP64__)
2725  const char* FMT = "\tihObject\t: 0x%x\n";
2726 #else
2727  const char* FMT = "\tihObject\t: 0x%lx\n";
2728 #endif /* __x86_64__ */
2729  printf( "*SELECTOBJECT*\n" );
2730  printf( FMT, ihObject );
2731  }
2732 #endif /* ENABLE_EDITING */
2733  };
2734 
2736 
2740  public:
2744  EMRDELETEOBJECT ( HGDIOBJ object )
2745  {
2746  emr.iType = EMR_DELETEOBJECT;
2747  emr.nSize = sizeof( ::EMRDELETEOBJECT );
2748  ihObject = object;
2749  }
2755  {
2756  ds >> emr >> ihObject;
2757  }
2761  bool serialize ( DATASTREAM ds )
2762  {
2763  ds << emr << ihObject;
2764  return true;
2765  }
2769  int size ( void ) const { return emr.nSize; }
2775  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
2776 #ifdef ENABLE_EDITING
2777 
2780  void edit ( void ) const
2781  {
2782 #if defined(__LP64__)
2783  const char* FMT = "\tihObject\t: 0x%x\n";
2784 #else
2785  const char* FMT = "\tihObject\t: 0x%lx\n";
2786 #endif /* __x86_64__ */
2787  printf( "*DELETEOBJECT*\n" );
2788  printf( FMT, ihObject );
2789  }
2790 #endif /* ENABLE_EDITING */
2791  };
2792 
2794 
2798  public:
2803  EMRMOVETOEX ( INT x, INT y )
2804  {
2805  emr.iType = EMR_MOVETOEX;
2806  emr.nSize = sizeof( ::EMRMOVETOEX );
2807  ptl.x = x;
2808  ptl.y = y;
2809  }
2815  {
2816  ds >> emr >> ptl;
2817  }
2821  bool serialize ( DATASTREAM ds )
2822  {
2823  ds << emr << ptl;
2824  return true;
2825  }
2829  int size ( void ) const { return emr.nSize; }
2835  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2836  {
2837  EMF_UNUSED(source);
2838  MoveToEx( dc, ptl.x, ptl.y, 0 );
2839  }
2840 #ifdef ENABLE_EDITING
2841 
2844  void edit ( void ) const
2845  {
2846  printf( "*MOVETOEX*\n" );
2847  edit_pointl( "ptl", ptl );
2848  }
2849 #endif /* ENABLE_EDITING */
2850  };
2851 
2853 
2857  public:
2862  EMRLINETO ( INT x, INT y )
2863  {
2864  emr.iType = EMR_LINETO;
2865  emr.nSize = sizeof( ::EMRLINETO );
2866  ptl.x = x;
2867  ptl.y = y;
2868  }
2874  {
2875  ds >> emr >> ptl;
2876  }
2880  bool serialize ( DATASTREAM ds )
2881  {
2882  ds << emr << ptl;
2883  return true;
2884  }
2888  int size ( void ) const { return emr.nSize; }
2894  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2895  {
2896  EMF_UNUSED(source);
2897  LineTo( dc, ptl.x, ptl.y );
2898  }
2899 #ifdef ENABLE_EDITING
2900 
2903  void edit ( void ) const
2904  {
2905  printf( "*LINETO*\n" );
2906  edit_pointl( "ptl", ptl );
2907  }
2908 #endif /* ENABLE_EDITING */
2909  };
2910 
2912 
2915  class EMRARC : public METARECORD, ::EMRARC {
2916  public:
2928  EMRARC ( INT left, INT top, INT right, INT bottom, INT xstart,
2929  INT ystart, INT xend, INT yend )
2930  {
2931  emr.iType = EMR_ARC;
2932  emr.nSize = sizeof( ::EMRARC );
2933  rclBox.left = left;
2934  rclBox.right = right;
2935  rclBox.bottom = bottom;
2936  rclBox.top = top;
2937  ptlStart.x = xstart;
2938  ptlStart.y = ystart;
2939  ptlEnd.x = xend;
2940  ptlEnd.y = yend;
2941  }
2947  {
2948  ds >> emr >> rclBox >> ptlStart >> ptlEnd;
2949  }
2953  bool serialize ( DATASTREAM ds )
2954  {
2955  ds << emr << rclBox << ptlStart << ptlEnd;
2956  return true;
2957  }
2961  int size ( void ) const { return emr.nSize; }
2967  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
2968  {
2969  EMF_UNUSED(source);
2970  Arc( dc, rclBox.left, rclBox.top, rclBox.right, rclBox.bottom,
2971  ptlStart.x, ptlStart.y, ptlEnd.x, ptlEnd.y );
2972  }
2973 #ifdef ENABLE_EDITING
2974 
2977  void edit ( void ) const
2978  {
2979  printf( "*ARC*\n" );
2980  edit_rectl( "rclBox\t", rclBox );
2981  edit_pointl( "ptlStart", ptlStart );
2982  edit_pointl( "ptlEnd\t", ptlEnd );
2983  }
2984 #endif /* ENABLE_EDITING */
2985  };
2986 
2988 
2991  class EMRARCTO : public METARECORD, ::EMRARCTO {
2992  public:
3004  EMRARCTO ( INT left, INT top, INT right, INT bottom, INT xstart,
3005  INT ystart, INT xend, INT yend )
3006  {
3007  emr.iType = EMR_ARCTO;
3008  emr.nSize = sizeof( ::EMRARCTO );
3009  rclBox.left = left;
3010  rclBox.right = right;
3011  rclBox.bottom = bottom;
3012  rclBox.top = top;
3013  ptlStart.x = xstart;
3014  ptlStart.y = ystart;
3015  ptlEnd.x = xend;
3016  ptlEnd.y = yend;
3017  }
3023  {
3024  ds >> emr >> rclBox >> ptlStart >> ptlEnd;
3025  }
3029  bool serialize ( DATASTREAM ds )
3030  {
3031  ds << emr << rclBox << ptlStart << ptlEnd;
3032  return true;
3033  }
3037  int size ( void ) const { return emr.nSize; }
3043  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3044  {
3045  EMF_UNUSED(source);
3046  ArcTo( dc, rclBox.left, rclBox.top, rclBox.right, rclBox.bottom,
3047  ptlStart.x, ptlStart.y, ptlEnd.x, ptlEnd.y );
3048  }
3049 #ifdef ENABLE_EDITING
3050 
3053  void edit ( void ) const
3054  {
3055  printf( "*ARCTO*\n" );
3056  edit_rectl( "rclBox\t", rclBox );
3057  edit_pointl( "ptlStart", ptlStart );
3058  edit_pointl( "ptlEnd\t", ptlEnd );
3059  }
3060 #endif /* ENABLE_EDITING */
3061  };
3062 
3064 
3068  public:
3075  EMRRECTANGLE ( INT left, INT top, INT right, INT bottom )
3076  {
3077  emr.iType = EMR_RECTANGLE;
3078  emr.nSize = sizeof( ::EMRRECTANGLE );
3079  rclBox.left = left;
3080  rclBox.right = right;
3081  rclBox.bottom = bottom;
3082  rclBox.top = top;
3083  }
3089  {
3090  ds >> emr >> rclBox;
3091  }
3095  bool serialize ( DATASTREAM ds )
3096  {
3097  ds << emr << rclBox;
3098  return true;
3099  }
3103  int size ( void ) const { return emr.nSize; }
3109  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3110  {
3111  EMF_UNUSED(source);
3112  Rectangle( dc, rclBox.left, rclBox.top, rclBox.right, rclBox.bottom );
3113  }
3114 #ifdef ENABLE_EDITING
3115 
3118  void edit ( void ) const
3119  {
3120  printf( "*RECTANGLE*\n" );
3121  edit_rectl( "rclBox", rclBox );
3122  }
3123 #endif /* ENABLE_EDITING */
3124  };
3125 
3127 
3131  public:
3139  EMRELLIPSE ( INT left, INT top, INT right, INT bottom )
3140  {
3141  emr.iType = EMR_ELLIPSE;
3142  emr.nSize = sizeof( ::EMRELLIPSE );
3143  rclBox.left = left;
3144  rclBox.right = right;
3145  rclBox.bottom = bottom;
3146  rclBox.top = top;
3147  }
3153  {
3154  ds >> emr >> rclBox;
3155  }
3159  bool serialize ( DATASTREAM ds )
3160  {
3161  ds << emr << rclBox;
3162  return true;
3163  }
3167  int size ( void ) const { return emr.nSize; }
3173  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3174  {
3175  EMF_UNUSED(source);
3176  Ellipse( dc, rclBox.left, rclBox.top, rclBox.right, rclBox.bottom );
3177  }
3178 #ifdef ENABLE_EDITING
3179 
3182  void edit ( void ) const
3183  {
3184  printf( "*ELLIPSE*\n" );
3185  edit_rectl( "rclBox", rclBox );
3186  }
3187 #endif /* ENABLE_EDITING */
3188  };
3189 
3191 
3195  POINTL* lpoints;
3196  public:
3202  EMRPOLYLINE ( const RECTL* bounds, const POINT* points, INT n )
3203  {
3204  cptl = n;
3205  aptl[0].x = 0; // Really unused
3206  aptl[0].y = 0;
3207 
3208  emr.iType = EMR_POLYLINE;
3209  // The (cptl - 1) below is to account for aptl, which isn't written out
3210  emr.nSize = sizeof( ::EMRPOLYLINE ) + sizeof( POINTL ) * ( cptl - 1);
3211 
3212  lpoints = new POINTL[cptl];
3213 
3214  for (int i=0; i<n; i++) {
3215  lpoints[i].x = points[i].x;
3216  lpoints[i].y = points[i].y;
3217  }
3218 
3219  rclBounds = *bounds;
3220  }
3225  {
3226  if ( lpoints ) delete[] lpoints;
3227  }
3233  {
3234  ds >> emr >> rclBounds >> cptl;
3235 
3236  lpoints = new POINTL[cptl];
3237 
3238  POINTLARRAY points( lpoints, cptl );
3239 
3240  ds >> points;
3241  }
3245  bool serialize ( DATASTREAM ds )
3246  {
3247  ds << emr << rclBounds << cptl << POINTLARRAY( lpoints, cptl );
3248  return true;
3249  }
3253  int size ( void ) const { return emr.nSize; }
3259  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3260  {
3261  EMF_UNUSED(source);
3262  // According to the wine windef.h header, POINT and POINTL are equivalent
3263  Polyline( dc, (POINT*)lpoints, cptl );
3264  }
3265 #ifdef ENABLE_EDITING
3266 
3269  void edit ( void ) const
3270  {
3271  printf( "*POLYLINE*\n" );
3272  edit_rectl( "rclBounds", rclBounds );
3273 #if 0
3274  printf( "\tcptl : %ld\n", cptl );
3275  printf( "\taptl->\n" );
3276  for ( unsigned int i = 0; i < cptl; i++ )
3277  printf( "\t\t%ld, %ld\n", lpoints[i].x, lpoints[i].y );
3278 #else
3279  edit_pointlarray( "\t", cptl, lpoints );
3280 #endif
3281  }
3282 #endif /* ENABLE_EDITING */
3283  };
3284 
3286 
3290  POINT16* lpoints;
3291  public:
3297  EMRPOLYLINE16 ( const RECTL* bounds, const POINT16* points, INT n )
3298  {
3299  cpts = n;
3300  apts[0].x = 0; // Really unused
3301  apts[0].y = 0;
3302 
3303  emr.iType = EMR_POLYLINE16;
3304  // The (cptl - 1) below is to account for aptl, which isn't written out
3305  emr.nSize = sizeof( ::EMRPOLYLINE16 ) + sizeof( POINT16 ) * ( cpts - 1);
3306 
3307  lpoints = new POINT16[cpts];
3308 
3309  for (int i=0; i<n; i++) {
3310  lpoints[i].x = points[i].x;
3311  lpoints[i].y = points[i].y;
3312  }
3313 
3314  rclBounds = *bounds;
3315  }
3322  EMRPOLYLINE16 ( const RECTL* bounds, const POINT* points, INT n )
3323  {
3324  cpts = n;
3325  apts[0].x = 0; // Really unused
3326  apts[0].y = 0;
3327 
3328  emr.iType = EMR_POLYLINE16;
3329  // The (cptl - 1) below is to account for aptl, which isn't written out
3330  emr.nSize = sizeof( ::EMRPOLYLINE16 ) + sizeof( POINT16 ) * ( cpts - 1);
3331 
3332  lpoints = new POINT16[cpts];
3333 
3334  for (int i=0; i<n; i++) {
3335  lpoints[i].x = points[i].x;
3336  lpoints[i].y = points[i].y;
3337  }
3338 
3339  rclBounds = *bounds;
3340  }
3345  {
3346  if ( lpoints ) delete[] lpoints;
3347  }
3353  {
3354  ds >> emr >> rclBounds >> cpts;
3355 
3356  lpoints = new POINT16[cpts];
3357 
3358  POINT16ARRAY points( lpoints, cpts );
3359 
3360  ds >> points;
3361  }
3365  bool serialize ( DATASTREAM ds )
3366  {
3367  ds << emr << rclBounds << cpts << POINT16ARRAY( lpoints, cpts );
3368  return true;
3369  }
3373  int size ( void ) const { return emr.nSize; }
3379  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3380  {
3381  EMF_UNUSED(source);
3382  // According to the wine windef.h header, POINT and POINTL are equivalent
3383  Polyline16( dc, lpoints, cpts );
3384  }
3385 #ifdef ENABLE_EDITING
3386 
3389  void edit ( void ) const
3390  {
3391  printf( "*POLYLINE16*\n" );
3392  edit_rectl( "rclBounds", rclBounds );
3393  edit_point16array( "\t", cpts, lpoints );
3394  }
3395 #endif /* ENABLE_EDITING */
3396  };
3397 
3399 
3403  POINTL* lpoints;
3404  public:
3410  EMRPOLYGON ( const RECTL* bounds, const POINT* points, INT n )
3411  {
3412  cptl = n;
3413  aptl[0].x = 0; // Really unused
3414  aptl[0].y = 0;
3415 
3416  emr.iType = EMR_POLYGON;
3417  // The (cptl-1) below is to account for aptl, which isn't written out
3418  emr.nSize = sizeof( ::EMRPOLYGON ) + sizeof( POINTL ) * (cptl-1);
3419 
3420  lpoints = new POINTL[cptl];
3421 
3422  for (int i=0; i<n; i++) {
3423  lpoints[i].x = points[i].x;
3424  lpoints[i].y = points[i].y;
3425  }
3426 
3427  rclBounds = *bounds;
3428  }
3434  {
3435  ds >> emr >> rclBounds >> cptl;
3436 
3437  lpoints = new POINTL[cptl];
3438 
3439  POINTLARRAY points( lpoints, cptl );
3440 
3441  ds >> points;
3442  }
3447  {
3448  if ( lpoints ) delete[] lpoints;
3449  }
3453  bool serialize ( DATASTREAM ds )
3454  {
3455  ds << emr << rclBounds << cptl << POINTLARRAY( lpoints, cptl );
3456  return true;
3457  }
3461  int size ( void ) const { return emr.nSize; }
3467  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3468  {
3469  EMF_UNUSED(source);
3470  // According to the wine windef.h header, POINT and POINTL are equivalent
3471  Polygon( dc, (POINT*)lpoints, cptl );
3472  }
3473 #ifdef ENABLE_EDITING
3474 
3477  void edit ( void ) const
3478  {
3479  printf( "*POLYGON*\n" );
3480  edit_rectl( "rclBounds", rclBounds );
3481 #if 0
3482  printf( "\tcptl : %ld\n", cptl );
3483  printf( "\taptl->\n" );
3484  for ( unsigned int i = 0; i < cptl; i++ )
3485  printf( "\t\t%ld, %ld\n", lpoints[i].x, lpoints[i].y );
3486 #else
3487  edit_pointlarray( "\t", cptl, lpoints );
3488 #endif
3489  }
3490 #endif /* ENABLE_EDITING */
3491  };
3492 
3494 
3498  POINT16* lpoints;
3499  public:
3505  EMRPOLYGON16 ( const RECTL* bounds, const POINT* points, INT16 n )
3506  {
3507  cpts = n;
3508  apts[0].x = 0; // Really unused
3509  apts[0].y = 0;
3510 
3511  emr.iType = EMR_POLYGON16;
3512  // The (cptl-1) below is to account for aptl, which isn't written out
3513  emr.nSize = sizeof( ::EMRPOLYGON16 ) + sizeof( POINT16 ) * (cpts-1);
3514 
3515  lpoints = new POINT16[cpts];
3516 
3517  for (int i=0; i<n; i++) {
3518  lpoints[i].x = points[i].x;
3519  lpoints[i].y = points[i].y;
3520  }
3521 
3522  rclBounds = *bounds;
3523  }
3530  EMRPOLYGON16 ( const RECTL* bounds, const POINT16* points, INT16 n )
3531  {
3532  cpts = n;
3533  apts[0].x = 0; // Really unused
3534  apts[0].y = 0;
3535 
3536  emr.iType = EMR_POLYGON16;
3537  // The (cptl-1) below is to account for aptl, which isn't written out
3538  emr.nSize = sizeof( ::EMRPOLYGON16 ) + sizeof( POINT16 ) * (cpts-1);
3539 
3540  lpoints = new POINT16[cpts];
3541 
3542  for (int i=0; i<n; i++) {
3543  lpoints[i].x = points[i].x;
3544  lpoints[i].y = points[i].y;
3545  }
3546 
3547  rclBounds = *bounds;
3548  }
3554  {
3555  ds >> emr >> rclBounds >> cpts;
3556 
3557  lpoints = new POINT16[cpts];
3558 
3559  POINT16ARRAY points( lpoints, cpts );
3560 
3561  ds >> points;
3562  }
3567  {
3568  if ( lpoints ) delete[] lpoints;
3569  }
3573  bool serialize ( DATASTREAM ds )
3574  {
3575  ds << emr << rclBounds << cpts << POINT16ARRAY( lpoints, cpts );
3576  return true;
3577  }
3581  int size ( void ) const { return emr.nSize; }
3587  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3588  {
3589  EMF_UNUSED(source);
3590  // According to the wine windef.h header, POINT and POINTL are equivalent
3591  Polygon16( dc, lpoints, cpts );
3592  }
3593 #ifdef ENABLE_EDITING
3594 
3597  void edit ( void ) const
3598  {
3599  printf( "*POLYGON16*\n" );
3600  edit_rectl( "rclBounds", rclBounds );
3601  edit_point16array( "\t", cpts, lpoints );
3602  }
3603 #endif /* ENABLE_EDITING */
3604  };
3605 
3607 
3611  DWORD* lcounts;
3612  POINTL* lpoints;
3613  public:
3620  EMRPOLYPOLYGON ( const RECTL* bounds, const POINT* points, const INT* counts,
3621  UINT polygons )
3622  {
3623  nPolys = polygons;
3624  // Count the number of points in points
3625  int n = 0;
3626  for ( unsigned int i = 0; i < nPolys; i++ )
3627  n += counts[i];
3628 
3629  cptl = n;
3630  aPolyCounts[0] = 0; // Really unused
3631  aptl[0].x = 0;
3632  aptl[0].y = 0;
3633 
3634  emr.iType = EMR_POLYPOLYGON;
3635  // The (#-1)'s below are to account for aPolyCounts[0] and aptl[0], which
3636  // aren't directly written out
3637  emr.nSize = sizeof( ::EMRPOLYPOLYGON ) + sizeof( POINTL ) * (cptl-1)
3638  + sizeof( DWORD ) * (nPolys-1);
3639 
3640  lcounts = new DWORD[nPolys];
3641 
3642  for ( unsigned int i = 0; i < nPolys; i++ )
3643  lcounts[i] = counts[i];
3644 
3645  lpoints = new POINTL[cptl];
3646 
3647  for (int i=0; i<n; i++) {
3648  lpoints[i].x = points[i].x;
3649  lpoints[i].y = points[i].y;
3650  }
3651 
3652  rclBounds = *bounds;
3653  }
3658  {
3659  if ( lcounts ) delete[] lcounts;
3660  if ( lpoints ) delete[] lpoints;
3661  }
3667  {
3668  ds >> emr >> rclBounds >> nPolys >> cptl;
3669 
3670  lcounts = new DWORD[nPolys];
3671 
3672  DWORDARRAY counts( lcounts, nPolys );
3673 
3674  ds >> counts;
3675 
3676  lpoints = new POINTL[cptl];
3677 
3678  POINTLARRAY points( lpoints, cptl );
3679 
3680  ds >> points;
3681  }
3685  bool serialize ( DATASTREAM ds )
3686  {
3687  ds << emr << rclBounds << nPolys << cptl << DWORDARRAY( lcounts, nPolys )
3688  << POINTLARRAY( lpoints, cptl );
3689  return true;
3690  }
3694  int size ( void ) const { return emr.nSize; }
3700  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3701  {
3702  EMF_UNUSED(source);
3703  // According to the wine windef.h header, POINT and POINTL are equivalent
3704  // (but DWORD and INT are not)
3705  std::vector<INT> countsv( lcounts, lcounts + nPolys );
3706 
3707  PolyPolygon( dc, (POINT*)lpoints, &countsv[0], nPolys );
3708  }
3709 #ifdef ENABLE_EDITING
3710 
3713  void edit ( void ) const
3714  {
3715 #if defined(__LP64__)
3716  const char* FMT0 = "\tnPolys\t\t: %d\n";
3717  const char* FMT1 = "\tcptl\t\t: %d\n";
3718  const char* FMT2 = "%d\n";
3719  const char* FMT3 = "\t\t\t %d\n";
3720  const char* FMT4 = "%d, %d\n";
3721  const char* FMT5 = "\t\t\t %d, %d\n";
3722 #else
3723  const char* FMT0 = "\tnPolys\t\t: %ld\n";
3724  const char* FMT1 = "\tcptl\t\t: %ld\n";
3725  const char* FMT2 = "%ld\n";
3726  const char* FMT3 = "\t\t\t %ld\n";
3727  const char* FMT4 = "%ld, %ld\n";
3728  const char* FMT5 = "\t\t\t %ld, %ld\n";
3729 #endif /* __x86_64__ */
3730  printf( "*POLYPOLYGON*\n" );
3731  edit_rectl( "rclBounds", rclBounds );
3732  printf( FMT0, nPolys );
3733  printf( FMT1, cptl );
3734  printf( "\taPolyCounts\t: " );
3735  if ( nPolys > 0 )
3736  printf( FMT2, lcounts[0] );
3737  else
3738  puts( "" );
3739  for ( unsigned int i = 1; i < nPolys; i++ )
3740  printf( FMT3, lcounts[i] );
3741  printf( "\tapts\t\t: " );
3742  if ( cptl > 0 )
3743  printf( FMT4, lpoints[0].x, lpoints[0].y );
3744  else
3745  puts( "" );
3746  for ( unsigned int i = 1; i < cptl; i++ )
3747  printf( FMT5, lpoints[i].x, lpoints[i].y );
3748  }
3749 #endif /* ENABLE_EDITING */
3750  };
3751 
3753 
3757  DWORD* lcounts;
3758  POINT16* lpoints;
3759  public:
3766  EMRPOLYPOLYGON16 ( const RECTL* bounds, const POINT* points,
3767  const INT* counts, UINT polygons )
3768  {
3769  nPolys = polygons;
3770  // Count the number of points in points
3771  int n = 0;
3772  for ( unsigned int i = 0; i < nPolys; i++ )
3773  n += counts[i];
3774 
3775  cpts = n;
3776  aPolyCounts[0] = 0; // Really unused
3777  apts[0].x = 0;
3778  apts[0].y = 0;
3779 
3780  emr.iType = EMR_POLYPOLYGON16;
3781  // The (#-1)'s below are to account for aPolyCounts[0] and aptl[0], which
3782  // aren't directly written out
3783  emr.nSize = sizeof( ::EMRPOLYPOLYGON16 ) + sizeof( POINT16 ) * (cpts-1)
3784  + sizeof( DWORD ) * (nPolys-1);
3785 
3786  lcounts = new DWORD[nPolys];
3787 
3788  for ( unsigned int i = 0; i < nPolys; i++ )
3789  lcounts[i] = counts[i];
3790 
3791  lpoints = new POINT16[cpts];
3792 
3793  for (int i=0; i<n; i++) {
3794  lpoints[i].x = points[i].x;
3795  lpoints[i].y = points[i].y;
3796  }
3797 
3798  rclBounds = *bounds;
3799  }
3807  EMRPOLYPOLYGON16 ( const RECTL* bounds, const POINT16* points,
3808  const INT* counts, UINT16 polygons )
3809  {
3810  nPolys = polygons;
3811  // Count the number of points in points
3812  int n = 0;
3813  for ( unsigned int i = 0; i < nPolys; i++ )
3814  n += counts[i];
3815 
3816  cpts = n;
3817  aPolyCounts[0] = 0; // Really unused
3818  apts[0].x = 0;
3819  apts[0].y = 0;
3820 
3821  emr.iType = EMR_POLYPOLYGON16;
3822  // The (#-1)'s below are to account for aPolyCounts[0] and aptl[0], which
3823  // aren't directly written out
3824  emr.nSize = sizeof( ::EMRPOLYPOLYGON16 ) + sizeof( POINT16 ) * (cpts-1)
3825  + sizeof( DWORD ) * (nPolys-1);
3826 
3827  lcounts = new DWORD[nPolys];
3828 
3829  for ( unsigned int i = 0; i < nPolys; i++ )
3830  lcounts[i] = counts[i];
3831 
3832  lpoints = new POINT16[cpts];
3833 
3834  for (int i=0; i<n; i++) {
3835  lpoints[i].x = points[i].x;
3836  lpoints[i].y = points[i].y;
3837  }
3838 
3839  rclBounds = *bounds;
3840  }
3845  {
3846  if ( lcounts ) delete[] lcounts;
3847  if ( lpoints ) delete[] lpoints;
3848  }
3854  {
3855  ds >> emr >> rclBounds >> nPolys >> cpts;
3856 
3857  lcounts = new DWORD[nPolys];
3858 
3859  DWORDARRAY counts( lcounts, nPolys );
3860 
3861  ds >> counts;
3862 
3863  lpoints = new POINT16[cpts];
3864 
3865  POINT16ARRAY points( lpoints, cpts );
3866 
3867  ds >> points;
3868  }
3872  bool serialize ( DATASTREAM ds )
3873  {
3874  ds << emr << rclBounds << nPolys << cpts << DWORDARRAY( lcounts, nPolys )
3875  << POINT16ARRAY( lpoints, cpts );
3876  return true;
3877  }
3881  int size ( void ) const { return emr.nSize; }
3887  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
3888  {
3889  EMF_UNUSED(source);
3890  // According to the wine windef.h header, POINT and POINTL are equivalent
3891  // (but DWORD and INT are not)
3892  std::vector<INT> counts( lcounts, lcounts + nPolys );
3893 
3894  PolyPolygon16( dc, lpoints, &counts[0], nPolys );
3895  }
3896 #ifdef ENABLE_EDITING
3897 
3900  void edit ( void ) const
3901  {
3902 #if defined(__LP64__)
3903  const char* FMT0 = "\tnPolys\t\t: %d\n";
3904  const char* FMT1 = "\tcptl\t\t: %d\n";
3905  const char* FMT2 = "%d\n";
3906  const char* FMT3 = "\t\t\t %d\n";
3907 #else
3908  const char* FMT0 = "\tnPolys\t\t: %ld\n";
3909  const char* FMT1 = "\tcptl\t\t: %ld\n";
3910  const char* FMT2 = "%ld\n";
3911  const char* FMT3 = "\t\t\t %ld\n";
3912 #endif /* __x86_64__ */
3913  printf( "*POLYPOLYGON16*\n" );
3914  edit_rectl( "rclBounds", rclBounds );
3915  printf( FMT0, nPolys );
3916  printf( FMT1, cpts );
3917  printf( "\taPolyCounts\t: " );
3918  if ( nPolys > 0 )
3919  printf( FMT2, lcounts[0] );
3920  else
3921  puts( "" );
3922  for ( unsigned int i = 1; i < nPolys; i++ )
3923  printf( FMT3, lcounts[i] );
3924  printf( "\tapts\t\t: " );
3925  if ( cpts > 0 )
3926  printf( "%d, %d\n", lpoints[0].x, lpoints[0].y );
3927  else
3928  puts( "" );
3929  for ( unsigned int i = 1; i < cpts; i++ )
3930  printf( "\t\t\t %d, %d\n", lpoints[i].x, lpoints[i].y );
3931  }
3932 #endif /* ENABLE_EDITING */
3933  };
3934 
3936 
3940  POINTL* lpoints;
3941  public:
3947  EMRPOLYBEZIER ( const RECTL* bounds, const POINT* points, INT n )
3948  {
3949  cptl = n;
3950  aptl[0].x = 0; // Really unused
3951  aptl[0].y = 0;
3952 
3953  emr.iType = EMR_POLYBEZIER;
3954  // The (cptl-1) below is to account for aptl, which isn't written out
3955  emr.nSize = sizeof( ::EMRPOLYBEZIER ) + sizeof( POINTL ) * (cptl-1);
3956 
3957  lpoints = new POINTL[cptl];
3958 
3959  for (int i=0; i<n; i++) {
3960  lpoints[i].x = points[i].x;
3961  lpoints[i].y = points[i].y;
3962  }
3963 
3964  rclBounds = *bounds;
3965  }
3971  {
3972  ds >> emr >> rclBounds >> cptl;
3973 
3974  lpoints = new POINTL[cptl];
3975 
3976  POINTLARRAY points( lpoints, cptl );
3977 
3978  ds >> points;
3979  }
3984  {
3985  if ( lpoints ) delete[] lpoints;
3986  }
3990  bool serialize ( DATASTREAM ds )
3991  {
3992  ds << emr << rclBounds << cptl << POINTLARRAY( lpoints, cptl );
3993  return true;
3994  }
3998  int size ( void ) const { return emr.nSize; }
4004  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4005  {
4006  EMF_UNUSED(source);
4007  // According to the wine windef.h header, POINT and POINTL are equivalent
4008  PolyBezier( dc, (POINT*)lpoints, cptl );
4009  }
4010 #ifdef ENABLE_EDITING
4011 
4014  void edit ( void ) const
4015  {
4016  printf( "*POLYBEZIER*\n" );
4017  edit_rectl( "rclBounds", rclBounds );
4018 #if 0
4019  printf( "\tcptl : %ld\n", cptl );
4020  printf( "\taptl->\n" );
4021  for ( unsigned int i = 0; i < cptl; i++ )
4022  printf( "\t\t%ld, %ld\n", lpoints[i].x, lpoints[i].y );
4023 #else
4024  edit_pointlarray( "\t", cptl, lpoints );
4025 #endif
4026  }
4027 #endif /* ENABLE_EDITING */
4028  };
4029 
4031 
4035  POINT16* lpoints;
4036  public:
4042  EMRPOLYBEZIER16 ( const RECTL* bounds, const POINT16* points, INT n )
4043  {
4044  cpts = n;
4045  apts[0].x = 0; // Really unused
4046  apts[0].y = 0;
4047 
4048  emr.iType = EMR_POLYBEZIER16;
4049  // The (cptl-1) below is to account for aptl, which isn't written out
4050  emr.nSize = sizeof( ::EMRPOLYBEZIER16 ) + sizeof( POINT16 ) * (cpts-1);
4051 
4052  lpoints = new POINT16[cpts];
4053 
4054  for (int i=0; i<n; i++) {
4055  lpoints[i].x = points[i].x;
4056  lpoints[i].y = points[i].y;
4057  }
4058 
4059  rclBounds = *bounds;
4060  }
4067  EMRPOLYBEZIER16 ( const RECTL* bounds, const POINT* points, INT n )
4068  {
4069  cpts = n;
4070  apts[0].x = 0; // Really unused
4071  apts[0].y = 0;
4072 
4073  emr.iType = EMR_POLYBEZIER16;
4074  // The (cptl-1) below is to account for aptl, which isn't written out
4075  emr.nSize = sizeof( ::EMRPOLYBEZIER16 ) + sizeof( POINT16 ) * (cpts-1);
4076 
4077  lpoints = new POINT16[cpts];
4078 
4079  for (int i=0; i<n; i++) {
4080  lpoints[i].x = points[i].x;
4081  lpoints[i].y = points[i].y;
4082  }
4083 
4084  rclBounds = *bounds;
4085  }
4091  {
4092  ds >> emr >> rclBounds >> cpts;
4093 
4094  lpoints = new POINT16[cpts];
4095 
4096  POINT16ARRAY points( lpoints, cpts );
4097 
4098  ds >> points;
4099  }
4104  {
4105  if ( lpoints ) delete[] lpoints;
4106  }
4110  bool serialize ( DATASTREAM ds )
4111  {
4112  ds << emr << rclBounds << cpts << POINT16ARRAY( lpoints, cpts );
4113  return true;
4114  }
4118  int size ( void ) const { return emr.nSize; }
4124  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4125  {
4126  EMF_UNUSED(source);
4127  // According to the wine windef.h header, POINT and POINTL are equivalent
4128  PolyBezier16( dc, lpoints, cpts );
4129  }
4130 #ifdef ENABLE_EDITING
4131 
4134  void edit ( void ) const
4135  {
4136  printf( "*POLYBEZIER16*\n" );
4137  edit_rectl( "rclBounds", rclBounds );
4138  edit_point16array( "\t", cpts, lpoints );
4139  }
4140 #endif /* ENABLE_EDITING */
4141  };
4142 
4144 
4148  POINTL* lpoints;
4149  public:
4155  EMRPOLYBEZIERTO ( const RECTL* bounds, const POINT* points, INT n )
4156  {
4157  cptl = n;
4158  aptl[0].x = 0; // Really unused
4159  aptl[0].y = 0;
4160 
4161  emr.iType = EMR_POLYBEZIERTO;
4162  // The (cptl-1) below is to account for aptl, which isn't written out
4163  emr.nSize = sizeof( ::EMRPOLYBEZIERTO ) + sizeof( POINTL ) * (cptl-1);
4164 
4165  lpoints = new POINTL[cptl];
4166 
4167  for (int i=0; i<n; i++) {
4168  lpoints[i].x = points[i].x;
4169  lpoints[i].y = points[i].y;
4170  }
4171 
4172  rclBounds = *bounds;
4173  }
4179  {
4180  ds >> emr >> rclBounds >> cptl;
4181 
4182  lpoints = new POINTL[cptl];
4183 
4184  POINTLARRAY points( lpoints, cptl );
4185 
4186  ds >> points;
4187  }
4192  {
4193  if ( lpoints ) delete[] lpoints;
4194  }
4198  bool serialize ( DATASTREAM ds )
4199  {
4200  ds << emr << rclBounds << cptl << POINTLARRAY( lpoints, cptl );
4201  return true;
4202  }
4206  int size ( void ) const { return emr.nSize; }
4212  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4213  {
4214  EMF_UNUSED(source);
4215  // According to the wine windef.h header, POINT and POINTL are equivalent
4216  PolyBezierTo( dc, (POINT*)lpoints, cptl );
4217  }
4218 #ifdef ENABLE_EDITING
4219 
4222  void edit ( void ) const
4223  {
4224  printf( "*POLYBEZIERTO*\n" );
4225  edit_rectl( "rclBounds", rclBounds );
4226 #if 0
4227  printf( "\tcptl : %ld\n", cptl );
4228  printf( "\taptl->\n" );
4229  for ( unsigned int i = 0; i < cptl; i++ )
4230  printf( "\t\t%ld, %ld\n", lpoints[i].x, lpoints[i].y );
4231 #else
4232  edit_pointlarray( "\t", cptl, lpoints );
4233 #endif
4234  }
4235 #endif /* ENABLE_EDITING */
4236  };
4237 
4239 
4243  POINT16* lpoints;
4244  public:
4250  EMRPOLYBEZIERTO16 ( const RECTL* bounds, const POINT16* points, INT n )
4251  {
4252  cpts = n;
4253  apts[0].x = 0; // Really unused
4254  apts[0].y = 0;
4255 
4256  emr.iType = EMR_POLYBEZIERTO16;
4257  // The (cptl-1) below is to account for aptl, which isn't written out
4258  emr.nSize = sizeof( ::EMRPOLYBEZIERTO16 ) + sizeof( POINT16 ) * (cpts-1);
4259 
4260  lpoints = new POINT16[cpts];
4261 
4262  for (int i=0; i<n; i++) {
4263  lpoints[i].x = points[i].x;
4264  lpoints[i].y = points[i].y;
4265  }
4266 
4267  rclBounds = *bounds;
4268  }
4275  EMRPOLYBEZIERTO16 ( const RECTL* bounds, const POINT* points, INT n )
4276  {
4277  cpts = n;
4278  apts[0].x = 0; // Really unused
4279  apts[0].y = 0;
4280 
4281  emr.iType = EMR_POLYBEZIERTO16;
4282  // The (cptl-1) below is to account for aptl, which isn't written out
4283  emr.nSize = sizeof( ::EMRPOLYBEZIERTO16 ) + sizeof( POINT16 ) * (cpts-1);
4284 
4285  lpoints = new POINT16[cpts];
4286 
4287  for (int i=0; i<n; i++) {
4288  lpoints[i].x = points[i].x;
4289  lpoints[i].y = points[i].y;
4290  }
4291 
4292  rclBounds = *bounds;
4293  }
4299  {
4300  ds >> emr >> rclBounds >> cpts;
4301 
4302  lpoints = new POINT16[cpts];
4303 
4304  POINT16ARRAY points( lpoints, cpts );
4305 
4306  ds >> points;
4307  }
4312  {
4313  if ( lpoints ) delete[] lpoints;
4314  }
4318  bool serialize ( DATASTREAM ds )
4319  {
4320  ds << emr << rclBounds << cpts << POINT16ARRAY( lpoints, cpts );
4321  return true;
4322  }
4326  int size ( void ) const { return emr.nSize; }
4332  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4333  {
4334  EMF_UNUSED(source);
4335  // According to the wine windef.h header, POINT and POINTL are equivalent
4336  PolyBezierTo16( dc, lpoints, cpts );
4337  }
4338 #ifdef ENABLE_EDITING
4339 
4342  void edit ( void ) const
4343  {
4344  printf( "*POLYBEZIERTO16*\n" );
4345  edit_rectl( "rclBounds", rclBounds );
4346  edit_point16array( "\t", cpts, lpoints );
4347  }
4348 #endif /* ENABLE_EDITING */
4349  };
4350 
4352 
4356  POINTL* lpoints;
4357  public:
4363  EMRPOLYLINETO ( const RECTL* bounds, const POINT* points, INT n )
4364  {
4365  cptl = n;
4366  aptl[0].x = 0;
4367  aptl[0].y = 0;
4368 
4369  emr.iType = EMR_POLYLINETO;
4370  // The (cptl-1) below is to account for aptl, which isn't written out
4371  emr.nSize = sizeof( ::EMRPOLYLINETO ) + sizeof( POINTL ) * (cptl-1);
4372 
4373  lpoints = new POINTL[cptl];
4374 
4375  for (int i=0; i<n; i++) {
4376  lpoints[i].x = points[i].x;
4377  lpoints[i].y = points[i].y;
4378  }
4379 
4380  rclBounds = *bounds;
4381  }
4387  {
4388  ds >> emr >> rclBounds >> cptl;
4389 
4390  lpoints = new POINTL[cptl];
4391 
4392  POINTLARRAY points( lpoints, cptl );
4393 
4394  ds >> points;
4395  }
4400  {
4401  if ( lpoints ) delete[] lpoints;
4402  }
4406  bool serialize ( DATASTREAM ds )
4407  {
4408  ds << emr << rclBounds << cptl << POINTLARRAY( lpoints, cptl );
4409  return true;
4410  }
4414  int size ( void ) const { return emr.nSize; }
4420  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4421  {
4422  EMF_UNUSED(source);
4423  // According to the wine windef.h header, POINT and POINTL are equivalent
4424  PolylineTo( dc, (POINT*)lpoints, cptl );
4425  }
4426 #ifdef ENABLE_EDITING
4427 
4430  void edit ( void ) const
4431  {
4432  printf( "*POLYLINETO*\n" );
4433  edit_rectl( "rclBounds", rclBounds );
4434 #if 0
4435  printf( "\tcptl : %ld\n", cptl );
4436  printf( "\taptl->\n" );
4437  for ( unsigned int i = 0; i < cptl; i++ )
4438  printf( "\t\t%ld, %ld\n", lpoints[i].x, lpoints[i].y );
4439 #else
4440  edit_pointlarray( "\t", cptl, lpoints );
4441 #endif
4442  }
4443 #endif /* ENABLE_EDITING */
4444  };
4445 
4447 
4451  POINT16* lpoints;
4452  public:
4458  EMRPOLYLINETO16 ( const RECTL* bounds, const POINT16* points, INT n )
4459  {
4460  cpts = n;
4461  apts[0].x = 0;
4462  apts[0].y = 0;
4463 
4464  emr.iType = EMR_POLYLINETO16;
4465  // The (cptl-1) below is to account for aptl, which isn't written out
4466  emr.nSize = sizeof( ::EMRPOLYLINETO16 ) + sizeof( POINT16 ) * (cpts-1);
4467 
4468  lpoints = new POINT16[cpts];
4469 
4470  for (int i=0; i<n; i++) {
4471  lpoints[i].x = points[i].x;
4472  lpoints[i].y = points[i].y;
4473  }
4474 
4475  rclBounds = *bounds;
4476  }
4483  EMRPOLYLINETO16 ( const RECTL* bounds, const POINT* points, INT n )
4484  {
4485  cpts = n;
4486  apts[0].x = 0;
4487  apts[0].y = 0;
4488 
4489  emr.iType = EMR_POLYLINETO16;
4490  // The (cptl-1) below is to account for aptl, which isn't written out
4491  emr.nSize = sizeof( ::EMRPOLYLINETO16 ) + sizeof( POINT16 ) * (cpts-1);
4492 
4493  lpoints = new POINT16[cpts];
4494 
4495  for (int i=0; i<n; i++) {
4496  lpoints[i].x = points[i].x;
4497  lpoints[i].y = points[i].y;
4498  }
4499 
4500  rclBounds = *bounds;
4501  }
4507  {
4508  ds >> emr >> rclBounds >> cpts;
4509 
4510  lpoints = new POINT16[cpts];
4511 
4512  POINT16ARRAY points( lpoints, cpts );
4513 
4514  ds >> points;
4515  }
4520  {
4521  if ( lpoints ) delete[] lpoints;
4522  }
4526  bool serialize ( DATASTREAM ds )
4527  {
4528  ds << emr << rclBounds << cpts << POINT16ARRAY( lpoints, cpts );
4529  return true;
4530  }
4534  int size ( void ) const { return emr.nSize; }
4540  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4541  {
4542  EMF_UNUSED(source);
4543  // According to the wine windef.h header, POINT and POINTL are equivalent
4544  PolylineTo16( dc, lpoints, cpts );
4545  }
4546 #ifdef ENABLE_EDITING
4547 
4550  void edit ( void ) const
4551  {
4552  printf( "*POLYLINETO16*\n" );
4553  edit_rectl( "rclBounds", rclBounds );
4554  edit_point16array( "\t", cpts, lpoints );
4555  }
4556 #endif /* ENABLE_EDITING */
4557  };
4558 
4560 
4566  PSTR string_a;
4567  int string_size;
4568 
4569  INT* dx_i;
4570  public:
4580  EMREXTTEXTOUTA ( const RECTL* bounds, DWORD graphicsMode, FLOAT xScale,
4581  FLOAT yScale, const PEMRTEXT text, LPCSTR string,
4582  const INT* dx )
4583  {
4584  emr.iType = EMR_EXTTEXTOUTA;
4585  emr.nSize = sizeof( ::EMREXTTEXTOUTA );
4586 
4587  rclBounds = *bounds;
4588 
4589  iGraphicsMode = graphicsMode;
4590  exScale = xScale;
4591  eyScale = yScale;
4592 
4593  emrtext = *text;
4594 
4595  string_size = ROUND_TO_LONG( emrtext.nChars );
4596 
4597  string_a = new CHAR[ string_size ];
4598 
4599  memset( string_a, 0, sizeof(CHAR) * string_size );
4600 
4601  for ( unsigned int i=0; i<emrtext.nChars; i++ )
4602  string_a[i] = *string++;
4603 
4604  emrtext.offString = emr.nSize;
4605  emr.nSize += string_size * sizeof(CHAR);
4606 #if 0
4607 /*
4608 Test only - Problem: Windows requires this dx to be set - at least from 2K on
4609 but to calculate real dx values is hard
4610 For pstoedit - this is "fixed" now by estimating dx in pstoedit
4611 */
4612  if ( !dx ) {
4613  int * dxn = new int [string_size];
4614  for (unsigned int i=0; i < string_size; i++) dxn[i] = 10;
4615  dx = dxn;
4616  }
4617 #endif
4618 
4619  if ( dx ) {
4620 
4621  dx_i = new INT[ emrtext.nChars ];
4622 
4623  for ( unsigned int i=0; i<emrtext.nChars; i++ )
4624  dx_i[i] = *dx++;
4625 
4626  emrtext.offDx = emr.nSize;
4627  emr.nSize += emrtext.nChars * sizeof(INT);
4628  }
4629  else {
4630  emrtext.offDx = 0;
4631  dx_i = 0;
4632  }
4633  }
4639  {
4640  ds >> emr >> rclBounds >> iGraphicsMode >> exScale >> eyScale >> emrtext;
4641 
4642  if ( emrtext.offString != 0 ) {
4643  string_size = ROUND_TO_LONG( emrtext.nChars );
4644 
4645  string_a = new CHAR[ string_size ];
4646 
4647  memset( string_a, 0, sizeof(CHAR) * string_size );
4648 
4649  CHARSTR string( string_a, string_size );
4650 
4651  ds >> string;
4652  }
4653  else
4654  string_a = 0;
4655 
4656  if ( emrtext.offDx ) {
4657  dx_i = new INT[ emrtext.nChars ];
4658 
4659  INTARRAY dx_is( dx_i, emrtext.nChars );
4660 
4661  ds >> dx_is;
4662  }
4663  else
4664  dx_i = 0;
4665  }
4671  {
4672  if ( string_a ) delete[] string_a;
4673  if ( dx_i ) delete[] dx_i;
4674  }
4678  bool serialize ( DATASTREAM ds )
4679  {
4680  ds << emr << rclBounds << iGraphicsMode << exScale << eyScale
4681  << emrtext << CHARSTR( string_a, string_size );
4682  if ( dx_i )
4683  ds << INTARRAY( dx_i, emrtext.nChars );
4684  return true;
4685  }
4689  int size ( void ) const { return emr.nSize; }
4695  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4696  {
4697  EMF_UNUSED(source);
4698  RECT rect;
4699  rect.left = emrtext.rcl.left;
4700  rect.top = emrtext.rcl.top;
4701  rect.right = emrtext.rcl.right;
4702  rect.bottom = emrtext.rcl.bottom;
4703 
4704  ExtTextOutA( dc, emrtext.ptlReference.x, emrtext.ptlReference.y,
4705  emrtext.fOptions, &rect, string_a, emrtext.nChars,
4706  dx_i );
4707  }
4708 #ifdef ENABLE_EDITING
4709 
4712  void edit ( void ) const
4713  {
4714 #if defined(__LP64__)
4715  const char* FMT0 = "unknown(%d)\n";
4716  const char* FMT1 = "\tptlReference\t: (%d,%d)\n";
4717  const char* FMT2 = "\tnChars\t\t: %d\n";
4718  const char* FMT3 = "\toffString\t: %d\n";
4719  const char* FMT4 = "\toffDx\t\t: %d\n";
4720 #else
4721  const char* FMT0 = "unknown(%ld)\n";
4722  const char* FMT1 = "\tptlReference\t: (%ld,%ld)\n";
4723  const char* FMT2 = "\tnChars\t\t: %ld\n";
4724  const char* FMT3 = "\toffString\t: %ld\n";
4725  const char* FMT4 = "\toffDx\t\t: %ld\n";
4726 #endif /* __x86_64__ */
4727  printf( "*EXTTEXTOUTA*\n" );
4728  edit_rectl( "rclBounds", rclBounds );
4729  printf( "\tiGraphicsMode\t: " );
4730  switch ( iGraphicsMode ) {
4731  case GM_COMPATIBLE: printf( "GM_COMPATIBLE\n" ); break;
4732  case GM_ADVANCED: printf( "GM_ADVANCED\n" ); break;
4733  default: printf( FMT0, iGraphicsMode );
4734  }
4735  printf( "\texScale\t\t: %f\n", exScale );
4736  printf( "\teyScale\t\t: %f\n", eyScale );
4737  printf( FMT1, emrtext.ptlReference.x, emrtext.ptlReference.y );
4738  printf( FMT2, emrtext.nChars );
4739  printf( FMT3, emrtext.offString );
4740  printf( "\tfOptions\t: " );
4741  if ( emrtext.fOptions == 0 )
4742  printf( "None" );
4743  else {
4744  if ( emrtext.fOptions & ETO_GRAYED ) {
4745  printf( "ETO_GRAYED" );
4746  if ( emrtext.fOptions & ~ETO_GRAYED )
4747  printf( " | " );
4748  }
4749  if ( emrtext.fOptions & ETO_OPAQUE ) {
4750  printf( "ETO_OPAQUE" );
4751  if ( emrtext.fOptions & ~(ETO_GRAYED | ETO_OPAQUE) )
4752  printf( " | " );
4753  }
4754  if ( emrtext.fOptions & ETO_CLIPPED ) {
4755  printf( "ETO_CLIPPED" );
4756  if ( emrtext.fOptions & ~(ETO_GRAYED | ETO_OPAQUE | ETO_CLIPPED ) )
4757  printf( " | " );
4758  }
4759  if ( emrtext.fOptions & ETO_GLYPH_INDEX ) {
4760  printf( "ETO_GLYPH_INDEX" );
4761  if ( emrtext.fOptions &
4762  ~(ETO_GRAYED | ETO_OPAQUE | ETO_CLIPPED | ETO_GLYPH_INDEX) )
4763  printf( " | " );
4764  }
4765  if ( emrtext.fOptions & ETO_RTLREADING ) {
4766  printf( "ETO_RTLREADING" );
4767  if ( emrtext.fOptions &
4768  ~(ETO_GRAYED | ETO_OPAQUE | ETO_CLIPPED | ETO_GLYPH_INDEX |
4769  ETO_RTLREADING) )
4770  printf( " | " );
4771  }
4772  if ( emrtext.fOptions & ETO_IGNORELANGUAGE )
4773  printf( "ETO_IGNORELANGUAGE" );
4774  }
4775  printf( "\n" );
4776  edit_rectl( "rcl\t", emrtext.rcl );
4777  printf( FMT4, emrtext.offDx );
4778  printf( "\tString:\n\t\t%s\n", string_a );
4779 
4780  if ( emrtext.offDx != 0 ) {
4781  printf( "\tOffsets:\n\t\t" );
4782  for ( unsigned int i = 0; i < emrtext.nChars; i++ )
4783  printf( "%d ", dx_i[i] );
4784  printf( "\n" );
4785  }
4786  }
4787 #endif /* ENABLE_EDITING */
4788  };
4790 
4796  PWSTR string_a;
4797  int string_size;
4798 
4799  INT* dx_i;
4800  public:
4810  EMREXTTEXTOUTW ( const RECTL* bounds, DWORD graphicsMode, FLOAT xScale,
4811  FLOAT yScale, const PEMRTEXT text, LPCWSTR string,
4812  const INT* dx )
4813  {
4814  emr.iType = EMR_EXTTEXTOUTW;
4815  emr.nSize = sizeof( ::EMREXTTEXTOUTW );
4816 
4817  rclBounds = *bounds;
4818 
4819  iGraphicsMode = graphicsMode;
4820  exScale = xScale;
4821  eyScale = yScale;
4822 
4823  emrtext = *text;
4824 
4825  string_size = ROUND_TO_LONG( emrtext.nChars );
4826 
4827  string_a = new WCHAR[ string_size ];
4828 
4829  memset( string_a, 0, sizeof(WCHAR) * string_size );
4830 
4831  for ( unsigned int i=0; i<emrtext.nChars; i++ )
4832  string_a[i] = *string++;
4833 
4834  emrtext.offString = emr.nSize;
4835  emr.nSize += string_size * sizeof(WCHAR);
4836 #if 0
4837 /*
4838 Test only - Problem: Windows requires this dx to be set - at least from 2K on
4839 but to calculate real dx values is hard
4840 For pstoedit - this is "fixed" now by estimating dx in pstoedit
4841 */
4842  if ( !dx ) {
4843  int * dxn = new int [string_size];
4844  for (unsigned int i=0; i < string_size; i++) dxn[i] = 10;
4845  dx = dxn;
4846  }
4847 #endif
4848 
4849  if ( dx ) {
4850 
4851  dx_i = new INT[ emrtext.nChars ];
4852 
4853  for ( unsigned int i=0; i<emrtext.nChars; i++ )
4854  dx_i[i] = *dx++;
4855 
4856  emrtext.offDx = emr.nSize;
4857  emr.nSize += emrtext.nChars * sizeof(INT);
4858  }
4859  else {
4860  emrtext.offDx = 0;
4861  dx_i = 0;
4862  }
4863  }
4869  {
4870  ds >> emr >> rclBounds >> iGraphicsMode >> exScale >> eyScale >> emrtext;
4871 
4872  if ( emrtext.offString != 0 ) {
4873  string_size = ROUND_TO_LONG( emrtext.nChars );
4874 
4875  string_a = new WCHAR[ string_size ];
4876 
4877  memset( string_a, 0, sizeof(WCHAR) * string_size );
4878 
4879  WCHARSTR string( string_a, string_size );
4880 
4881  ds >> string;
4882  }
4883  else
4884  string_a = 0;
4885 
4886  if ( emrtext.offDx ) {
4887  dx_i = new INT[ emrtext.nChars ];
4888 
4889  INTARRAY dx_is( dx_i, emrtext.nChars );
4890 
4891  ds >> dx_is;
4892  }
4893  else
4894  dx_i = 0;
4895  }
4901  {
4902  if ( string_a ) delete[] string_a;
4903  if ( dx_i ) delete[] dx_i;
4904  }
4908  bool serialize ( DATASTREAM ds )
4909  {
4910  ds << emr << rclBounds << iGraphicsMode << exScale << eyScale
4911  << emrtext << WCHARSTR( string_a, string_size );
4912  if ( dx_i )
4913  ds << INTARRAY( dx_i, emrtext.nChars );
4914  return true;
4915  }
4919  int size ( void ) const { return emr.nSize; }
4925  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
4926  {
4927  EMF_UNUSED(source);
4928  RECT rect;
4929  rect.left = emrtext.rcl.left;
4930  rect.top = emrtext.rcl.top;
4931  rect.right = emrtext.rcl.right;
4932  rect.bottom = emrtext.rcl.bottom;
4933 
4934  ExtTextOutW( dc, emrtext.ptlReference.x, emrtext.ptlReference.y,
4935  emrtext.fOptions, &rect, string_a, emrtext.nChars,
4936  dx_i );
4937  }
4938 #ifdef ENABLE_EDITING
4939 
4942  void edit ( void ) const
4943  {
4944 #if defined(__LP64__)
4945  const char* FMT0 = "unknown(%d)\n";
4946  const char* FMT1 = "\tptlReference\t: (%d,%d)\n";
4947  const char* FMT2 = "\tnChars\t\t: %d\n";
4948  const char* FMT3 = "\toffString\t: %d\n";
4949  const char* FMT4 = "\toffDx\t\t: %d\n";
4950 #else
4951  const char* FMT0 = "unknown(%ld)\n";
4952  const char* FMT1 = "\tptlReference\t: (%ld,%ld)\n";
4953  const char* FMT2 = "\tnChars\t\t: %ld\n";
4954  const char* FMT3 = "\toffString\t: %ld\n";
4955  const char* FMT4 = "\toffDx\t\t: %ld\n";
4956 #endif /* __x86_64__ */
4957  printf( "*EXTTEXTOUTA*\n" );
4958  edit_rectl( "rclBounds", rclBounds );
4959  printf( "\tiGraphicsMode\t: " );
4960  switch ( iGraphicsMode ) {
4961  case GM_COMPATIBLE: printf( "GM_COMPATIBLE\n" ); break;
4962  case GM_ADVANCED: printf( "GM_ADVANCED\n" ); break;
4963  default: printf( FMT0, iGraphicsMode );
4964  }
4965  printf( "\texScale\t\t: %f\n", exScale );
4966  printf( "\teyScale\t\t: %f\n", eyScale );
4967  printf( FMT1, emrtext.ptlReference.x, emrtext.ptlReference.y );
4968  printf( FMT2, emrtext.nChars );
4969  printf( FMT3, emrtext.offString );
4970  printf( "\tfOptions\t: " );
4971  if ( emrtext.fOptions == 0 )
4972  printf( "None" );
4973  else {
4974  if ( emrtext.fOptions & ETO_GRAYED ) {
4975  printf( "ETO_GRAYED" );
4976  if ( emrtext.fOptions & ~ETO_GRAYED )
4977  printf( " | " );
4978  }
4979  if ( emrtext.fOptions & ETO_OPAQUE ) {
4980  printf( "ETO_OPAQUE" );
4981  if ( emrtext.fOptions & ~(ETO_GRAYED | ETO_OPAQUE) )
4982  printf( " | " );
4983  }
4984  if ( emrtext.fOptions & ETO_CLIPPED ) {
4985  printf( "ETO_CLIPPED" );
4986  if ( emrtext.fOptions & ~(ETO_GRAYED | ETO_OPAQUE | ETO_CLIPPED ) )
4987  printf( " | " );
4988  }
4989  if ( emrtext.fOptions & ETO_GLYPH_INDEX ) {
4990  printf( "ETO_GLYPH_INDEX" );
4991  if ( emrtext.fOptions &
4992  ~(ETO_GRAYED | ETO_OPAQUE | ETO_CLIPPED | ETO_GLYPH_INDEX) )
4993  printf( " | " );
4994  }
4995  if ( emrtext.fOptions & ETO_RTLREADING ) {
4996  printf( "ETO_RTLREADING" );
4997  if ( emrtext.fOptions &
4998  ~(ETO_GRAYED | ETO_OPAQUE | ETO_CLIPPED | ETO_GLYPH_INDEX |
4999  ETO_RTLREADING) )
5000  printf( " | " );
5001  }
5002  if ( emrtext.fOptions & ETO_IGNORELANGUAGE )
5003  printf( "ETO_IGNORELANGUAGE" );
5004  }
5005  printf( "\n" );
5006  edit_rectl( "rcl\t", emrtext.rcl );
5007  printf( FMT4, emrtext.offDx );
5008 #if 0
5009  printf( "\tString:\n\t\t%s\n", string_a );
5010 #else
5011  {
5012  // iconv_open arguments are TO, FROM (not the other way around).
5013  iconv_t cvt = iconv_open( "UTF-8", "UTF-16LE" );
5014  std::vector<char> utf8_buffer( emrtext.nChars );
5015  // Cannot predict the space necessary to hold the converted
5016  // string. So, we loop until conversion is complete.
5017  size_t size = emrtext.nChars * sizeof(*string_a);
5018  size_t in_bytes_left = size;
5019  size_t converted = 0;
5020  char* in_buffer = (char*)string_a;
5021  while ( 1 ) {
5022  char* out_buffer = &utf8_buffer[converted];
5023  size_t out_bytes_left = size - converted;
5024 
5025  size_t n = iconv( cvt, &in_buffer, &in_bytes_left,
5026  &out_buffer, &out_bytes_left );
5027 
5028  converted = size - out_bytes_left;
5029 
5030  if ( n == (size_t)-1 ) {
5031  if ( errno == E2BIG ) {
5032  size_t new_size = 2 * utf8_buffer.size();
5033  utf8_buffer.resize( new_size );
5034  size = utf8_buffer.size();
5035  }
5036  else {
5037  // Real conversion error.
5038  break;
5039  }
5040  }
5041  else {
5042  break;
5043  }
5044  }
5045 
5046  iconv_close( cvt );
5047 
5048  if ( converted == utf8_buffer.size() )
5049  utf8_buffer.push_back( '\0' );
5050  else
5051  utf8_buffer[converted] = '\0';
5052 
5053  printf( "\tString:\n\t\t%s\n", &utf8_buffer[0] );
5054  }
5055 #endif
5056  if ( emrtext.offDx != 0 ) {
5057  printf( "\tOffsets:\n\t\t" );
5058  for ( unsigned int i = 0; i < emrtext.nChars; i++ )
5059  printf( "%d ", dx_i[i] );
5060  printf( "\n" );
5061  }
5062  }
5063 #endif /* ENABLE_EDITING */
5064  };
5065 
5067 
5071  public:
5077  EMRSETPIXELV ( INT x, INT y, COLORREF color )
5078  {
5079  emr.iType = EMR_SETPIXELV;
5080  emr.nSize = sizeof( ::EMRSETPIXELV );
5081  ptlPixel.x = x;
5082  ptlPixel.y = y;
5083  crColor = color;
5084  }
5090  {
5091  ds >> emr >> ptlPixel >> crColor;
5092  }
5096  bool serialize ( DATASTREAM ds )
5097  {
5098  ds << emr << ptlPixel << crColor;
5099  return true;
5100  }
5104  int size ( void ) const { return emr.nSize; }
5110  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5111  {
5112  EMF_UNUSED(source);
5113  SetPixel( dc, ptlPixel.x, ptlPixel.y, crColor );
5114  }
5115 #ifdef ENABLE_EDITING
5116 
5119  void edit ( void ) const
5120  {
5121  printf( "*SETPIXELV*\n" );
5122  edit_pointl( "ptlPixel", ptlPixel );
5123  edit_color( "crColor\t", crColor );
5124  }
5125 #endif /* ENABLE_EDITING */
5126  };
5127 
5128  class PEN;
5129  class EXTPEN;
5130  class BRUSH;
5131  class FONT;
5132  class PALETTE;
5133 
5135 
5138  class EMRCREATEPEN : public METARECORD, public ::EMRCREATEPEN
5139  {
5140  public:
5145  EMRCREATEPEN ( PEN* pen, HGDIOBJ handle );
5150  EMRCREATEPEN ( DATASTREAM& ds );
5154  bool serialize ( DATASTREAM ds )
5155  {
5156  ds << emr << ihPen << lopn;
5157  return true;
5158  }
5162  int size ( void ) const { return emr.nSize; }
5168  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
5169 #ifdef ENABLE_EDITING
5170 
5173  void edit ( void ) const
5174  {
5175 #if defined(__LP64__)
5176  const char* FMT0 = "\tihPen\t\t: 0x%x\n";
5177  const char* FMT1 = "\tlopn.lopnWidth\t: %d, %d\n";
5178 #else
5179  const char* FMT0 = "\tihPen\t\t: 0x%lx\n";
5180  const char* FMT1 = "\tlopn.lopnWidth\t: %ld, %ld\n";
5181 #endif /* __x86_64__ */
5182  printf( "*CREATEPEN*\n" );
5183  printf( FMT0, ihPen );
5184  edit_pen_style( "lopn.lopnStyle", lopn.lopnStyle );
5185  printf( FMT1, lopn.lopnWidth.x, lopn.lopnWidth.y );
5186  edit_color( "lopn.lopnColor", lopn.lopnColor );
5187  }
5188 #endif /* ENABLE_EDITING */
5189  };
5190 
5192 
5197  {
5198  public:
5203  EMREXTCREATEPEN ( EXTPEN* pen, HGDIOBJ handle );
5208  EMREXTCREATEPEN ( DATASTREAM& ds );
5212  bool serialize ( DATASTREAM ds )
5213  {
5214  ds << emr << ihPen << offBmi << cbBmi << offBits << cbBits << elp;
5215  return true;
5216  }
5220  int size ( void ) const { return emr.nSize; }
5226  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
5227 #ifdef ENABLE_EDITING
5228 
5231  void edit ( void ) const
5232  {
5233 #if defined(__LP64__)
5234  const char* FMT0 = "\tihPen\t\t\t: 0x%x\n";
5235  const char* FMT1 = "\toffBmi\t\t\t: %d\n";
5236  const char* FMT2 = "\tcbBmi\t\t\t: %d\n";
5237  const char* FMT3 = "\toffBits\t\t\t: %d\n";
5238  const char* FMT4 = "\tcbBits\t\t\t: %d\n";
5239  const char* FMT5 = "\telp.elpWidth\t\t: %d\n";
5240  const char* FMT6 = "\telp.elpNumEntries\t: %d\n";
5241 #else
5242  const char* FMT0 = "\tihPen\t\t\t: 0x%lx\n";
5243  const char* FMT1 = "\toffBmi\t\t\t: %ld\n";
5244  const char* FMT2 = "\tcbBmi\t\t\t: %ld\n";
5245  const char* FMT3 = "\toffBits\t\t\t: %ld\n";
5246  const char* FMT4 = "\tcbBits\t\t\t: %ld\n";
5247  const char* FMT5 = "\telp.elpWidth\t\t: %ld\n";
5248  const char* FMT6 = "\telp.elpNumEntries\t: %ld\n";
5249 #endif /* __x86_64__ */
5250  printf( "*EXTCREATEPEN*\n" );
5251  printf( FMT0, ihPen );
5252  printf( FMT1, offBmi );
5253  printf( FMT2, cbBmi );
5254  printf( FMT3, offBits );
5255  printf( FMT4, cbBits );
5256  edit_pen_style( "elp.elpPenStyle\t", elp.elpPenStyle );
5257  printf( FMT5, elp.elpWidth );
5258  edit_brush_style( "elp.elpBrushStyle", elp.elpBrushStyle );
5259  edit_color( "elp.elpColor\t", elp.elpColor );
5260  edit_brush_hatch( "elp.elpHatch\t", elp.elpHatch );
5261  printf( FMT6, elp.elpNumEntries );
5262  }
5263 #endif /* ENABLE_EDITING */
5264  };
5265 
5267 
5271  {
5272  public:
5277  EMRCREATEBRUSHINDIRECT ( BRUSH* brush, HGDIOBJ handle );
5286  bool serialize ( DATASTREAM ds )
5287  {
5288  ds << emr << ihBrush << lb;
5289  return true;
5290  }
5294  int size ( void ) const { return emr.nSize; }
5300  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
5301 #ifdef ENABLE_EDITING
5302 
5305  void edit ( void ) const
5306  {
5307 #if defined(__LP64__)
5308  const char* FMT = "\tihBrush\t\t: 0x%x\n";
5309 #else
5310  const char* FMT = "\tihBrush\t\t: 0x%lx\n";
5311 #endif /* __x86_64__ */
5312  printf( "*CREATEBRUSHINDIRECT*\n" );
5313  printf( FMT, ihBrush );
5314  edit_brush_style( "lb.lbStyle", lb.lbStyle );
5315  edit_color( "lb.lbColor", lb.lbColor );
5316  edit_brush_hatch( "lb.lbHatch", lb.lbHatch );
5317  }
5318 #endif /* ENABLE_EDITING */
5319  };
5320 
5322 
5326  {
5327  public:
5332  EMREXTCREATEFONTINDIRECTW ( FONT* font, HGDIOBJ handle );
5341  bool serialize ( DATASTREAM ds )
5342  {
5343  // Since EMF records have to be multiples of 4 bytes, this
5344  // should perhaps be a general thing, but we know it's currently
5345  // only a problem for this structure.
5346 
5347  ds << emr << ihFont << elfw << PADDING( 2 );
5348 
5349  return true;
5350  }
5354  int size ( void ) const { return emr.nSize; }
5360  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
5361 #ifdef ENABLE_EDITING
5362 
5365  void edit ( void ) const
5366  {
5367 #if defined(__LP64__)
5368  const char* FMT0 = "\tihFont\t\t\t: %d\n";
5369  const char* FMT1 = "\tlfHeight\t\t: %d\n";
5370  const char* FMT2 = "\tlfWidth\t\t\t: %d\n";
5371  const char* FMT3 = "\tlfEscapement\t\t: %d\n";
5372  const char* FMT4 = "\tlfOrientation\t\t: %d\n";
5373  const char* FMT5 = "\telfVersion\t\t: %d\n";
5374  const char* FMT6 = "\telfStyleSize\t\t: %d\n";
5375  const char* FMT7 = "\telfMatch\t\t: %d\n";
5376  const char* FMT8 = "\telfCulture\t\t: %d\n";
5377 #else
5378  const char* FMT0 = "\tihFont\t\t\t: %ld\n";
5379  const char* FMT1 = "\tlfHeight\t\t: %ld\n";
5380  const char* FMT2 = "\tlfWidth\t\t\t: %ld\n";
5381  const char* FMT3 = "\tlfEscapement\t\t: %ld\n";
5382  const char* FMT4 = "\tlfOrientation\t\t: %ld\n";
5383  const char* FMT5 = "\telfVersion\t\t: %ld\n";
5384  const char* FMT6 = "\telfStyleSize\t\t: %ld\n";
5385  const char* FMT7 = "\telfMatch\t\t: %ld\n";
5386  const char* FMT8 = "\telfCulture\t\t: %ld\n";
5387 #endif /* __x86_64__ */
5388  printf( "*EXTCREATEFONTINDIRECTW*\n" );
5389  printf( FMT0, ihFont );
5390  printf( FMT1, elfw.elfLogFont.lfHeight );
5391  printf( FMT2, elfw.elfLogFont.lfWidth );
5392  printf( FMT3, elfw.elfLogFont.lfEscapement );
5393  printf( FMT4, elfw.elfLogFont.lfOrientation );
5394  printf( "\tlfWeight\t\t: " );
5395  switch ( elfw.elfLogFont.lfWeight ) {
5396  case FW_DONTCARE: printf( "FW_DONTCARE\n" ); break;
5397  case FW_THIN: printf( "FW_THIN\n" ); break;
5398  case FW_EXTRALIGHT: printf( "FW_EXTRALIGHT\n" ); break;
5399  case FW_LIGHT: printf( "FW_LIGHT\n" ); break;
5400  case FW_NORMAL: printf( "FW_NORMAL\n" ); break;
5401  case FW_MEDIUM: printf( "FW_MEDIUM\n" ); break;
5402  case FW_SEMIBOLD: printf( "FW_SEMIBOLD\n" ); break;
5403  case FW_BOLD: printf( "FW_BOLD\n" ); break;
5404  case FW_EXTRABOLD: printf( "FW_EXTRABOLD\n" ); break;
5405  case FW_BLACK: printf( "FW_BLACK\n" ); break;
5406  }
5407  printf( "\tlfItalic\t\t: %d\n", elfw.elfLogFont.lfItalic );
5408  printf( "\tlfUnderline\t\t: %d\n", elfw.elfLogFont.lfUnderline );
5409  printf( "\tlfStrikeOut\t\t: %d\n", elfw.elfLogFont.lfStrikeOut );
5410  printf( "\tlfCharSet\t\t: %d\n", elfw.elfLogFont.lfCharSet );
5411  printf( "\tlfOutPrecision\t\t: %d\n", elfw.elfLogFont.lfOutPrecision );
5412  printf( "\tlfClipPrecision\t\t: %d\n", elfw.elfLogFont.lfClipPrecision );
5413  printf( "\tlfQuality\t\t: %d\n", elfw.elfLogFont.lfQuality );
5414  printf( "\tlfPitchAndFamily\t: %d\n", elfw.elfLogFont.lfPitchAndFamily );
5415  int i = 0;
5416  printf( "\tlfFaceName\t\t: '" );
5417  while ( elfw.elfLogFont.lfFaceName[i] != 0 && i < LF_FACESIZE ) {
5418  putchar( elfw.elfLogFont.lfFaceName[i] );
5419  i++;
5420  }
5421  puts( "'" );
5422 
5423  i = 0;
5424  printf( "\telfFullName\t\t: '" );
5425  while ( elfw.elfFullName[i] != 0 && i < LF_FULLFACESIZE ) {
5426  putchar( elfw.elfFullName[i] );
5427  i++;
5428  }
5429  puts( "'" );
5430 
5431  i = 0;
5432  printf( "\telfStyle\t\t: '" );
5433  while ( elfw.elfStyle[i] != 0 && i < LF_FACESIZE ) {
5434  putchar( elfw.elfStyle[i] );
5435  i++;
5436  }
5437  puts( "'" );
5438 
5439  printf( FMT5, elfw.elfVersion );
5440  printf( FMT6, elfw.elfStyleSize );
5441  printf( FMT7, elfw.elfMatch );
5442  printf( "\telfVendorId\t\t: '%s'\n", elfw.elfVendorId );
5443  printf( FMT8, elfw.elfCulture );
5444  printf( "\telfPanose\t\t:\n" );
5445  printf( "\t\tbFamilyType\t\t: %d\n", elfw.elfPanose.bFamilyType );
5446  printf( "\t\tbSerifStyle\t\t: %d\n", elfw.elfPanose.bSerifStyle );
5447  printf( "\t\tbWeight\t\t\t: %d\n", elfw.elfPanose.bWeight );
5448  printf( "\t\tbProportion\t\t: %d\n", elfw.elfPanose.bProportion );
5449  printf( "\t\tbContrast\t\t: %d\n", elfw.elfPanose.bContrast );
5450  printf( "\t\tbStrokeVariation\t: %d\n", elfw.elfPanose.bStrokeVariation );
5451  printf( "\t\tbArmStyle\t\t: %d\n", elfw.elfPanose.bArmStyle );
5452  printf( "\t\tbLetterform\t\t: %d\n", elfw.elfPanose.bLetterform );
5453  printf( "\t\tbMidline\t\t: %d\n", elfw.elfPanose.bMidline );
5454  printf( "\t\tbXHeight\t\t: %d\n", elfw.elfPanose.bXHeight );
5455  }
5456 #endif /* ENABLE_EDITING */
5457  };
5458 
5460 
5464  {
5465  public:
5470  EMRCREATEPALETTE ( PALETTE* palette, HGDIOBJ handle );
5475  EMRCREATEPALETTE ( DATASTREAM& ds );
5479  bool serialize ( DATASTREAM ds )
5480  {
5481  ds << emr << ihPal << lgpl;
5482  return true;
5483  }
5487  int size ( void ) const { return emr.nSize; }
5493  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const;
5494 #ifdef ENABLE_EDITING
5495 
5498  void edit ( void ) const
5499  {
5500  printf( "*CREATEPALETTE* (not really handled by libEMF)\n" );
5501  }
5502 #endif /* ENABLE_EDITING */
5503  };
5504 
5506 
5510  public:
5514  EMRFILLPATH ( const RECTL* bounds )
5515  {
5516  emr.iType = EMR_FILLPATH;
5517  emr.nSize = sizeof( ::EMRFILLPATH );
5518  rclBounds = *bounds;
5519  }
5525  {
5526  ds >> emr >> rclBounds;
5527  }
5531  bool serialize ( DATASTREAM ds )
5532  {
5533  ds << emr << rclBounds;
5534  return true;
5535  }
5539  int size ( void ) const { return emr.nSize; }
5545  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5546  {
5547  EMF_UNUSED(source);
5548  FillPath( dc );
5549  }
5550 #ifdef ENABLE_EDITING
5551 
5554  void edit ( void ) const
5555  {
5556  printf( "*FILLPATH*\n" );
5557  edit_rectl( "rclBounds", rclBounds );
5558  }
5559 #endif /* ENABLE_EDITING */
5560  };
5562 
5566  public:
5570  EMRSTROKEPATH ( const RECTL* bounds )
5571  {
5572  emr.iType = EMR_STROKEPATH;
5573  emr.nSize = sizeof( ::EMRSTROKEPATH );
5574  rclBounds = *bounds;
5575  }
5581  {
5582  ds >> emr >> rclBounds;
5583  }
5587  bool serialize ( DATASTREAM ds )
5588  {
5589  ds << emr << rclBounds;
5590  return true;
5591  }
5595  int size ( void ) const { return emr.nSize; }
5601  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5602  {
5603  EMF_UNUSED(source);
5604  StrokePath( dc );
5605  }
5606 #ifdef ENABLE_EDITING
5607 
5610  void edit ( void ) const
5611  {
5612  printf( "*STROKEPATH*\n" );
5613  edit_rectl( "rclBounds", rclBounds );
5614  }
5615 #endif /* ENABLE_EDITING */
5616  };
5618 
5622  public:
5626  EMRSTROKEANDFILLPATH ( const RECTL* bounds )
5627  {
5628  emr.iType = EMR_STROKEANDFILLPATH;
5629  emr.nSize = sizeof( ::EMRSTROKEANDFILLPATH );
5630  rclBounds = *bounds;
5631  }
5637  {
5638  ds >> emr >> rclBounds;
5639  }
5643  bool serialize ( DATASTREAM ds )
5644  {
5645  ds << emr << rclBounds;
5646  return true;
5647  }
5651  int size ( void ) const { return emr.nSize; }
5657  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5658  {
5659  EMF_UNUSED(source);
5660  StrokeAndFillPath( dc );
5661  }
5662 #ifdef ENABLE_EDITING
5663 
5666  void edit ( void ) const
5667  {
5668  printf( "*STROKEANDFILLPATH*\n" );
5669  edit_rectl( "rclBounds", rclBounds );
5670  }
5671 #endif /* ENABLE_EDITING */
5672  };
5674 
5678  public:
5682  EMRBEGINPATH ( void )
5683  {
5684  emr.iType = EMR_BEGINPATH;
5685  emr.nSize = sizeof( ::EMRBEGINPATH );
5686  }
5692  {
5693  ds >> emr;
5694  }
5698  bool serialize ( DATASTREAM ds )
5699  {
5700  ds << emr;
5701  return true;
5702  }
5706  int size ( void ) const { return emr.nSize; }
5712  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5713  {
5714  EMF_UNUSED(source);
5715  BeginPath( dc );
5716  }
5717 #ifdef ENABLE_EDITING
5718 
5721  void edit ( void ) const
5722  {
5723  printf( "*BEGINPATH*\n" );
5724  }
5725 #endif /* ENABLE_EDITING */
5726  };
5728 
5732  public:
5736  EMRENDPATH ( void )
5737  {
5738  emr.iType = EMR_ENDPATH;
5739  emr.nSize = sizeof( ::EMRENDPATH );
5740  }
5746  {
5747  ds >> emr;
5748  }
5752  bool serialize ( DATASTREAM ds )
5753  {
5754  ds << emr;
5755  return true;
5756  }
5760  int size ( void ) const { return emr.nSize; }
5766  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5767  {
5768  EMF_UNUSED(source);
5769  EndPath( dc );
5770  }
5771 #ifdef ENABLE_EDITING
5772 
5775  void edit ( void ) const
5776  {
5777  printf( "*ENDPATH*\n" );
5778  }
5779 #endif /* ENABLE_EDITING */
5780  };
5782 
5786  public:
5791  {
5792  emr.iType = EMR_CLOSEFIGURE;
5793  emr.nSize = sizeof( ::EMRCLOSEFIGURE );
5794  }
5800  {
5801  ds >> emr;
5802  }
5806  bool serialize ( DATASTREAM ds )
5807  {
5808  ds << emr;
5809  return true;
5810  }
5814  int size ( void ) const { return emr.nSize; }
5820  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5821  {
5822  EMF_UNUSED(source);
5823  CloseFigure( dc );
5824  }
5825 #ifdef ENABLE_EDITING
5826 
5829  void edit ( void ) const
5830  {
5831  printf( "*CLOSEFIGURE*\n" );
5832  }
5833 #endif /* ENABLE_EDITING */
5834  };
5836 
5841  public:
5845  EMRSAVEDC ( void )
5846  {
5847  emr.iType = EMR_SAVEDC;
5848  emr.nSize = sizeof( ::EMRSAVEDC );
5849  }
5855  {
5856  ds >> emr;
5857  }
5861  bool serialize ( DATASTREAM ds )
5862  {
5863  ds << emr;
5864  return true;
5865  }
5869  int size ( void ) const { return emr.nSize; }
5875  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5876  {
5877  EMF_UNUSED(source);
5878  SaveDC( dc );
5879  }
5880 #ifdef ENABLE_EDITING
5881 
5884  void edit ( void ) const
5885  {
5886  printf( "*SAVEDC*\n" );
5887  }
5888 #endif /* ENABLE_EDITING */
5889  };
5891 
5895  public:
5899  EMRRESTOREDC ( INT n )
5900  {
5901  emr.iType = EMR_RESTOREDC;
5902  emr.nSize = sizeof( ::EMRRESTOREDC );
5903  iRelative = n;
5904  }
5910  {
5911  ds >> emr >> iRelative;
5912  }
5916  bool serialize ( DATASTREAM ds )
5917  {
5918  ds << emr << iRelative;
5919  return true;
5920  }
5924  int size ( void ) const { return emr.nSize; }
5930  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5931  {
5932  EMF_UNUSED(source);
5933  RestoreDC( dc, iRelative );
5934  }
5935 #ifdef ENABLE_EDITING
5936 
5939  void edit ( void ) const
5940  {
5941 #if defined(__LP64__)
5942  const char* FMT = "\tiRelative: %d\n";
5943 #else
5944  const char* FMT = "\tiRelative: %ld\n";
5945 #endif /* __x86_64__ */
5946  printf( "*RESTOREDC*\n" );
5947  printf( FMT, iRelative );
5948  }
5949 #endif /* ENABLE_EDITING */
5950  };
5952 
5956  public:
5960  EMRSETMETARGN ( void )
5961  {
5962  emr.iType = EMR_SETMETARGN;
5963  emr.nSize = sizeof( ::EMRSETMETARGN );
5964  }
5970  {
5971  ds >> emr;
5972  }
5976  bool serialize ( DATASTREAM ds )
5977  {
5978  ds << emr;
5979  return true;
5980  }
5984  int size ( void ) const { return emr.nSize; }
5990  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
5991  {
5992  EMF_UNUSED(source);
5993  SetMetaRgn( dc );
5994  }
5995 #ifdef ENABLE_EDITING
5996 
5999  void edit ( void ) const
6000  {
6001  printf( "*SETMETARGN*\n" );
6002  }
6003 #endif /* ENABLE_EDITING */
6004  };
6005 
6007 
6010  class PEN : public GRAPHICSOBJECT, public LOGPEN {
6011  public:
6015  PEN ( const LOGPEN* lpen )
6016  {
6017  lopnStyle = lpen->lopnStyle;
6018  lopnWidth = lpen->lopnWidth;
6019  lopnColor = lpen->lopnColor;
6020  }
6024  OBJECTTYPE getType ( void ) const { return O_PEN; }
6031  METARECORD* newEMR ( HDC dc, HGDIOBJ emf_handle )
6032  {
6033  contexts[dc] = emf_handle;
6034  return new EMRCREATEPEN( this, emf_handle );
6035  }
6036  };
6037 
6039 
6042  class EXTPEN : public GRAPHICSOBJECT, public EXTLOGPEN {
6043  public:
6047  EXTPEN ( const EXTLOGPEN* lpen )
6048  {
6049  elpPenStyle = lpen->elpPenStyle;
6050  elpWidth = lpen->elpWidth;
6051  elpBrushStyle = lpen->elpBrushStyle;
6052  elpColor = lpen->elpColor;
6053  elpHatch = lpen->elpHatch;
6054  elpNumEntries = 0;
6055  elpStyleEntry[0] = 0;
6056  }
6060  OBJECTTYPE getType ( void ) const { return O_EXTPEN; }
6067  METARECORD* newEMR ( HDC dc, HGDIOBJ emf_handle )
6068  {
6069  contexts[dc] = emf_handle;
6070  return new EMREXTCREATEPEN( this, emf_handle );
6071  }
6072  };
6073 
6075 
6078  class BRUSH : public GRAPHICSOBJECT, public LOGBRUSH {
6079  public:
6083  BRUSH ( const LOGBRUSH* lbrush )
6084  {
6085  lbStyle = lbrush->lbStyle;
6086  lbColor = lbrush->lbColor;
6087  lbHatch = lbrush->lbHatch;
6088  }
6092  OBJECTTYPE getType ( void ) const { return O_BRUSH; }
6099  METARECORD* newEMR ( HDC dc, HGDIOBJ emf_handle )
6100  {
6101  contexts[dc] = emf_handle;
6102  return new EMRCREATEBRUSHINDIRECT( this, emf_handle );
6103  }
6104  };
6105 
6107 
6110  class FONT : public GRAPHICSOBJECT, public EXTLOGFONTW {
6111  public:
6115  FONT ( const LOGFONTW* lfont )
6116  {
6117  this->elfLogFont = *lfont;
6118  // There are a lot more entries in the EXTLOGFONTW structure than
6119  // the API has values for, so we invent them here
6120  memset( &elfFullName, 0, sizeof elfFullName );
6121  memset( &elfStyle, 0, sizeof elfStyle );
6122  elfVersion = ELF_VERSION;
6123  elfStyleSize = 0;
6124  elfMatch = 0;
6125  elfReserved = 0;
6126  memset( &elfVendorId, 0, sizeof elfVendorId );
6127  elfCulture = ELF_CULTURE_LATIN;
6128  memset( &elfPanose, 1, sizeof(PANOSE) );
6129  }
6133  OBJECTTYPE getType ( void ) const { return O_FONT; }
6140  METARECORD* newEMR ( HDC dc, HGDIOBJ emf_handle )
6141  {
6142  contexts[dc] = emf_handle;
6143  return new EMREXTCREATEFONTINDIRECTW( this, emf_handle );
6144  }
6145  };
6146 
6148 
6151  class PALETTE : public GRAPHICSOBJECT, public LOGPALETTE {
6152  public:
6156  PALETTE ( const LOGPALETTE* lpalette )
6157  {
6158  EMF_UNUSED(lpalette);
6159  palVersion = 0;
6160  palNumEntries = 0;
6161  PALETTEENTRY zero_entry = { 0, 0, 0, 0 };
6162  palPalEntry[0] = zero_entry;
6163  }
6167  OBJECTTYPE getType ( void ) const { return O_PALETTE; }
6174  METARECORD* newEMR ( HDC dc, HGDIOBJ emf_handle )
6175  {
6176  contexts[dc] = emf_handle;
6177  return new EMRCREATEPALETTE( this, emf_handle );
6178  }
6179  };
6180 
6182 
6186  public:
6190  EMRSETMITERLIMIT ( FLOAT limit )
6191  {
6192  emr.iType = EMR_SETMITERLIMIT;
6193  emr.nSize = sizeof( ::EMRSETMITERLIMIT );
6194  eMiterLimit = limit;
6195  }
6201  {
6202  int miter_limit;
6203  ds >> emr >> miter_limit;
6204  eMiterLimit = float(miter_limit);
6205  }
6209  bool serialize ( DATASTREAM ds )
6210  {
6211  ds << emr << (int)eMiterLimit;
6212  return true;
6213  }
6217  int size ( void ) const { return emr.nSize; }
6223  void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const
6224  {
6225  EMF_UNUSED(source);
6226  SetMiterLimit( dc, eMiterLimit, 0 );
6227  }
6228 #ifdef ENABLE_EDITING
6229 
6232  void edit ( void ) const
6233  {
6234  printf( "*SETMITERLIMIT*\n" );
6235  printf( "\teMiterLimit\t: %f\n", eMiterLimit );
6236  }
6237 #endif /* ENABLE_EDITING */
6238  };
6239 
6241 
6255  void init ( const RECT* size, LPCWSTR description_w ) {
6256 
6257  // Evidently, metafile handles are numbered from 1, so don't
6258  // ever use 0.
6259 
6260  handles.push_back( true );
6261 
6262  // Keep some of our graphics state in a header record
6263 
6264  header = new ENHMETAHEADER ( description_w );
6265  records.push_back( header );
6266 
6267  // Compute the size and position of the metafile on the "page"
6268 
6269  if ( size ) {
6270  update_frame = false;
6271 
6272  header->rclFrame.left = size->left;
6273  header->rclFrame.top = size->top;
6274  header->rclFrame.right = size->right;
6275  header->rclFrame.bottom = size->bottom;
6276 
6277  header->rclBounds.left =
6278  size->left * header->szlDevice.cx / ( header->szlMillimeters.cx * 100 );
6279  header->rclBounds.top =
6280  size->top * header->szlDevice.cy / ( header->szlMillimeters.cy * 100 );
6281  header->rclBounds.right =
6282  size->right * header->szlDevice.cx / ( header->szlMillimeters.cx * 100 );
6283  header->rclBounds.bottom =
6284  size->bottom * header->szlDevice.cy / ( header->szlMillimeters.cy * 100 );
6285  }
6286  else {
6287  update_frame = true;
6288 
6289  header->rclBounds.left = -10;
6290  header->rclBounds.top = -10;
6291  header->rclBounds.right = 10;
6292  header->rclBounds.bottom = 10;
6293 
6294  header->rclFrame.left = (LONG)floor( (float)header->rclBounds.left *
6295  header->szlMillimeters.cx * 100 / header->szlDevice.cx );
6296  header->rclFrame.top = (LONG)floor( (float)header->rclBounds.top *
6297  header->szlMillimeters.cy * 100 / header->szlDevice.cy );
6298  header->rclFrame.right = (LONG)ceil( (float)header->rclBounds.right *
6299  header->szlMillimeters.cx * 100 / header->szlDevice.cx );
6300  header->rclFrame.bottom = (LONG)ceil( (float)header->rclBounds.bottom *
6301  header->szlMillimeters.cy * 100 / header->szlDevice.cy );
6302  }
6303 
6304  // Some default graphics state (are they really, though?)
6305 
6306  SIZEL default_resolution = { RESOLUTION, RESOLUTION };
6307  resolution = default_resolution;
6308  SIZEL default_viewport_ext = { 1, 1 };
6309  viewport_ext = default_viewport_ext;
6310  POINT default_viewport_org = { 0, 0 };
6311  viewport_org = default_viewport_org;
6312  SIZEL default_window_ext = { 1, 1 };
6313  window_ext = default_window_ext;
6314  POINT default_window_org = { 0, 0 };
6315  window_org = default_window_org;
6316 
6317  min_device_point = viewport_org;
6318  max_device_point = viewport_org;
6319 
6320  pen = (PEN*)globalObjects.find( BLACK_PEN | ENHMETA_STOCK_OBJECT );
6321  brush = (BRUSH*)globalObjects.find( BLACK_BRUSH | ENHMETA_STOCK_OBJECT );
6322  font = (FONT*)globalObjects.find( DEVICE_DEFAULT_FONT | ENHMETA_STOCK_OBJECT);
6323  palette = (PALETTE*)globalObjects.find( DEFAULT_PALETTE|ENHMETA_STOCK_OBJECT);
6324 
6325  text_alignment = TA_BASELINE;
6326  text_color = RGB(0,0,0);
6327  bk_color = RGB(0xff,0xff,0xff);
6328  bk_mode = OPAQUE;
6329  polyfill_mode = ALTERNATE;
6330  map_mode = MM_TEXT;
6331  miter_limit = 10.f;
6332 
6333  handle = globalObjects.add( this );
6334  }
6335 
6336  public:
6340  ::FILE* fp;
6353  std::vector< EMF::METARECORD* > records;
6354 
6355  // Keep a small set of graphics state information
6356  SIZEL resolution;
6359  SIZEL window_ext;
6360  POINT window_org;
6364  POINT point;
6370  COLORREF text_color;
6371  COLORREF bk_color;
6372  INT bk_mode;
6374  INT map_mode;
6375  FLOAT miter_limit;
6376 
6382  std::vector< bool > handles;
6383 
6389  std::map< HGDIOBJ, HGDIOBJ > emf_handles;
6390 
6401  METAFILEDEVICECONTEXT ( FILE* fp_, const RECT* size,
6402  LPCWSTR description_w )
6403  : fp(fp_), ds( fp_ )
6404  {
6405  init( size, description_w );
6406  }
6412  {
6413  // Purge all the metarecords (if there are any) {this include the
6414  // header record, too}
6415  if ( records.size() > 0 )
6416  deleteMetafile();
6417  }
6421  OBJECTTYPE getType ( void ) const { return O_METAFILEDEVICECONTEXT; }
6426  DWORD nextHandle ( void )
6427  {
6428  for ( unsigned int i = 1; i < handles.size(); i++ ) {
6429  if ( !handles[i] ) {
6430  handles[i] = true;
6431  return i;
6432  }
6433  }
6434  handles.push_back( true );
6435  // Well, it appears that even StockObject handles count for something.
6436  // Not sure what the right value here is, then.
6437  header->nHandles = handles.size();
6438  return handles.size()-1;
6439  }
6443  void clearHandle ( DWORD handle )
6444  {
6445  handles[handle] = false;
6446  }
6452  void appendRecord ( METARECORD* record )
6453  {
6454  records.push_back( record );
6455 
6456  header->nBytes += record->size();
6457  header->nRecords++;
6458  }
6464  void appendHandle ( METARECORD* record )
6465  {
6466  records.push_back( record );
6467 
6468  header->nBytes += record->size();
6469  header->nRecords++;
6470  }
6475  void deleteMetafile ( void )
6476  {
6477  for ( std::vector<METARECORD*>::const_iterator r = records.begin();
6478  r != records.end();
6479  r++ ) {
6480  delete *r;
6481  }
6482  records.clear();
6483  }
6488  void mergePoint ( const LONG& x, const LONG& y )
6489  {
6490  POINT p;
6491  p.x = x;
6492  p.y = y;
6493  mergePoint( p );
6494  }
6499  void mergePoint( const POINT& p )
6500  {
6501  POINT device_point;
6502 
6503  // *** Note, it's possible for the global transformation matrix to
6504  // affect this too. ***
6505 
6506  device_point.x = (LONG)( (float)( p.x - window_org.x ) / window_ext.cx *
6507  viewport_ext.cx + viewport_org.x );
6508 
6509  device_point.y = (LONG)( (float)( p.y - window_org.y ) / window_ext.cy *
6510  viewport_ext.cy + viewport_org.y );
6511 
6512  // If the user didn't specify a bounding rectangle in the constructor,
6513  // compute one from this data, too.
6514  if ( device_point.x < min_device_point.x ) {
6515  min_device_point.x = device_point.x;
6516  if ( update_frame ) {
6517  header->rclBounds.left = min_device_point.x - 10;
6518  header->rclFrame.left = (LONG)floor( (float)header->rclBounds.left *
6519  header->szlMillimeters.cx * 100 / header->szlDevice.cx );
6520  }
6521  }
6522  else if ( device_point.x > max_device_point.x ) {
6523  max_device_point.x = device_point.x;
6524  if ( update_frame ) {
6525  header->rclBounds.right = max_device_point.x + 10;
6526  header->rclFrame.right = (LONG)ceil( (float)header->rclBounds.right *
6527  header->szlMillimeters.cx * 100 / header->szlDevice.cx );
6528  }
6529  }
6530 
6531  if ( device_point.y < min_device_point.y ) {
6532  min_device_point.y = device_point.y;
6533  if ( update_frame ) {
6534  header->rclBounds.top = min_device_point.y - 10;
6535  header->rclFrame.top = (LONG)floor( (float)header->rclBounds.top *
6536  header->szlMillimeters.cy * 100 / header->szlDevice.cy );
6537  }
6538  }
6539  else if ( device_point.y > max_device_point.y ) {
6540  max_device_point.y = device_point.y;
6541  if ( update_frame ) {
6542  header->rclBounds.bottom = max_device_point.y + 10;
6543  header->rclFrame.bottom = (LONG)ceil( (float)header->rclBounds.bottom *
6544  header->szlMillimeters.cy * 100 / header->szlDevice.cy );
6545  }
6546  }
6547  }
6548  };
6549 
6550 } // close EMF namespace
6551 
6552 #undef EMF_UNUSED
6553 #endif /* _LIBEMF_H */
~EMRPOLYLINE16()
Definition: libemf.h:3344
int size(void) const
Definition: libemf.h:1767
bool serialize(DATASTREAM ds)
Definition: libemf.h:4318
bool serialize(DATASTREAM ds)
Definition: libemf.h:4678
int size(void) const
Definition: libemf.h:3998
bool serialize(DATASTREAM ds)
Definition: libemf.h:5212
bool serialize(DATASTREAM ds)
Definition: libemf.h:4406
int size(void) const
Definition: libemf.h:4414
bool serialize(DATASTREAM ds)
Definition: libemf.h:5341
EMF Line To.
Definition: libemf.h:2856
EMRSETBKCOLOR(DATASTREAM &ds)
Definition: libemf.h:2430
void mergePoint(const POINT &p)
Definition: libemf.h:6499
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4004
EMRSCALEWINDOWEXTEX(LONG x_num, LONG x_den, LONG y_num, LONG y_den)
Definition: libemf.h:2068
EMF End of File Record.
Definition: libemf.h:1672
EMRENDPATH(void)
Definition: libemf.h:5736
int size(void) const
Definition: libemf.h:3581
~ENHMETAHEADER()
Definition: libemf.h:1504
EMF Set Background Color.
Definition: libemf.h:2415
EMREXTTEXTOUTW(const RECTL *bounds, DWORD graphicsMode, FLOAT xScale, FLOAT yScale, const PEMRTEXT text, LPCWSTR string, const INT *dx)
Definition: libemf.h:4810
EMRARCTO(DATASTREAM &ds)
Definition: libemf.h:3022
FONT(const LOGFONTW *lfont)
Definition: libemf.h:6115
int size(void) const
Definition: libemf.h:5984
int size(void) const
Definition: libemf.h:2711
EMRPOLYLINE16(DATASTREAM &ds)
Definition: libemf.h:3352
EMF PolyBezierTo16.
Definition: libemf.h:4242
COLORREF text_color
The current text foreground color.
Definition: libemf.h:6370
EMRPOLYBEZIERTO16(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:4275
~EMRPOLYBEZIERTO()
Definition: libemf.h:4191
bool serialize(DATASTREAM ds)
Definition: libemf.h:3159
int size(void) const
Definition: libemf.h:4326
EMF Modify World Transform.
Definition: libemf.h:2140
EMRSETVIEWPORTORGEX(DATASTREAM &ds)
Definition: libemf.h:1752
virtual ~METARECORD()
Definition: libemf.h:1018
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5601
~EMRPOLYBEZIER()
Definition: libemf.h:3983
METARECORD * newEMR(HDC dc, HGDIOBJ emf_handle)
Definition: libemf.h:6067
EMRARC(INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend)
Definition: libemf.h:2928
EMF Fill path.
Definition: libemf.h:5509
EMRSTROKEANDFILLPATH(const RECTL *bounds)
Definition: libemf.h:5626
bool serialize(DATASTREAM ds)
Definition: libemf.h:5096
EMRSETBKCOLOR(COLORREF color)
Definition: libemf.h:2420
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4420
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2451
int size(void) const
Definition: libemf.h:2302
Represent an array of points in a simple way.
Definition: libemf.h:140
EMRELLIPSE(DATASTREAM &ds)
Definition: libemf.h:3152
EMRELLIPSE(INT left, INT top, INT right, INT bottom)
Definition: libemf.h:3139
EMF Extended Text Output Wide character.
Definition: libemf.h:4795
Represent a byte array in a simple way.
Definition: libemf.h:124
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:1897
A global graphics object.
Definition: libemf.h:1255
EMRPOLYGON(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:3410
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3109
OBJECTTYPE getType(void) const
Definition: libemf.h:6133
EMRCLOSEFIGURE(DATASTREAM &ds)
Definition: libemf.h:5799
int size(void) const
Definition: libemf.h:1830
EMRSETWINDOWEXTEX(INT cx, INT cy)
Definition: libemf.h:2005
EMRPOLYLINETO(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:4363
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5545
All metafile records must be padded out to a multiple of 4 bytes.
Definition: libemf.h:204
bool serialize(DATASTREAM ds)
Definition: libemf.h:2380
bool serialize(DATASTREAM ds)
Definition: libemf.h:3095
EMRPOLYLINE16(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:3322
EMF Stroke and Fill path.
Definition: libemf.h:5621
EMF Scale Viewport Extents (ex)
Definition: libemf.h:1920
EMRSCALEVIEWPORTEXTEX(DATASTREAM &ds)
Definition: libemf.h:1941
bool update_frame
Update the frame automatically?
Definition: libemf.h:6361
EMRPOLYBEZIERTO(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:4155
int size(void) const
Definition: libemf.h:5651
EMF Set Text Color.
Definition: libemf.h:2358
bool serialize(DATASTREAM ds)
Definition: libemf.h:5861
EMRDELETEOBJECT(HGDIOBJ object)
Definition: libemf.h:2744
EMF Rectangle.
Definition: libemf.h:3067
EMRMOVETOEX(INT x, INT y)
Definition: libemf.h:2803
virtual ~GRAPHICSOBJECT()
GRAPHICSOBJECTs has a virtual destructor.
Definition: libemf.h:1258
bool serialize(DATASTREAM ds)
Definition: libemf.h:5286
EMRLINETO(DATASTREAM &ds)
Definition: libemf.h:2873
Graphics Brush.
Definition: libemf.h:6078
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:1836
EMREOF(void)
Definition: libemf.h:1677
int size(void) const
Definition: libemf.h:1567
EMF Poly Polygon.
Definition: libemf.h:3610
EMRARC(DATASTREAM &ds)
Definition: libemf.h:2946
Represent a wide (UNICODE) character string in a simple way.
Definition: libemf.h:89
void appendHandle(METARECORD *record)
Definition: libemf.h:6464
FONT * font
The current font.
Definition: libemf.h:6367
EMRPOLYGON16(const RECTL *bounds, const POINT *points, INT16 n)
Definition: libemf.h:3505
EMF Close Figure.
Definition: libemf.h:5785
bool serialize(DATASTREAM ds)
Definition: libemf.h:5976
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5110
EMF Polybezier.
Definition: libemf.h:3939
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4540
bool serialize(DATASTREAM ds)
Definition: libemf.h:5806
bool serialize(DATASTREAM ds)
Definition: libemf.h:4110
EMREXTTEXTOUTW(DATASTREAM &ds)
Definition: libemf.h:4868
bool serialize(DATASTREAM ds)
Definition: libemf.h:5479
EMRDELETEOBJECT(DATASTREAM &ds)
Definition: libemf.h:2754
int size(void) const
Definition: libemf.h:5354
EMF Set World Transform.
Definition: libemf.h:2215
int size(void) const
Definition: libemf.h:1956
bool serialize(DATASTREAM ds)
Definition: libemf.h:5698
int size(void) const
Definition: libemf.h:3103
EMF Stroke path.
Definition: libemf.h:5565
int size(void) const
Definition: libemf.h:1706
EMRMOVETOEX(DATASTREAM &ds)
Definition: libemf.h:2814
EMF MoveTo (ex)
Definition: libemf.h:2797
EMRPOLYPOLYGON16(const RECTL *bounds, const POINT16 *points, const INT *counts, UINT16 polygons)
Definition: libemf.h:3807
OBJECTTYPE getType(void) const
Definition: libemf.h:6024
int size(void) const
Definition: libemf.h:3461
EMF Set Window Extent (ex)
Definition: libemf.h:1999
int size(void) const
Definition: libemf.h:5814
EMF SetMiterLimit.
Definition: libemf.h:6185
EXTPEN(const EXTLOGPEN *lpen)
Definition: libemf.h:6047
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4212
int size(void) const
Definition: libemf.h:3253
DWORD nextHandle(void)
Definition: libemf.h:6426
EMF Poly Polygon16.
Definition: libemf.h:3756
EMRSETWORLDTRANSFORM(const XFORM *transform)
Definition: libemf.h:2220
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2644
POINT window_org
The origin of the window.
Definition: libemf.h:6360
EMRPOLYBEZIER16(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:4067
INT bk_mode
The current background mode.
Definition: libemf.h:6372
EMRSETTEXTALIGN(DATASTREAM &ds)
Definition: libemf.h:2287
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:6223
int size(void) const
Definition: libemf.h:2173
int size(void) const
Definition: libemf.h:4689
EMREOF(DATASTREAM &ds)
Definition: libemf.h:1690
int size(void) const
Definition: libemf.h:3167
static const char padding_[4]
Pad with &#39;\0&#39;s.
Definition: libemf.h:205
int size(void) const
Definition: libemf.h:5706
Represent an array of integers in a simple way.
Definition: libemf.h:172
virtual ~METAFILEDEVICECONTEXT()
Definition: libemf.h:6411
EMF Restore DC.
Definition: libemf.h:5894
EMF Pen.
Definition: libemf.h:5138
std::vector< EMF::OBJECT * >::const_iterator end(void) const
Definition: libemf.h:1307
EMRPOLYGON(DATASTREAM &ds)
Definition: libemf.h:3433
ENHMETAHEADER(LPCWSTR description=0)
Definition: libemf.h:1439
EMF Set Text Alignment.
Definition: libemf.h:2272
int size(void) const
Definition: libemf.h:2829
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5875
EMF Save DC.
Definition: libemf.h:5840
OBJECT(void)
Definition: libemf.h:1242
int size(void) const
Definition: libemf.h:3881
std::map< HDC, HGDIOBJ > contexts
Definition: libemf.h:1263
~EMRPOLYLINE()
Definition: libemf.h:3224
int size(void) const
Definition: libemf.h:2245
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:1773
bool serialize(DATASTREAM ds)
Definition: libemf.h:3872
void deleteMetafile(void)
Definition: libemf.h:6475
int size(void) const
Definition: libemf.h:2503
bool serialize(DATASTREAM ds)
Definition: libemf.h:2630
bool serialize(DATASTREAM ds)
Definition: libemf.h:2562
bool serialize(DATASTREAM ds)
Definition: libemf.h:3365
EMRPOLYLINE(DATASTREAM &ds)
Definition: libemf.h:3232
EMRSETBKMODE(DATASTREAM &ds)
Definition: libemf.h:2488
int size(void) const
Definition: libemf.h:2769
bool serialize(DATASTREAM ds)
Definition: libemf.h:3245
int size(void) const
Definition: libemf.h:2031
bool serialize(DATASTREAM ds)
Definition: libemf.h:1512
EMRPOLYBEZIER(DATASTREAM &ds)
Definition: libemf.h:3970
EMRPOLYLINETO16(const RECTL *bounds, const POINT16 *points, INT n)
Definition: libemf.h:4458
POINT point
The current point.
Definition: libemf.h:6364
bool serialize(DATASTREAM ds)
Definition: libemf.h:5531
bool serialize(DATASTREAM ds)
Definition: libemf.h:2703
const DWORD n_
Number of POINTLs in array.
Definition: libemf.h:142
EMRSETVIEWPORTORGEX(INT x, INT y)
Definition: libemf.h:1741
int size(void) const
Definition: libemf.h:3037
EMRPOLYBEZIERTO16(const RECTL *bounds, const POINT16 *points, INT n)
Definition: libemf.h:4250
EMF Begin Path.
Definition: libemf.h:5677
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2894
~EMREXTTEXTOUTW()
Definition: libemf.h:4900
BRUSH * brush
The current brush.
Definition: libemf.h:6366
int size(void) const
Definition: libemf.h:5869
bool serialize(DATASTREAM ds)
Definition: libemf.h:2237
Global GDI object.
Definition: libemf.h:1233
const int size_
Number of bytes of padding.
Definition: libemf.h:206
POINT16 *const points_
Array of POINT16s.
Definition: libemf.h:157
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2037
Represent an array of double word integers in a simple way.
Definition: libemf.h:188
~EMRPOLYLINETO()
Definition: libemf.h:4399
PEN(const LOGPEN *lpen)
Definition: libemf.h:6015
void mergePoint(const LONG &x, const LONG &y)
Definition: libemf.h:6488
UINT text_alignment
The current text alignment.
Definition: libemf.h:6369
int size(void) const
Definition: libemf.h:5487
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2179
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:1573
Extended Graphics Pen.
Definition: libemf.h:6042
EMRBEGINPATH(DATASTREAM &ds)
Definition: libemf.h:5691
EMRSTROKEPATH(const RECTL *bounds)
Definition: libemf.h:5570
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:1712
Graphics Font.
Definition: libemf.h:6110
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3259
EMF Set Window Origin (ex)
Definition: libemf.h:1798
EMRSETBKMODE(DWORD mode)
Definition: libemf.h:2478
DWORD *const dwords_
Array of double words.
Definition: libemf.h:189
EMRSETMETARGN(DATASTREAM &ds)
Definition: libemf.h:5969
EMRSETTEXTCOLOR(DATASTREAM &ds)
Definition: libemf.h:2373
virtual int size(void) const =0
EMF Extended Pen.
Definition: libemf.h:5196
~EMRPOLYBEZIER16()
Definition: libemf.h:4103
int size(void) const
Definition: libemf.h:2570
EMRSCALEVIEWPORTEXTEX(LONG x_num, LONG x_den, LONG y_num, LONG y_den)
Definition: libemf.h:1928
EMRSETPOLYFILLMODE(DWORD mode)
Definition: libemf.h:2545
EMRRESTOREDC(DATASTREAM &ds)
Definition: libemf.h:5909
CHARSTR(CHAR *const string, const int length)
Definition: libemf.h:115
EMRSETVIEWPORTEXTEX(DATASTREAM &ds)
Definition: libemf.h:1876
bool serialize(DATASTREAM ds)
Definition: libemf.h:5752
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3587
~EMRPOLYPOLYGON()
Definition: libemf.h:3657
EMRFILLPATH(DATASTREAM &ds)
Definition: libemf.h:5524
Enhanced Metafile Header Record.
Definition: libemf.h:1427
EMF PolylineTo.
Definition: libemf.h:4355
EMF Set Viewport Origin (ex)
Definition: libemf.h:1735
OBJECT * find(const HGDIOBJ handle)
Definition: libemf.cpp:213
int size(void) const
Definition: libemf.h:6217
bool serialize(DATASTREAM ds)
Definition: libemf.h:3990
const int length_
Number of WCHARs in string.
Definition: libemf.h:91
POINTLARRAY(POINTL *const points, const DWORD n)
Definition: libemf.h:148
int size(void) const
Definition: libemf.h:3694
::FILE * fp
Definition: libemf.h:6340
EMRRECTANGLE(INT left, INT top, INT right, INT bottom)
Definition: libemf.h:3075
EMRPOLYPOLYGON16(const RECTL *bounds, const POINT *points, const INT *counts, UINT polygons)
Definition: libemf.h:3766
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3700
POINT viewport_org
The origin of the viewport.
Definition: libemf.h:6358
INT polyfill_mode
The current polygon fill mode.
Definition: libemf.h:6373
std::map< HGDIOBJ, HGDIOBJ > emf_handles
Definition: libemf.h:6389
int size(void) const
Definition: libemf.h:2888
~EMRPOLYPOLYGON16()
Definition: libemf.h:3844
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2835
void clearHandle(DWORD handle)
Definition: libemf.h:6443
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5930
PEN * pen
The current pen.
Definition: libemf.h:6365
FLOAT miter_limit
The current miter length limit.
Definition: libemf.h:6375
POINT min_device_point
The lft/top-most painted point in device units.
Definition: libemf.h:6362
EMF Set Viewport Extents (ex)
Definition: libemf.h:1859
bool serialize(DATASTREAM ds)
Definition: libemf.h:1759
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3173
EMRPOLYLINE16(const RECTL *bounds, const POINT16 *points, INT n)
Definition: libemf.h:3297
const int length_
Number of single byte characers in array.
Definition: libemf.h:109
bool serialize(DATASTREAM ds)
Definition: libemf.h:5643
bool serialize(DATASTREAM ds)
Definition: libemf.h:6209
COLORREF bk_color
The current background color.
Definition: libemf.h:6371
bool serialize(DATASTREAM ds)
Definition: libemf.h:2437
Represent an ASCII character string in a simple way.
Definition: libemf.h:107
EMRSETPOLYFILLMODE(DATASTREAM &ds)
Definition: libemf.h:2555
bool unserialize(DATASTREAM ds)
Definition: libemf.h:1529
EMF Arc To.
Definition: libemf.h:2991
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2251
EMREXTTEXTOUTA(DATASTREAM &ds)
Definition: libemf.h:4638
Represent an array of 16-bit point in a simple way.
Definition: libemf.h:156
std::vector< EMF::OBJECT * >::const_iterator begin(void) const
Definition: libemf.h:1302
METAFILEDEVICECONTEXT(FILE *fp_, const RECT *size, LPCWSTR description_w)
Definition: libemf.h:6401
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3043
EMF Ellipse.
Definition: libemf.h:3130
void appendRecord(METARECORD *record)
Definition: libemf.h:6452
PADDING(const int size)
Definition: libemf.h:211
int size(void) const
Definition: libemf.h:5760
EMRSETPIXELV(INT x, INT y, COLORREF color)
Definition: libemf.h:5077
int size(void) const
Definition: libemf.h:1891
EMRSETWORLDTRANSFORM(DATASTREAM &ds)
Definition: libemf.h:2230
bool serialize(DATASTREAM ds)
Definition: libemf.h:3029
std::vector< EMF::METARECORD * > records
Definition: libemf.h:6353
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3379
EMF Set Mapping Mode.
Definition: libemf.h:2608
EMRSAVEDC(DATASTREAM &ds)
Definition: libemf.h:5854
EMRSETMAPMODE(DWORD mode)
Definition: libemf.h:2613
POINT max_device_point
The rgt/btm-most painted point in device units.
Definition: libemf.h:6363
EMRPOLYLINETO16(DATASTREAM &ds)
Definition: libemf.h:4506
~EMRPOLYBEZIERTO16()
Definition: libemf.h:4311
EMRSTROKEPATH(DATASTREAM &ds)
Definition: libemf.h:5580
EMRSTROKEANDFILLPATH(DATASTREAM &ds)
Definition: libemf.h:5636
The base class of all metafile records.
Definition: libemf.h:991
int size(void) const
Definition: libemf.h:4534
~EMRPOLYLINETO16()
Definition: libemf.h:4519
~EMRPOLYGON()
Definition: libemf.h:3446
bool serialize(DATASTREAM ds)
Definition: libemf.h:2495
EMRPOLYPOLYGON(const RECTL *bounds, const POINT *points, const INT *counts, UINT polygons)
Definition: libemf.h:3620
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4695
PALETTE * palette
The current palette.
Definition: libemf.h:6368
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:1962
METARECORD * newEMR(HDC dc, HGDIOBJ emf_handle)
Definition: libemf.h:6031
CHAR *const string_
Array of single byte characters.
Definition: libemf.h:108
POINT16ARRAY(POINT16 *const points, const DWORD n)
Definition: libemf.h:164
EMF Polybezier16.
Definition: libemf.h:4034
METARECORD * newEMR(HDC dc, HGDIOBJ emf_handle)
Definition: libemf.h:6099
int size(void) const
Definition: libemf.h:5539
EMRPOLYBEZIER(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:3947
int size(void) const
Definition: libemf.h:5162
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5990
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2394
EMRMODIFYWORLDTRANSFORM(const XFORM *transform, DWORD mode)
Definition: libemf.h:2147
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3467
int size(void) const
Definition: libemf.h:4206
DATASTREAM ds
Definition: libemf.h:6345
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2967
EMRPOLYGON16(DATASTREAM &ds)
Definition: libemf.h:3553
int size(void) const
Definition: libemf.h:2445
METARECORD * newEMR(HDC dc, HGDIOBJ emf_handle)
Definition: libemf.h:6174
EMRSETPIXELV(DATASTREAM &ds)
Definition: libemf.h:5089
HGDIOBJ handle
Definition: libemf.h:1235
EMRPOLYPOLYGON(DATASTREAM &ds)
Definition: libemf.h:3666
EMRPOLYBEZIERTO(DATASTREAM &ds)
Definition: libemf.h:4178
bool serialize(DATASTREAM ds)
Definition: libemf.h:2088
EMRSELECTOBJECT(DATASTREAM &ds)
Definition: libemf.h:2696
const DWORD n_
Number of double words in array.
Definition: libemf.h:190
EMRSELECTOBJECT(HGDIOBJ object)
Definition: libemf.h:2686
EMRSETTEXTCOLOR(COLORREF color)
Definition: libemf.h:2363
~EMRPOLYGON16()
Definition: libemf.h:3566
OBJECTTYPE getType(void) const
Definition: libemf.h:6167
METARECORD * newEMR(HDC dc, HGDIOBJ emf_handle)
Definition: libemf.h:6140
EMF Set the Polygon Fill Mode.
Definition: libemf.h:2540
EMRMODIFYWORLDTRANSFORM(DATASTREAM &ds)
Definition: libemf.h:2158
EMF PolylineTo16.
Definition: libemf.h:4450
BYTE *const array_
Array of unsigned bytes.
Definition: libemf.h:125
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5712
Definition: libemf.cpp:26
EMF Palette.
Definition: libemf.h:5463
Support different endian modes when reading and writing the metafile.
Definition: libemf.h:222
bool serialize(DATASTREAM ds)
Definition: libemf.h:1883
EMRPOLYLINETO16(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:4483
bool serialize(DATASTREAM ds)
Definition: libemf.h:2023
SIZEL window_ext
The extent of the window.
Definition: libemf.h:6359
EMRCLOSEFIGURE(void)
Definition: libemf.h:5790
bool serialize(DATASTREAM ds)
Definition: libemf.h:2953
int size(void) const
Definition: libemf.h:4919
EMF Set Background Mode.
Definition: libemf.h:2473
EMRARCTO(INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend)
Definition: libemf.h:3004
bool serialize(DATASTREAM ds)
Definition: libemf.h:5154
bool serialize(DATASTREAM ds)
Definition: libemf.h:5587
EMRPOLYBEZIER16(const RECTL *bounds, const POINT16 *points, INT n)
Definition: libemf.h:4042
OBJECTTYPE getType(void) const
Definition: libemf.h:6092
DWORDARRAY(DWORD *const dwords, const DWORD n)
Definition: libemf.h:196
int size(void) const
Definition: libemf.h:4118
bool serialize(DATASTREAM ds)
Definition: libemf.h:3573
SIZEL viewport_ext
The extent of the viewport.
Definition: libemf.h:6357
const int n_
Number of bytes in array.
Definition: libemf.h:126
EMRSETWINDOWEXTEX(DATASTREAM &ds)
Definition: libemf.h:2016
EMRPOLYPOLYGON16(DATASTREAM &ds)
Definition: libemf.h:3853
int size(void) const
Definition: libemf.h:3373
WCHAR *const string_
String of WCHARs.
Definition: libemf.h:90
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4124
EMRPOLYGON16(const RECTL *bounds, const POINT16 *points, INT16 n)
Definition: libemf.h:3530
INT *const ints_
Array of ints.
Definition: libemf.h:173
EMRRESTOREDC(INT n)
Definition: libemf.h:5899
EMF Polyline.
Definition: libemf.h:3194
INTARRAY(INT *const ints, const DWORD n)
Definition: libemf.h:180
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5657
BYTEARRAY(BYTE *const array, const int n)
Definition: libemf.h:132
Graphics Device Context.
Definition: libemf.h:6247
EMRENDPATH(DATASTREAM &ds)
Definition: libemf.h:5745
int size(void) const
Definition: libemf.h:5220
EMF Extended Text Output ASCII.
Definition: libemf.h:4565
const DWORD n_
Number of POINT16s in array.
Definition: libemf.h:158
Graphics Pen.
Definition: libemf.h:6010
EMRLINETO(INT x, INT y)
Definition: libemf.h:2862
int size(void) const
Definition: libemf.h:2096
EMRSETMITERLIMIT(FLOAT limit)
Definition: libemf.h:6190
bool serialize(DATASTREAM ds)
Definition: libemf.h:1698
int size(void) const
Definition: libemf.h:5924
int size(void) const
Definition: libemf.h:2638
EMRRECTANGLE(DATASTREAM &ds)
Definition: libemf.h:3088
bool serialize(DATASTREAM ds)
Definition: libemf.h:1948
bool serialize(DATASTREAM ds)
Definition: libemf.h:4198
EMRSETMAPMODE(DATASTREAM &ds)
Definition: libemf.h:2623
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2576
bool serialize(DATASTREAM ds)
Definition: libemf.h:2880
~EMREXTTEXTOUTA()
Definition: libemf.h:4670
bool serialize(DATASTREAM ds)
Definition: libemf.h:3453
EMRSCALEWINDOWEXTEX(DATASTREAM &ds)
Definition: libemf.h:2081
bool serialize(DATASTREAM ds)
Definition: libemf.h:3685
EMF Scale Window Extents (ex)
Definition: libemf.h:2060
EMF Polyline16.
Definition: libemf.h:3289
EMRBEGINPATH(void)
Definition: libemf.h:5682
SIZEL resolution
The resolution in DPI of the reference DC.
Definition: libemf.h:6356
EMRSETVIEWPORTEXTEX(INT cx, INT cy)
Definition: libemf.h:1865
BRUSH(const LOGBRUSH *lbrush)
Definition: libemf.h:6083
INT map_mode
The current mapping mode.
Definition: libemf.h:6374
POINTL *const points_
Array of POINTLs.
Definition: libemf.h:141
EMF Font.
Definition: libemf.h:5325
OBJECTTYPE getType(void) const
Definition: libemf.h:6421
EMF Select Object.
Definition: libemf.h:2681
bool serialize(DATASTREAM ds)
Definition: libemf.h:2761
OBJECTTYPE getType(void) const
Definition: libemf.h:6060
EMRSAVEDC(void)
Definition: libemf.h:5845
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4332
int size(void) const
Definition: libemf.h:5595
EMF Arc.
Definition: libemf.h:2915
EMRSETMETARGN(void)
Definition: libemf.h:5960
EMRPOLYLINETO(DATASTREAM &ds)
Definition: libemf.h:4386
EMRSETTEXTALIGN(UINT mode)
Definition: libemf.h:2277
int size(void) const
Definition: libemf.h:2388
bool serialize(DATASTREAM ds)
Definition: libemf.h:5916
bool serialize(DATASTREAM ds)
Definition: libemf.h:1822
EMF Set Pixel.
Definition: libemf.h:5070
int size(void) const
Definition: libemf.h:5104
DATASTREAM(::FILE *fp=0)
Definition: libemf.h:233
EMF Filled Polygon16.
Definition: libemf.h:3497
EMRPOLYBEZIERTO16(DATASTREAM &ds)
Definition: libemf.h:4298
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2509
WCHARSTR(WCHAR *const string, const int length)
Definition: libemf.h:97
EMRPOLYLINE(const RECTL *bounds, const POINT *points, INT n)
Definition: libemf.h:3202
EMF Filled Polygon.
Definition: libemf.h:3402
EMF PolyBezierTo.
Definition: libemf.h:4147
Definition: libemf.h:1278
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:4925
EMF Brush.
Definition: libemf.h:5270
EMRFILLPATH(const RECTL *bounds)
Definition: libemf.h:5514
EMRPOLYBEZIER16(DATASTREAM &ds)
Definition: libemf.h:4090
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5766
EMREXTTEXTOUTA(const RECTL *bounds, DWORD graphicsMode, FLOAT xScale, FLOAT yScale, const PEMRTEXT text, LPCSTR string, const INT *dx)
Definition: libemf.h:4580
bool serialize(DATASTREAM ds)
Definition: libemf.h:4908
void setStream(::FILE *fp)
Definition: libemf.h:238
const DWORD n_
Number of ints in array.
Definition: libemf.h:174
int size(void) const
Definition: libemf.h:5294
EMRSETMITERLIMIT(DATASTREAM &ds)
Definition: libemf.h:6200
EMF Delete Object.
Definition: libemf.h:2739
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2308
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:3887
bool serialize(DATASTREAM ds)
Definition: libemf.h:4526
EMRSETWINDOWORGEX(DATASTREAM &ds)
Definition: libemf.h:1815
EMRSETWINDOWORGEX(INT x, INT y)
Definition: libemf.h:1804
bool serialize(DATASTREAM ds)
Definition: libemf.h:2821
ENHMETAHEADER * header
Definition: libemf.h:6349
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:5820
bool serialize(DATASTREAM ds)
Definition: libemf.h:2165
EMF Set Meta Region.
Definition: libemf.h:5955
void execute(METAFILEDEVICECONTEXT *source, HDC dc) const
Definition: libemf.h:2102
HGDIOBJ add(OBJECT *object)
Definition: libemf.cpp:180
std::vector< bool > handles
Definition: libemf.h:6382
EMF End Path.
Definition: libemf.h:5731
int size(void) const
Definition: libemf.h:2961
bool serialize(DATASTREAM ds)
Definition: libemf.h:2294
PALETTE(const LOGPALETTE *lpalette)
Definition: libemf.h:6156
Graphics Palette.
Definition: libemf.h:6151