---

libemf.h

/* -*- c++ -*-
 * EMF: A library for generating ECMA-234 Enhanced Metafiles
 * Copyright (C) 2002 lignum Computing, Inc. <libemf@lignumcomputing.com>
 * $Id: libemf.h,v 1.6 2002/01/28 18:06:45 allen Exp $
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#ifndef _LIBEMF_H
#define _LIBEMF_H 1

#include <cmath>
#include <vector>
#include <map>
#include <functional>
#include <algorithm>

#include <config.h>
#include <emf.h>

#include <wine/w16.h>

namespace EMF {
  const int XMAX_PIXELS = 1024; /*(INT_MAX)*/
  const int YMAX_PIXELS = 768; /*(INT_MAX)*/
  const int XMAX_MM = 320;
  const int YMAX_MM = 240;
  const int RESOLUTION = 96;
  static inline int ROUND_TO_LONG ( int n ) { return ((n+3)/4)*4; }


  struct WCHARSTR {
    WCHAR *const string_;       
    const int length_;          

    WCHARSTR ( WCHAR *const string, const int length )
      : string_( string ), length_( length ) {}
  };


  struct CHARSTR {
    CHAR *const string_;        
    const int length_;          

    CHARSTR ( CHAR *const string, const int length )
      : string_( string ), length_( length ) {}
  };


  struct BYTEARRAY {
    BYTE *const array_;         
    const int n_;               

    BYTEARRAY ( BYTE *const array, const int n )
      : array_( array ), n_( n ) {}
  };


  struct POINTLARRAY {
    POINTL *const points_;      
    const DWORD n_;             

    POINTLARRAY ( POINTL *const points, const DWORD n )
      : points_( points ), n_( n ) {}
  };


  struct POINT16ARRAY {
    POINT16 *const points_;     
    const DWORD n_;             

    POINT16ARRAY ( POINT16 *const points, const DWORD n )
      : points_( points ), n_( n ) {}
  };


  struct INTARRAY {
    INT *const ints_;           
    const DWORD n_;             

    INTARRAY ( INT *const ints, const DWORD n )
      : ints_( ints ), n_( n ) {}
  };


  struct DWORDARRAY {
    DWORD *const dwords_;       
    const DWORD n_;             

    DWORDARRAY ( DWORD *const dwords, const DWORD n )
      : dwords_( dwords ), n_( n ) {}
  };


  struct PADDING {
    static const char padding_[4]; 
    const int size_;            

    PADDING ( const int size ) : size_( size ) {}
  };
  

  class DATASTREAM {
    bool swap_;
    ::FILE* fp_;

    static bool bigEndian ( void );
  public:
    DATASTREAM ( ::FILE* fp = 0 ) : swap_( bigEndian() ), fp_( fp ) {}
    void setStream ( ::FILE* fp ) { fp_ = fp; }
    DATASTREAM& operator<< ( const BYTE& byte )
    {
      fwrite( &byte, sizeof(BYTE), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( BYTE& byte )
    {
      fread( &byte, sizeof(BYTE), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const WORD& word )
    {
      if ( swap_ ) {
        unsigned char const * p = (unsigned char const*)&word;
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &word, sizeof(WORD), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( WORD& word )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&word;
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &word, sizeof(WORD), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const INT16& word )
    {
      if ( swap_ ) {
        unsigned char const * p = (unsigned char const*)&word;
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &word, sizeof(INT16), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( INT16& word )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&word;
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &word, sizeof(INT16), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const DWORD& dword )
    {
      if ( swap_ ) {
        unsigned char const* p = (unsigned char const*)&dword;
        fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &dword, sizeof(DWORD), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( DWORD& dword )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&dword;
        fread( &p[3], sizeof(unsigned char), 1, fp_ );
        fread( &p[2], sizeof(unsigned char), 1, fp_ );
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &dword, sizeof(DWORD), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const LONG& long_ )
    {
      if ( swap_ ) {
        unsigned char const* p = (unsigned char const*)&long_;
        fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &long_, sizeof(LONG), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( LONG& long_ )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&long_;
        fread( &p[3], sizeof(unsigned char), 1, fp_ );
        fread( &p[2], sizeof(unsigned char), 1, fp_ );
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &long_, sizeof(LONG), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const INT& int_ )
    {
      if ( swap_ ) {
        unsigned char const* p = (unsigned char const*)&int_;
        fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &int_, sizeof(INT), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( INT& int_ )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&int_;
        fread( &p[3], sizeof(unsigned char), 1, fp_ );
        fread( &p[2], sizeof(unsigned char), 1, fp_ );
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &int_, sizeof(INT), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const UINT& uint )
    {
      if ( swap_ ) {
        unsigned char const* p = (unsigned char const*)&uint;
        fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &uint, sizeof(UINT), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( UINT& uint )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&uint;
        fread( &p[3], sizeof(unsigned char), 1, fp_ );
        fread( &p[2], sizeof(unsigned char), 1, fp_ );
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &uint, sizeof(UINT), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const FLOAT& float_ )
    {
      if ( swap_ ) {
        unsigned char const* p = (unsigned char const*)&float_;
        fwrite( &p[3], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[2], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[1], sizeof(unsigned char), 1, fp_ );
        fwrite( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fwrite( &float_, sizeof(FLOAT), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( FLOAT& float_ )
    {
      if ( swap_ ) {
        unsigned char* p = (unsigned char*)&float_;
        fread( &p[3], sizeof(unsigned char), 1, fp_ );
        fread( &p[2], sizeof(unsigned char), 1, fp_ );
        fread( &p[1], sizeof(unsigned char), 1, fp_ );
        fread( &p[0], sizeof(unsigned char), 1, fp_ );
      }
      else
        fread( &float_, sizeof(FLOAT), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const PADDING& padding )
    {
      if ( padding.size_ != 0 )
        fwrite( &padding.padding_, sizeof(CHAR), padding.size_, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const RECTL& rectl )
    {
      *this << rectl.left << rectl.top << rectl.right << rectl.bottom;
      return *this;
    }
    DATASTREAM& operator>> ( RECTL& rectl )
    {
      *this >> rectl.left >> rectl.top >> rectl.right >> rectl.bottom;
      return *this;
    }
    DATASTREAM& operator<< ( const SIZEL& sizel )
    {
      *this << sizel.cx << sizel.cy;
      return *this;
    }
    DATASTREAM& operator>> ( SIZEL& sizel )
    {
      *this >> sizel.cx >> sizel.cy;
      return *this;
    }
    DATASTREAM& operator<< ( const WCHARSTR& wcharstr )
    {
      for ( int i = 0; i < wcharstr.length_; i++ )
        *this << wcharstr.string_[i];
      return *this;
    }
    DATASTREAM& operator>> ( WCHARSTR& wcharstr )
    {
      for ( int i = 0; i < wcharstr.length_; i++ )
        *this >> wcharstr.string_[i];
      return *this;
    }
    DATASTREAM& operator<< ( const CHARSTR& charstr )
    {
      fwrite( charstr.string_, sizeof(CHAR), charstr.length_, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( CHARSTR& charstr )
    {
      fread( charstr.string_, sizeof(CHAR), charstr.length_, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const ::EMR& emr )
    {
      *this << emr.iType << emr.nSize;
      return *this;
    }
    DATASTREAM& operator>> ( ::EMR& emr )
    {
      *this >> emr.iType >> emr.nSize;
      return *this;
    }
    DATASTREAM& operator<< ( const POINT& point )
    {
      *this << point.x << point.y;
      return *this;
    }
    DATASTREAM& operator>> ( POINT& point )
    {
      *this >> point.x >> point.y;
      return *this;
    }
    DATASTREAM& operator<< ( const POINTL& pointl )
    {
      *this << pointl.x << pointl.y;
      return *this;
    }
    DATASTREAM& operator>> ( POINTL& pointl )
    {
      *this >> pointl.x >> pointl.y;
      return *this;
    }
    DATASTREAM& operator<< ( const POINT16& point )
    {
      *this << point.x << point.y;
      return *this;
    }
    DATASTREAM& operator>> ( POINT16& point )
    {
      *this >> point.x >> point.y;
      return *this;
    }
    DATASTREAM& operator<< ( const XFORM& xform )
    {
      *this << xform.eM11 << xform.eM12 << xform.eM21 << xform.eM22
            << xform.eDx << xform.eDy;
      return *this;
    }
    DATASTREAM& operator>> ( XFORM& xform )
    {
      *this >> xform.eM11 >> xform.eM12 >> xform.eM21 >> xform.eM22
            >> xform.eDx >> xform.eDy;
      return *this;
    }
    DATASTREAM& operator<< ( const BYTEARRAY& array )
    {
      fwrite( array.array_, sizeof(BYTE), array.n_, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( BYTEARRAY& array )
    {
      fread( array.array_, sizeof(BYTE), array.n_, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const POINTLARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this << array.points_[i];
      return *this;
    }
    DATASTREAM& operator>> ( POINTLARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this >> array.points_[i];
      return *this;
    }
    DATASTREAM& operator<< ( const POINT16ARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this << array.points_[i];
      return *this;
    }
    DATASTREAM& operator>> ( POINT16ARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this >> array.points_[i];
      return *this;
    }
    DATASTREAM& operator<< ( const INTARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this << array.ints_[i];
      return *this;
    }
    DATASTREAM& operator>> ( INTARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this >> array.ints_[i];
      return *this;
    }
    DATASTREAM& operator<< ( const DWORDARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this << array.dwords_[i];
      return *this;
    }
    DATASTREAM& operator>> ( DWORDARRAY& array )
    {
      for ( unsigned int i = 0; i < array.n_; i++ )
        *this >> array.dwords_[i];
      return *this;
    }
    DATASTREAM& operator<< ( const ::EMRTEXT& text )
    {
      *this << text.ptlReference << text.nChars << text.offString << text.fOptions
         << text.rcl << text.offDx;
      return *this;
    }
    DATASTREAM& operator>> ( ::EMRTEXT& text )
    {
      *this >> text.ptlReference >> text.nChars >> text.offString >> text.fOptions
            >> text.rcl >> text.offDx;
      return *this;
    }
    DATASTREAM& operator<< ( const LOGPEN& pen )
    {
      *this << pen.lopnStyle << pen.lopnWidth << pen.lopnColor;
      return *this;
    }
    DATASTREAM& operator>> ( LOGPEN& pen )
    {
      *this >> pen.lopnStyle >> pen.lopnWidth >> pen.lopnColor;
      return *this;
    }
    DATASTREAM& operator<< ( const EXTLOGPEN& pen )
    {
      // *** How big is this structure if there are no style entries? ***
      *this << pen.elpPenStyle << pen.elpWidth << pen.elpBrushStyle << pen.elpColor
            << pen.elpHatch << pen.elpNumEntries;
      return *this;
    }
    DATASTREAM& operator>> ( EXTLOGPEN& pen )
    {
      // *** How big is this structure if there are no style entries? ***
      *this >> pen.elpPenStyle >> pen.elpWidth >> pen.elpBrushStyle >> pen.elpColor
            >> pen.elpHatch >> pen.elpNumEntries;
      return *this;
    }
    DATASTREAM& operator<< ( const LOGBRUSH& brush )
    {
      *this << brush.lbStyle << brush.lbColor << brush.lbHatch;
      return *this;
    }
    DATASTREAM& operator>> ( LOGBRUSH& brush )
    {
      *this >> brush.lbStyle >> brush.lbColor >> brush.lbHatch;
      return *this;
    }
    DATASTREAM& operator<< ( const LOGFONTW& font )
    {
      *this << font.lfHeight << font.lfWidth << font.lfEscapement
            << font.lfOrientation << font.lfWeight << font.lfItalic
            << font.lfUnderline << font.lfStrikeOut << font.lfCharSet
            << font.lfOutPrecision << font.lfClipPrecision << font.lfQuality
            << font.lfPitchAndFamily
            << WCHARSTR( const_cast<WCHAR*const>(font.lfFaceName), LF_FACESIZE );
      return *this;
    }
    DATASTREAM& operator>> ( LOGFONTW& font )
    {
      WCHARSTR wFaceName( font.lfFaceName, LF_FACESIZE );

      *this >> font.lfHeight >> font.lfWidth >> font.lfEscapement
            >> font.lfOrientation >> font.lfWeight >> font.lfItalic
            >> font.lfUnderline >> font.lfStrikeOut >> font.lfCharSet
            >> font.lfOutPrecision >> font.lfClipPrecision >> font.lfQuality
            >> font.lfPitchAndFamily
            >> wFaceName;
      return *this;
    }
    DATASTREAM& operator<< ( const PANOSE& panose )
    {
      fwrite( &panose, sizeof(PANOSE), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator>> ( PANOSE& panose )
    {
      fread( &panose, sizeof(PANOSE), 1, fp_ );
      return *this;
    }
    DATASTREAM& operator<< ( const EXTLOGFONTW& font )
    {
      *this << font.elfLogFont
            << WCHARSTR( const_cast<WCHAR*const>(font.elfFullName),
                         LF_FULLFACESIZE )
            << WCHARSTR( const_cast<WCHAR*const>(font.elfStyle), LF_FACESIZE )
            << font.elfVersion << font.elfStyleSize << font.elfMatch
            << font.elfReserved
            << BYTEARRAY( const_cast<BYTE*const>(font.elfVendorId),
                          ELF_VENDOR_SIZE )
            << font.elfCulture << font.elfPanose;
      return *this;
    }
    DATASTREAM& operator>> ( EXTLOGFONTW& font )
    {
      WCHARSTR wFullName( font.elfFullName, LF_FULLFACESIZE );
      WCHARSTR wStyle( font.elfStyle, LF_FACESIZE );
      BYTEARRAY bVendorId( font.elfVendorId, ELF_VENDOR_SIZE );
      *this >> font.elfLogFont
            >> wFullName >> wStyle
            >> font.elfVersion >> font.elfStyleSize >> font.elfMatch
            >> font.elfReserved >> bVendorId
            >> font.elfCulture >> font.elfPanose;
      return *this;
    }
    DATASTREAM& operator<< ( const LOGPALETTE& palette )
    {
      // *** How big is this structure if the palette is empty? ***
      *this << palette.palVersion << palette.palNumEntries;
      return *this;
    }
    DATASTREAM& operator>> ( LOGPALETTE& palette )
    {
      // *** How big is this structure if the palette is empty? ***
      *this >> palette.palVersion >> palette.palNumEntries;
      return *this;
    }
  };

  class METAFILEDEVICECONTEXT;


  class METARECORD {
  public:
    virtual void execute ( METAFILEDEVICECONTEXT* source, HDC dc ) const = 0;
    virtual bool serialize ( DATASTREAM ds ) = 0;
    virtual int size ( void ) const = 0;
    virtual ~METARECORD( ) { }
#ifdef ENABLE_EDITING

    virtual void edit ( void ) const {}
#endif
  };

#ifdef ENABLE_EDITING
  /* Miscellaneous editing routines */
  inline void edit_rectl ( const char* tag, const RECTL& rectl )
  {
    printf( "\t%s\t: (%ld, %ld) - (%ld, %ld)\n", tag, rectl.left, rectl.top,
            rectl.right, rectl.bottom );
  }

  inline void edit_xform ( const char* tag, const XFORM& xform )
  {
    printf( "\t%s.eM11\t: %f\n", tag, xform.eM11 );
    printf( "\t%s.eM12\t: %f\n", tag, xform.eM12 );
    printf( "\t%s.eM21\t: %f\n", tag, xform.eM21 );
    printf( "\t%s.eM22\t: %f\n", tag, xform.eM22 );
    printf( "\t%s.eDx\t: %f\n", tag, xform.eDx );
    printf( "\t%s.eDy\t: %f\n", tag, xform.eDy );
  }

  inline void edit_color ( const char* tag, const COLORREF& color )
  {
    printf( "\t%s\t: R(0x%02lx) G(0x%02lx) B(0x%02lx)\n", tag,
            GetRValue( color ), GetGValue( color ), GetBValue( color ) );
  }

  inline void edit_sizel ( const char* tag, const SIZEL& size )
  {
    printf( "\t%s\t: (%ld, %ld)\n", tag, size.cx, size.cy );
  }

  inline void edit_pointl ( const char* tag, const POINTL& point )
  {
    printf( "\t%s\t: (%ld, %ld)\n", tag, point.x, point.y );
  }

  inline void edit_pointlarray ( const char* tag, const DWORD cptl,
                                  const POINTL* points )
  {
    printf( "\tcptl%s\t: %ld\n", tag, cptl );
    printf( "\taptl%s\t: ", tag );
    if ( cptl > 0 )
      printf( "%ld, %ld\n", points[0].x, points[0].y );
    else
      puts( "" );
    for ( DWORD i = 1; i < cptl; i++ )
      printf( "\t\t%s  %ld, %ld\n", tag, points[i].x, points[i].y );
  }

  inline void edit_point16array ( const char* tag, const unsigned int cpts,
                                  const POINT16* points )
  {
    printf( "\tcpts%s\t: %d\n", tag, cpts );
    printf( "\tapts%s\t: ", tag );
    if ( cpts > 0 )
      printf( "%d, %d\n", points[0].x, points[0].y );
    else
      puts( "" );
    for ( unsigned int i = 1; i < cpts; i++ )
      printf( "\t\t%s  %d, %d\n", tag, points[i].x, points[i].y );
  }

  inline void edit_pen_style ( const char* tag, DWORD style )
  {
    printf( "\t%s\t: ", tag );
    switch ( style & PS_STYLE_MASK ) {
    case PS_SOLID: printf( "PS_SOLID" ); break;
    case PS_DASH: printf( "PS_DASH" ); break;
    case PS_DOT: printf( "PS_DOT" ); break;
    case PS_DASHDOT: printf( "PS_DASHDOT" ); break;
    case PS_DASHDOTDOT: printf( "PS_DASHDOTDOT" ); break;
    case PS_NULL: printf( "PS_NULL" ); break;
    case PS_INSIDEFRAME: printf( "PS_INSIDEFRAME" ); break;
    case PS_USERSTYLE: printf( "PS_USERSTYLE" ); break;
    case PS_ALTERNATE: printf( "PS_ALTERNATE" ); break;
    }
    switch ( style & PS_ENDCAP_MASK ) {
    case PS_ENDCAP_ROUND: printf( " | PS_ENDCAP_ROUND" ); break;
    case PS_ENDCAP_SQUARE: printf( " | PS_ENDCAP_SQUARE" ); break;
    case PS_ENDCAP_FLAT: printf( " | PS_ENDCAP_FLAT" ); break;
    }
    switch ( style & PS_JOIN_MASK ) {
    case PS_JOIN_ROUND: printf( " | PS_JOIN_ROUND" ); break;
    case PS_JOIN_BEVEL: printf( " | PS_JOIN_BEVEL" ); break;
    case PS_JOIN_MITER: printf( " | PS_JOIN_MITER" ); break;
    }
    switch ( style & PS_TYPE_MASK ) {
    case PS_COSMETIC: printf( " | PS_COSMETIC" ); break;
    case PS_GEOMETRIC: printf( " | PS_GEOMETRIC" ); break;
    }
    printf( "\n" );
  }

  inline void edit_brush_style ( const char* tag, DWORD style )
  {
    printf( "\t%s\t: ", tag );
    switch ( style ) {
    case BS_SOLID: printf( "BS_SOLID" ); break;
    case BS_NULL: printf( "BS_NULL" ); break;
    case BS_HATCHED: printf( "BS_HATCHED" ); break;
    case BS_PATTERN: printf( "BS_PATTERN" ); break;
    case BS_INDEXED: printf( "BS_INDEXED" ); break;
    case BS_DIBPATTERN: printf( "BS_DIBPATTERN" ); break;
    case BS_DIBPATTERNPT: printf( "BS_DIBPATTERNPT" ); break;
    case BS_PATTERN8X8: printf( "BS_PATTERN8X8" ); break;
    case BS_DIBPATTERN8X8: printf( "BS_DIBPATTERN8X8" ); break;
    case BS_MONOPATTERN: printf( "BS_DIBPATTERN8X8" ); break;
    default: printf( "unknown(%ld)", style );
    }
    printf( "\n" );
  }

  inline void edit_brush_hatch ( const char* tag, DWORD hatch )
  {
    printf( "\t%s\t: ", tag );
    switch ( hatch ) {
    case HS_HORIZONTAL: printf( "HS_HORIZONTAL" ); break;
    case HS_VERTICAL: printf( "HS_VERTICAL" ); break;
    case HS_FDIAGONAL: printf( "HS_FDIAGONAL" ); break;
    case HS_BDIAGONAL: printf( "HS_BDIAGONAL" ); break;
    case HS_CROSS: printf( "HS_CROSS" ); break;
    case HS_DIAGCROSS: printf( "HS_DIAGCROSS" ); break;
    default: printf( "unknown(%ld)", hatch );
    }
    printf( "\n" );
  }
#endif

  enum OBJECTTYPE { O_METAFILEDEVICECONTEXT     = OBJ_METADC,
                    O_FONT                      = OBJ_FONT,
                    O_PEN                       = OBJ_PEN,
                    O_EXTPEN                    = OBJ_EXTPEN,
                    O_BRUSH                     = OBJ_BRUSH,
                    O_PALETTE                   = OBJ_PAL };
#if 0

  static char* typStr ( OBJECTTYPE type )
  {
    switch (type) {
    case O_METAFILEDEVICECONTEXT:
      return "metafile device context";
    case O_FONT:
      return "font";
    case O_PEN:
      return "pen";
    case O_EXTPEN:
      return "extended pen";
    case O_BRUSH:
      return "brush";
    case O_PALETTE:
      return "palette";
    }
    return "unknown object";
  }
#endif


  class OBJECT {
  public:
    HGDIOBJ handle;             

    virtual ~OBJECT () {}
    OBJECT ( void ) : handle( 0 ) {}
    virtual OBJECTTYPE getType ( void ) const = 0;
  };


  class GRAPHICSOBJECT : public OBJECT {
  public:
    virtual ~GRAPHICSOBJECT () {}
    std::map< HDC, HGDIOBJ > contexts;
    virtual METARECORD* newEMR ( HDC dc, HGDIOBJ handle ) = 0;
  };

  typedef METARECORD*(*METARECORDCTOR)(DATASTREAM&);

  class GLOBALOBJECTS {
    std::vector<OBJECT*> objects;

    std::map< DWORD, METARECORDCTOR > new_records;

  public:
    GLOBALOBJECTS ( void );
    ~GLOBALOBJECTS ( void );
    HGDIOBJ add ( OBJECT* object );
    OBJECT* find ( const HGDIOBJ handle );
    void remove ( const OBJECT* object );

    std::vector<EMF::OBJECT*>::const_iterator begin ( void ) const
    { return objects.begin(); }
    std::vector<EMF::OBJECT*>::const_iterator end ( void ) const
    { return objects.end(); }

    METARECORDCTOR newRecord ( DWORD iType ) const;

    static EMF::METARECORD* new_eof ( DATASTREAM& ds );
    static EMF::METARECORD* new_setviewportorgex ( DATASTREAM& ds );
    static EMF::METARECORD* new_setwindoworgex ( DATASTREAM& ds );
    static EMF::METARECORD* new_setviewportextex ( DATASTREAM& ds );
    static EMF::METARECORD* new_setwindowextex ( DATASTREAM& ds );
    static EMF::METARECORD* new_scaleviewportextex ( DATASTREAM& ds );
    static EMF::METARECORD* new_scalewindowextex ( DATASTREAM& ds );
    static EMF::METARECORD* new_modifyworldtransform ( DATASTREAM& ds );
    static EMF::METARECORD* new_setworldtransform ( DATASTREAM& ds );
    static EMF::METARECORD* new_settextalign ( DATASTREAM& ds );
    static EMF::METARECORD* new_settextcolor ( DATASTREAM& ds );
    static EMF::METARECORD* new_setbkcolor ( DATASTREAM& ds );
    static EMF::METARECORD* new_setbkmode ( DATASTREAM& ds );
    static EMF::METARECORD* new_setpolyfillmode ( DATASTREAM& ds );
    static EMF::METARECORD* new_setmapmode ( DATASTREAM& ds );
    static EMF::METARECORD* new_selectobject ( DATASTREAM& ds );
    static EMF::METARECORD* new_deleteobject ( DATASTREAM& ds );
    static EMF::METARECORD* new_movetoex ( DATASTREAM& ds );
    static EMF::METARECORD* new_lineto ( DATASTREAM& ds );
    static EMF::METARECORD* new_arc ( DATASTREAM& ds );
    static EMF::METARECORD* new_arcto ( DATASTREAM& ds );
    static EMF::METARECORD* new_rectangle ( DATASTREAM& ds );
    static EMF::METARECORD* new_ellipse ( DATASTREAM& ds );
    static EMF::METARECORD* new_polyline ( DATASTREAM& ds );
    static EMF::METARECORD* new_polyline16 ( DATASTREAM& ds );
    static EMF::METARECORD* new_polygon ( DATASTREAM& ds );
    static EMF::METARECORD* new_polygon16 ( DATASTREAM& ds );
    static EMF::METARECORD* new_polypolygon ( DATASTREAM& ds );
    static EMF::METARECORD* new_polypolygon16 ( DATASTREAM& ds );
    static EMF::METARECORD* new_polybezier ( DATASTREAM& ds );
    static EMF::METARECORD* new_polybezier16 ( DATASTREAM& ds );
    static EMF::METARECORD* new_polybezierto ( DATASTREAM& ds );
    static EMF::METARECORD* new_polybezierto16 ( DATASTREAM& ds );
    static EMF::METARECORD* new_polylineto ( DATASTREAM& ds );
    static EMF::METARECORD* new_polylineto16 ( DATASTREAM& ds );
    static EMF::METARECORD* new_exttextouta ( DATASTREAM& ds );
    static EMF::METARECORD* new_setpixelv ( DATASTREAM& ds );
    static EMF::METARECORD* new_createpen ( DATASTREAM& ds );
    static EMF::METARECORD* new_extcreatepen ( DATASTREAM& ds );
    static EMF::METARECORD* new_createbrushindirect ( DATASTREAM& ds );
    static EMF::METARECORD* new_extcreatefontindirectw ( DATASTREAM& ds );
    static EMF::METARECORD* new_fillpath ( DATASTREAM& ds );
    static EMF::METARECORD* new_strokepath ( DATASTREAM& ds );
    static EMF::METARECORD* new_beginpath ( DATASTREAM& ds );
    static EMF::METARECORD* new_endpath ( DATASTREAM& ds );
    static EMF::METARECORD* new_closefigure ( DATASTREAM& ds );
    static EMF::METARECORD* new_savedc ( DATASTREAM& ds );
    static EMF::METARECORD* new_restoredc ( DATASTREAM& ds );
    static EMF::METARECORD* new_setmetargn ( DATASTREAM& ds );
  };

  extern GLOBALOBJECTS globalObjects;


  class ENHMETAHEADER : public METARECORD, public ::ENHMETAHEADER {

    LPWSTR description_w;
    int description_size;

  public:
    ENHMETAHEADER ( LPCWSTR description = 0 )
      : description_w( 0 ), description_size( 0 )
    {
      iType = EMR_HEADER;
      nSize = sizeof( ::ENHMETAHEADER );

      // Compute the bounds
      RECTL default_bounds = { 0, 0, 0, 0 };
      rclBounds = default_bounds;
      RECTL default_frame = { 0, 0, 0, 0 };
      rclFrame = default_frame;
      dSignature = ENHMETA_SIGNATURE;
      nVersion = 0x10000;
      nBytes = nSize;
      nRecords = 1;
      nHandles = 0;
      sReserved = 0;
      nDescription = 0;
      offDescription = 0;
      nPalEntries = 0;
      szlDevice.cx = XMAX_PIXELS;
      szlDevice.cy = YMAX_PIXELS;
      szlMillimeters.cx = XMAX_MM;
      szlMillimeters.cy = YMAX_MM;
      //
      cbPixelFormat = 0;
      offPixelFormat = 0;
      bOpenGL = FALSE;
      //
      szlMicrometers.cx = 1000 * szlMillimeters.cx;
      szlMicrometers.cy = 1000 * szlMillimeters.cy;

      if ( description ) {
        // Count the number of characters in the description
        int description_count = 0, nulls = 0;
        LPCWSTR description_p = description;
        while ( nulls < 3 ) {
          description_count++;
          if ( (*description_p++) == 0 ) nulls++;
        }

        // Make sure that the TOTAL record length will be a multiple of 4

        int record_size = ROUND_TO_LONG( sizeof( ::ENHMETAHEADER ) +
                                         sizeof( WCHAR ) * description_count );
        description_size =
          (record_size - sizeof( ::ENHMETAHEADER )) / sizeof( WCHAR );

        description_w = new WCHAR[ description_size ];

        memset( description_w, 0, sizeof(WCHAR) * description_size );

        for ( int i=0; i<description_count; i++ )
          description_w[i] = *description++;

        nSize = nBytes = record_size;
        nDescription = description_count;
        offDescription = sizeof( ::ENHMETAHEADER );
      }
    }
    
    ~ENHMETAHEADER ( )
    {
      if ( description_w ) delete[] description_w;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << iType << nSize
         << rclBounds << rclFrame
         << dSignature << nVersion << nBytes << nRecords << nHandles << sReserved
         << nDescription << offDescription << nPalEntries
         << szlDevice << szlMillimeters
         << cbPixelFormat << offPixelFormat << bOpenGL
         << szlMicrometers
         << WCHARSTR( description_w, description_size );
      return true;
    }
    bool unserialize ( DATASTREAM ds )
    {
      ds >> iType >> nSize
         >> rclBounds >> rclFrame
         >> dSignature >> nVersion >> nBytes >> nRecords >> nHandles >> sReserved
         >> nDescription >> offDescription >> nPalEntries
         >> szlDevice >> szlMillimeters;

      // Some elements of the metafile header were added at later dates

#define OffsetOf( a, b ) ((unsigned int)(((char*)&(((::ENHMETAHEADER*)a)->b)) - \
(char*)((::ENHMETAHEADER*)a)))

      if ( OffsetOf( this, szlMicrometers ) <= offDescription )
        ds >> cbPixelFormat >> offPixelFormat >> bOpenGL;

#undef OffsetOf

      if ( sizeof(::ENHMETAHEADER) <= offDescription )
        ds >> szlMicrometers;

      // Should now probably check that the offset is correct...

      description_size = ( nSize - offDescription ) / sizeof(WCHAR);
      description_w = new WCHAR[ description_size ];

      WCHARSTR description( description_w, description_size );

      ds >> description;

      return true;
    }
    int size ( void ) const { return nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC /*dc*/ ) const
    {
      // Actually handled by the destination device context.
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*HEADER*\n" );
      printf( "\tiType\t\t\t: %ld\n", iType );
      printf( "\tnSize\t\t\t: %ld\n", nSize );
      edit_rectl( "rclBounds\t", rclBounds );
      edit_rectl( "rclFrame\t", rclFrame );
      printf( "\tdSignature\t\t: %.4s\n", (const char*)&dSignature );
      printf( "\tnVersion\t\t: 0x%x\n", (unsigned int)nVersion );
      printf( "\tnBytes\t\t\t: %ld\n", nBytes );
      printf( "\tnRecords\t\t: %ld\n", nRecords );
      printf( "\tnHandles\t\t: %d\n", nHandles );
      printf( "\tnDescription\t\t: %ld\n", nDescription );
      printf( "\toffDescription\t\t: %ld\n", offDescription );
      printf( "\tnPalEntries\t\t: %ld\n", nPalEntries );
      edit_sizel( "szlDevice\t", szlDevice );
      edit_sizel( "szlMillimeters\t", szlMillimeters );

      /* Make a crude guess as to the age of this file */
#define OffsetOf( a, b ) ((unsigned int)(((const char*)&(((const ::ENHMETAHEADER*)a)->b)) - \
(const char*)((const ::ENHMETAHEADER*)a)))

      if ( OffsetOf( this, cbPixelFormat ) <= offDescription ) {
        printf( "\tcbPixelFormat\t\t: %ld\n", cbPixelFormat );
        printf( "\toffPixelFormat\t\t: %ld\n", offPixelFormat );
        printf( "\tbOpenGL\t\t\t: %ld\n", bOpenGL );

        if ( sizeof(::ENHMETAHEADER) <= offDescription ) {
          edit_sizel( "szlMicrometers\t", szlMicrometers );
        }
      }

#undef OffsetOf

      if ( nDescription != 0 ) {

        wchar_t last_w = 0;
        WCHAR* description = description_w;

        printf( "\tDescription:" );

        for ( DWORD i = 0; i < nDescription; i++ ) {

          wchar_t w = *description++; /* This is not true, really. UNICODE is not
                                       * glibc's wide character representation */

          if ( w != 0 ) {
            if ( last_w == 0 ) printf( "\n\t\t" );
            putchar( w );
          }
          
          last_w = w;
        }
        printf( "\n" );
      }
    }
#endif /* ENABLE_EDITING */
  };


  class EMREOF : public METARECORD, ::EMREOF {
  public:
    EMREOF ( void )
    {
      emr.iType = EMR_EOF;
      emr.nSize = sizeof( ::EMREOF );
      nPalEntries = 0;
      offPalEntries = 0;
      nSizeLast = 0;
    }

    EMREOF ( DATASTREAM& ds )
    {
      ds >> emr >> nPalEntries >> offPalEntries >> nSizeLast;
    }

    bool serialize ( DATASTREAM ds )
    {
      ds << emr << nPalEntries << offPalEntries << nSizeLast;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC /*dc*/ ) const
    {
      // Actually handled by the destination device context.
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*EOF*\n" );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETVIEWPORTORGEX : public METARECORD, ::EMRSETVIEWPORTORGEX {
  public:
    EMRSETVIEWPORTORGEX ( INT x, INT y )
    {
      emr.iType = EMR_SETVIEWPORTORGEX;
      emr.nSize = sizeof( ::EMRSETVIEWPORTORGEX );
      ptlOrigin.x = x;
      ptlOrigin.y = y;
    }
    EMRSETVIEWPORTORGEX ( DATASTREAM& ds )
    {
      ds >> emr >> ptlOrigin;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << ptlOrigin;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetViewportOrgEx( dc, ptlOrigin.x, ptlOrigin.y, 0 );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SETVIEWPORTORGEX*\n" );
      edit_pointl( "ptlOrigin", ptlOrigin );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETWINDOWORGEX : public METARECORD, ::EMRSETWINDOWORGEX {
  public:
    EMRSETWINDOWORGEX ( INT x, INT y )
    {
      emr.iType = EMR_SETWINDOWORGEX;
      emr.nSize = sizeof( ::EMRSETWINDOWORGEX );
      ptlOrigin.x = x;
      ptlOrigin.y = y;
    }
    EMRSETWINDOWORGEX ( DATASTREAM& ds )
    {
      ds >> emr >> ptlOrigin;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << ptlOrigin;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetWindowOrgEx( dc, ptlOrigin.x, ptlOrigin.y, 0 );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SETWINDOWORGEX*\n" );
      edit_pointl( "ptlOrigin", ptlOrigin );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETVIEWPORTEXTEX : public METARECORD, ::EMRSETVIEWPORTEXTEX {
  public:
    EMRSETVIEWPORTEXTEX ( INT cx, INT cy )
    {
      emr.iType = EMR_SETVIEWPORTEXTEX;
      emr.nSize = sizeof( ::EMRSETVIEWPORTEXTEX );
      szlExtent.cx = cx;
      szlExtent.cy = cy;
    }
    EMRSETVIEWPORTEXTEX ( DATASTREAM& ds )
    {
      ds >> emr >> szlExtent;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << szlExtent;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetViewportExtEx( dc, szlExtent.cx, szlExtent.cy, 0 );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SETVIEWPORTEXTEX*\n" );
      edit_sizel( "szlExtent", szlExtent );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSCALEVIEWPORTEXTEX : public METARECORD, ::EMRSCALEVIEWPORTEXTEX {
  public:
    EMRSCALEVIEWPORTEXTEX ( LONG x_num, LONG x_den, LONG y_num, LONG y_den )
    {
      emr.iType = EMR_SCALEVIEWPORTEXTEX;
      emr.nSize = sizeof( ::EMRSCALEVIEWPORTEXTEX );
      xNum = x_num;
      xDenom = x_den;
      yNum = y_num;
      yDenom = y_den;
    }
    EMRSCALEVIEWPORTEXTEX ( DATASTREAM& ds )
    {
      ds >> emr >> xNum >> xDenom >> yNum >> yDenom;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << xNum << xDenom << yNum << yDenom;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      ScaleViewportExtEx( dc, xNum, xDenom, yNum, yDenom, 0 );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SCALEVIEWPORTEXTEX*\n" );
      printf( "\txNum\t: %ld\n", xNum );
      printf( "\txDenom\t: %ld\n", xDenom );
      printf( "\tyNum\t: %ld\n", yNum );
      printf( "\tyDenom\t: %ld\n", yDenom );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETWINDOWEXTEX : public METARECORD, ::EMRSETWINDOWEXTEX {
  public:
    EMRSETWINDOWEXTEX ( INT cx, INT cy )
    {
      emr.iType = EMR_SETWINDOWEXTEX;
      emr.nSize = sizeof( ::EMRSETWINDOWEXTEX );
      szlExtent.cx = cx;
      szlExtent.cy = cy;
    }
    EMRSETWINDOWEXTEX ( DATASTREAM& ds )
    {
      ds >> emr >> szlExtent;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << szlExtent;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetWindowExtEx( dc, szlExtent.cx, szlExtent.cy, 0 );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SETWINDOWEXTEX*\n" );
      edit_sizel( "szlExtent", szlExtent );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSCALEWINDOWEXTEX : public METARECORD, ::EMRSCALEWINDOWEXTEX {
  public:
    EMRSCALEWINDOWEXTEX ( LONG x_num, LONG x_den, LONG y_num, LONG y_den )
    {
      emr.iType = EMR_SCALEWINDOWEXTEX;
      emr.nSize = sizeof( ::EMRSCALEWINDOWEXTEX );
      xNum = x_num;
      xDenom = x_den;
      yNum = y_num;
      yDenom = y_den;
    }
    EMRSCALEWINDOWEXTEX ( DATASTREAM& ds )
    {
      ds >> emr >> xNum >> xDenom >> yNum >> yDenom;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << xNum << xDenom << yNum << yDenom;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      ScaleWindowExtEx( dc, xNum, xDenom, yNum, yDenom, 0 );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SCALEWINDOWEXTEX*\n" );
      printf( "\txNum\t: %ld\n", xNum );
      printf( "\txDenom\t: %ld\n", xDenom );
      printf( "\tyNum\t: %ld\n", yNum );
      printf( "\tyDenom\t: %ld\n", yDenom );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRMODIFYWORLDTRANSFORM : public METARECORD, ::EMRMODIFYWORLDTRANSFORM {
  public:
    EMRMODIFYWORLDTRANSFORM ( const XFORM* transform, DWORD mode )
    {
      emr.iType = EMR_MODIFYWORLDTRANSFORM;
      emr.nSize = sizeof( ::EMRMODIFYWORLDTRANSFORM );
      xform = *transform;
      iMode = mode;
    }
    EMRMODIFYWORLDTRANSFORM ( DATASTREAM& ds )
    {
      ds >> emr >> xform >> iMode;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << xform << iMode;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      ModifyWorldTransform( dc, &xform, iMode );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*MODIFYWORLDTRANSFORM*\n" );
      edit_xform( "xform", xform );
      printf( "\tiMode\t\t: " );
      switch ( iMode ) {
      case MWT_IDENTITY: printf( "MWT_IDENTITY\n" ); break;
      case MWT_LEFTMULTIPLY: printf( "MWT_LEFTMULTIPLY\n" ); break;
      case MWT_RIGHTMULTIPLY: printf( "MWT_RIGHTMULTIPLY\n" ); break;
      default: printf( "unknown(%ld)\n", iMode );
      }
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETWORLDTRANSFORM : public METARECORD, ::EMRSETWORLDTRANSFORM {
  public:
    EMRSETWORLDTRANSFORM ( const XFORM* transform )
    {
      emr.iType = EMR_SETWORLDTRANSFORM;
      emr.nSize = sizeof( ::EMRSETWORLDTRANSFORM );
      xform = *transform;
    }
    EMRSETWORLDTRANSFORM ( DATASTREAM& ds )
    {
      ds >> emr >> xform;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << xform;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetWorldTransform( dc, &xform );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      printf( "*SETWORLDTRANSFORM*\n" );
      edit_xform( "xform", xform );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETTEXTALIGN : public METARECORD, ::EMRSETTEXTALIGN {
  public:
    EMRSETTEXTALIGN ( UINT mode )
    {
      emr.iType = EMR_SETTEXTALIGN;
      emr.nSize = sizeof( ::EMRSETTEXTALIGN );
      iMode = mode;
    }
    EMRSETTEXTALIGN ( DATASTREAM& ds )
    {
      ds >> emr >> iMode;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << iMode;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetTextAlign( dc, iMode );
    }
#ifdef ENABLE_EDITING

    void edit ( void ) const
    {
      unsigned int known_bits = TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING;
      unsigned int unknown_bits = ~known_bits;

      printf( "*SETTEXTALIGN*\n" );
      printf( "\tiMode\t: " );
      if ( iMode & TA_UPDATECP )
        printf( "TA_UPDATECP" );
      else
        printf( "TA_NOUPDATECP" );
      if ( iMode & TA_CENTER )
        printf( " | TA_CENTER" );
      else if ( iMode & TA_RIGHT )
        printf( " | TA_RIGHT" );
      else
        printf( " | TA_LEFT" );
      if ( iMode & TA_BASELINE )
        printf( " | TA_BASELINE" );
      else if ( iMode & TA_BOTTOM )
        printf( " | TA_BOTTOM" );
      else
        printf( " | TA_TOP" );
      if ( iMode & TA_RTLREADING )
        printf( " | TA_RTLREADING" );
      if ( iMode & unknown_bits )
        printf( " | unknown bits(0x%lx)", iMode & unknown_bits );
      printf( "\n" );
    }
#endif /* ENABLE_EDITING */
  };


  class EMRSETTEXTCOLOR : public METARECORD, ::EMRSETTEXTCOLOR {
  public:
    EMRSETTEXTCOLOR ( COLORREF color )
    {
      emr.iType = EMR_SETTEXTCOLOR;
      emr.nSize = sizeof( ::EMRSETTEXTCOLOR );
      crColor = color;
    }
    EMRSETTEXTCOLOR ( DATASTREAM& ds )
    {
      ds >> emr >> crColor;
    }
    bool serialize ( DATASTREAM ds )
    {
      ds << emr << crColor;
      return true;
    }
    int size ( void ) const { return emr.nSize; }
    void execute ( METAFILEDEVICECONTEXT* /*source*/, HDC dc ) const
    {
      SetTextColor( dc, crColor );
    }
#ifdef ENABLE_EDITING

    void