home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / Chapt_16 / EMF / EmfDC.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-16  |  25.5 KB  |  918 lines
  1. //-----------------------------------------------------------------------------------//
  2. //              Windows Graphics Programming: Win32 GDI and DirectDraw               //
  3. //                             ISBN  0-13-086985-6                                   //
  4. //                                                                                   //
  5. //  Written            by  Yuan, Feng                             www.fengyuan.com   //
  6. //  Copyright (c) 2000 by  Hewlett-Packard Company                www.hp.com         //
  7. //  Published          by  Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com      //
  8. //                                                                                   //
  9. //  FileName   : emfdc.cpp                                                             //
  10. //  Description: EMF decompiler                                                         //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define  STRICT
  15. #define WIN32_LEAN_AND_MEAN
  16. #define _WIN32_WINNT 0x0500
  17. #define WINVER         0x500
  18.  
  19. #include <windows.h>
  20. #include <assert.h>
  21. #include <commctrl.h>
  22. #include <fstream.h>
  23.  
  24. #include "..\..\include\treeview.h"
  25. #include "..\..\include\mmfile.h"
  26.  
  27. #include "EmfDC.h"
  28. #include "Formator.h"
  29. #include "OutPipe.h"
  30.  
  31. #include "resource.h"
  32.  
  33.  
  34. const DicItem Dic_BkMode[] =
  35. {
  36.     pair(OPAQUE),
  37.     pair(TRANSPARENT),
  38.     dummyitem
  39. };
  40.  
  41.  
  42. const DicItem Dic_ArcDirection[] =
  43. {
  44.     pair(AD_COUNTERCLOCKWISE),
  45.     pair(AD_CLOCKWISE),
  46.     dummyitem
  47. };
  48.  
  49.  
  50. const DicItem Dic_PolyFillMode[] =
  51. {
  52.     pair(ALTERNATE),
  53.     pair(WINDING),
  54.     dummyitem
  55. };
  56.  
  57.  
  58. const DicItem Dic_MapMode[] =
  59. {
  60.     pair(MM_ANISOTROPIC), 
  61.     pair(MM_HIENGLISH), 
  62.     pair(MM_HIMETRIC), 
  63.     pair(MM_ISOTROPIC), 
  64.     pair(MM_LOENGLISH), 
  65.     pair(MM_LOMETRIC), 
  66.     pair(MM_TEXT), 
  67.     pair(MM_TWIPS),
  68.     dummyitem
  69. };
  70.  
  71.  
  72. const DicItem Dic_StretchBltMode[] =
  73. { 
  74.     pair(STRETCH_ANDSCANS), 
  75.     pair(STRETCH_DELETESCANS), 
  76.     pair(STRETCH_ORSCANS),
  77.     pair(STRETCH_HALFTONE), 
  78.     pair(BLACKONWHITE),
  79.     pair(COLORONCOLOR),
  80.     pair(HALFTONE),
  81.     pair(WHITEONBLACK),
  82.     dummyitem
  83. };
  84.  
  85.  
  86. const DicItem Dic_ICMMode [] =
  87. {
  88.     pair(ICM_ON),
  89.     pair(ICM_OFF),
  90.     pair(ICM_QUERY),
  91.     dummyitem
  92. };
  93.  
  94.  
  95. const DicItem Dic_RegionOper [] =
  96. {
  97.     pair(RGN_AND),
  98.     pair(RGN_XOR),
  99.     pair(RGN_COPY), 
  100.     pair(RGN_DIFF), 
  101.     pair(RGN_OR),
  102.     dummyitem
  103. };
  104.  
  105.  
  106. const DicItem Dic_TransCombineMode [] =
  107. {
  108.     pair(MWT_IDENTITY),
  109.     pair(MWT_LEFTMULTIPLY),
  110.     pair(MWT_RIGHTMULTIPLY),
  111.     dummyitem
  112. };
  113.  
  114.  
  115. const DicItem Dic_ROP2 [] =
  116. {
  117.     pair(R2_BLACK), 
  118.     pair(R2_COPYPEN), 
  119.     pair(R2_MASKNOTPEN), 
  120.     pair(R2_MASKPEN), 
  121.     pair(R2_MASKPENNOT),
  122.     pair(R2_MERGENOTPEN), 
  123.     pair(R2_MERGEPEN), 
  124.     pair(R2_MERGEPENNOT), 
  125.     pair(R2_NOP), 
  126.     pair(R2_NOT), 
  127.     pair(R2_NOTCOPYPEN), 
  128.     pair(R2_NOTMASKPEN), 
  129.     pair(R2_NOTMERGEPEN), 
  130.     pair(R2_NOTXORPEN), 
  131.     pair(R2_WHITE), 
  132.     pair(R2_XORPEN),
  133.     dummyitem
  134. };
  135.  
  136.  
  137. const DicItem Dic_FloodFillMode [] =
  138. {
  139.     pair(FLOODFILLBORDER),
  140.     pair(FLOODFILLSURFACE),
  141.     dummyitem
  142. };
  143.  
  144.  
  145. const DicItem Dic_PenStyle[] =
  146. {
  147. //    tripod(PS_COSMETIC,     PS_TYPE_MASK),
  148.     tripod(PS_GEOMETRIC,    PS_TYPE_MASK),
  149.  
  150.     tripod(PS_SOLID,        PS_STYLE_MASK),
  151.     tripod(PS_DASH,            PS_STYLE_MASK),
  152.     tripod(PS_DOT,            PS_STYLE_MASK),
  153.     tripod(PS_DASHDOT,        PS_STYLE_MASK),
  154.     tripod(PS_DASHDOTDOT,    PS_STYLE_MASK),
  155.     tripod(PS_NULL,            PS_STYLE_MASK),
  156.     tripod(PS_INSIDEFRAME,    PS_STYLE_MASK),
  157.     tripod(PS_USERSTYLE,    PS_STYLE_MASK),
  158.     tripod(PS_ALTERNATE,    PS_STYLE_MASK),
  159.  
  160. //    tripod(PS_ENDCAP_ROUND, PS_ENDCAP_MASK),
  161.     tripod(PS_ENDCAP_SQUARE,PS_ENDCAP_MASK),
  162.     tripod(PS_ENDCAP_FLAT,  PS_ENDCAP_MASK),
  163.     
  164. //    tripod(PS_JOIN_ROUND,   PS_JOIN_MASK),
  165.     tripod(PS_JOIN_BEVEL,   PS_JOIN_MASK),
  166.     tripod(PS_JOIN_MITER,   PS_JOIN_MASK),
  167.     
  168.     dummyitem
  169. };
  170.  
  171.  
  172. const DicItem Dic_ROP3[] =
  173. {
  174.     pair(BLACKNESS), 
  175.     pair(DSTINVERT), 
  176.     pair(MERGECOPY), 
  177.     pair(MERGEPAINT), 
  178.     pair(NOTSRCCOPY), 
  179.     pair(NOTSRCERASE), 
  180.     pair(PATCOPY), 
  181.     pair(PATINVERT), 
  182.     pair(PATPAINT), 
  183.     pair(SRCAND), 
  184.     pair(SRCCOPY), 
  185.     pair(SRCERASE), 
  186.     pair(SRCINVERT), 
  187.     pair(SRCPAINT), 
  188.     pair(WHITENESS), 
  189.     dummyitem
  190. };
  191.  
  192.  
  193. const DicItem Dic_DIBColor [] =
  194. {
  195.     pair(DIB_PAL_COLORS),
  196. //    pair(DIB_PAL_INDICES),
  197.     pair(DIB_RGB_COLORS),
  198.     dummyitem
  199. };
  200.  
  201. typedef struct
  202. {
  203.     unsigned      type;
  204.  
  205.     const TCHAR * funcname;
  206.     const DicItem * dic;
  207. }    EmrInfo;
  208.  
  209.  
  210. const DicItem Dic_TextAlign [] = 
  211. {
  212.     tripod(TA_NOUPDATECP,     0x01),
  213.     tripod(TA_UPDATECP,       0x01),
  214.  
  215.     tripod(TA_LEFT,              0x06),
  216.     tripod(TA_RIGHT,          0x06),
  217.     tripod(TA_CENTER,         0x06),
  218.  
  219.     tripod(TA_TOP,            0x18),
  220.     tripod(TA_BOTTOM,         0x18),
  221.     tripod(TA_BASELINE,       0x18),
  222.  
  223.     tripod(TA_RTLREADING,     0x100),
  224.  
  225.     dummyitem
  226. };
  227.  
  228.  
  229. const DicItem Dic_ExtTextOption [] = 
  230. {
  231.     tripod(ETO_OPAQUE,            ETO_OPAQUE),
  232.     tripod(ETO_CLIPPED,            ETO_CLIPPED),
  233.     tripod(ETO_GLYPH_INDEX,        ETO_GLYPH_INDEX),
  234.     tripod(ETO_RTLREADING,        ETO_RTLREADING),
  235.     tripod(ETO_NUMERICSLOCAL,    ETO_NUMERICSLOCAL),
  236.     tripod(ETO_NUMERICSLATIN,    ETO_NUMERICSLATIN),
  237.     tripod(ETO_IGNORELANGUAGE,    ETO_IGNORELANGUAGE),
  238.     tripod(ETO_PDY,                ETO_PDY),
  239.     dummyitem
  240. };
  241.  
  242.  
  243. const EmrInfo Pattern [] = 
  244. {
  245.     { EMR_SETWINDOWEXTEX          , "SetWindowExtEx"        "(hDC, %d, %d, NULL);" },
  246.     { EMR_SETWINDOWORGEX          , "SetWindowOrgEx"        "(hDC, %d, %d, NULL);" },
  247.     { EMR_SETVIEWPORTEXTEX        , "SetViewportExtEx"        "(hDC, %d, %d, NULL);" },
  248.     { EMR_SETVIEWPORTORGEX        , "SetViewportOrgEx"        "(hDC, %d, %d, NULL);" },
  249.     { EMR_SCALEVIEWPORTEXTEX      , "ScaleViewportExtEx"    "(hDC, %d, %d, %d, %d, NULL);" },
  250.     { EMR_SCALEWINDOWEXTEX        , "ScaleWindowExtEx"        "(hDC, %d, %d, %d, %d, NULL);" },
  251.     { EMR_SETLAYOUT                  , "SetLayout"                "(hDC, %d)" },
  252.     { EMR_SETMETARGN              , "SetMetaRgn"            "(hDC);" },
  253.         
  254.     { EMR_BEGINPATH               , "BeginPath"                "(hDC);" },
  255.     { EMR_ENDPATH                 , "EndPath"                "(hDC);" },
  256.     { EMR_ABORTPATH               , "AbortPath"                "(hDC);" },
  257.     { EMR_FLATTENPATH             , "FlattenPath"            "(hDC);" },
  258.     { EMR_WIDENPATH               , "WidenPath"                "(hDC);" },
  259.     { EMR_CLOSEFIGURE             , "CloseFigure"            "(hDC);" },
  260.     { EMR_FILLPATH                , "FillPath"                "(hDC);" },
  261.     { EMR_STROKEANDFILLPATH       , "StrokeAndFillPath"        "(hDC);" },
  262.     { EMR_STROKEPATH              , "StrokePath"            "(hDC);" },
  263.     { EMR_SAVEDC                  , "SaveDC"                "(hDC);" },
  264.     { EMR_RESTOREDC               , "RestoreDC"                "(hDC, %d);" },
  265.     
  266.     { EMR_CREATEPEN               , "#o=CreatePen(%L, %d%_, #c);", Dic_PenStyle },
  267.     { EMR_CREATEBRUSHINDIRECT     , "#o=#C;" },
  268.     { EMR_EXTCREATEFONTINDIRECTW  , "#o=CreateFont(%d,%d,%d,%d,%d,%b,%b,%b,%b,%b,%b,%b,%b,%S);" },
  269.     { EMR_CREATEPALETTE           , "#o=CreatePalette(LOGPALETTE {%D,%D,...});" },
  270.     
  271.     { EMR_SELECTOBJECT            , "SelectObject(hDC, #o);" },
  272.     { EMR_SELECTPALETTE           , "SelectPalette(hDC, (HPALETTE)#o, TRUE);" },
  273.     { EMR_SETCOLORSPACE           , "SetColorSpace(hDC, #o);" },
  274.     { EMR_DELETEOBJECT            , "DeleteObject(#o);" },
  275.     { EMR_DELETECOLORSPACE        , "DeleteColorSpace(#o);" },
  276.     
  277.     { EMR_SETTEXTCOLOR            , "SetTextColor(hDC, #c);" },
  278.     { EMR_SETBKCOLOR              , "SetBkColor(hDC, #c);" },
  279.     { EMR_SETBRUSHORGEX           , "SetBrushOrgEx(hDC, %d, %d, NULL);" },
  280.     { EMR_SELECTCLIPPATH          , "SelectClipPath(hDC, %L);", Dic_RegionOper },
  281.     { EMR_SETTEXTALIGN            , "SetTextAlign(hDC, %L);", Dic_TextAlign },
  282.     
  283.     { EMR_SETBKMODE               , "SetBkMode(hDC, %L);",            Dic_BkMode },
  284.     { EMR_SETARCDIRECTION         , "SetArcDirection(hDC, %L);",        Dic_ArcDirection },
  285.     { EMR_SETPOLYFILLMODE         , "SetPolyFillMode(hDC, %L);",        Dic_PolyFillMode },
  286.     { EMR_SETMAPMODE              , "SetMapMode(hDC, %L);",            Dic_MapMode },
  287.     { EMR_SETSTRETCHBLTMODE       , "SetStretchBltMode(hDC, %L);",    Dic_StretchBltMode },
  288.     { EMR_SETMAPPERFLAGS          , "SetMapperFlags(hDC, %d);" },
  289.     { EMR_SETICMMODE              , "SetICMMode(hDC, %d);",          Dic_ICMMode },
  290.     { EMR_SETROP2                 , "SetROP2(hDC, %L);",             Dic_ROP2 },
  291.  
  292.     { EMR_SETMITERLIMIT           , "SetMiterLimit(hDC, %f);" },
  293.     { EMR_SETWORLDTRANSFORM       , "SetWorldTransform(hDC, %f, %f, %f, %f, %f, %f);" }, 
  294.     { EMR_MODIFYWORLDTRANSFORM    , "ModifyWorldTransform(hDC, %f, %f, %f, %f, %f, %f, %L);", Dic_TransCombineMode },
  295.     
  296.     { EMR_REALIZEPALETTE          , "RealizePalette(hDC);" },
  297.     { EMR_RESIZEPALETTE           , "ResizePalette(hDC, #o, %d);" },
  298.     
  299.     { EMR_OFFSETCLIPRGN           , "OffsetClipRgn(hDC, %d, %d);" },
  300.     { EMR_EXCLUDECLIPRECT         , "ExcludeClipRect(hDC, %d, %d, %d, %d);" },
  301.     { EMR_INTERSECTCLIPRECT       , "IntersectClipRect(hDC, %d, %d, %d, %d);" },
  302.     
  303.     { EMR_SETPIXELV               , "SetPixelV(hDC, %d, %d, #c);" },
  304.     { EMR_MOVETOEX                , "MoveToEx(hDC, %d, %d, NULL);" },
  305.     { EMR_LINETO                  , "LineTo(hDC, %d, %d);" },
  306.     { EMR_RECTANGLE               , "Rectangle(hDC, %d, %d, %d, %d);" },
  307.     { EMR_ELLIPSE                 , "Ellipse(hDC, %d, %d, %d, %d);" },
  308.     { EMR_ROUNDRECT               , "RoundRect(hDC, %d, %d, %d, %d, %d, %d);" },
  309.     { EMR_PIE                     , "Pie(hDC, %d, %d, %d, %d, %d, %d, %d, %d);" },
  310.     { EMR_ARC                     , "Arc(hDC, %d, %d, %d, %d, %d, %d, %d, %d);" },
  311.     { EMR_CHORD                   , "Chord(hDC, %d, %d, %d, %d, %d, %d, %d, %d);" },
  312.     { EMR_ARCTO                   , "ArcTo(hDC, %d, %d, %d, %d, %d, %d, %d, %d);" },
  313.     { EMR_ANGLEARC                , "AngleArc(hDC, %d, %d, %d, %f, %f);" },
  314.     { EMR_EXTFLOODFILL            , "ExtFloodFill(hDC, %d, %d, #c, %L);", Dic_FloodFillMode },
  315.     
  316.     { EMR_POLYLINE16              , "\nstatic const POINT Points_%n[]=#p;\n"     "Polyline(hDC, Points_%n, %4);" },
  317.     { EMR_POLYLINETO16            , "\nstatic const POINT Points_%n[]=#p;\n"   "PolylineTo(hDC, Points_%n, %4);" },
  318.     { EMR_POLYBEZIER16            , "\nstatic const POINT Points_%n[]=#p;\n"   "PolyBezier(hDC, Points_%n, %4);" },
  319.     { EMR_POLYBEZIERTO16          , "\nstatic const POINT Points_%n[]=#p;\n" "PolyBezierTo(hDC, Points_%n, %4);" },
  320.     { EMR_POLYGON16               , "\nstatic const POINT Points_%n[]=#p;\n"      "Polygon(hDC, Points_%n, %4);" },
  321.     
  322.     { EMR_POLYLINE                , "\nstatic const POINT Points_%n[]=#P;\n"     "Polyline(hDC, Points_%n, %4);" },
  323.     { EMR_POLYLINETO              , "\nstatic const POINT Points_%n[]=#P;\n"   "PolylineTo(hDC, Points_%n, %4);" },
  324.     { EMR_POLYBEZIER              , "\nstatic const POINT Points_%n[]=#P;\n"   "PolyBezier(hDC, Points_%n, %4);" },
  325.     { EMR_POLYBEZIERTO            , "\nstatic const POINT Points_%n[]=#P;\n" "PolyBezierTo(hDC, Points_%n, %4);" },
  326.     { EMR_POLYGON                 , "\nstatic const POINT Points_%n[]=#P;\n"      "Polygon(hDC, Points_%n, %4);" },
  327.     
  328.     //////////////////
  329. //  { EMR_HEADER                  , "// Header" },
  330.     
  331.       { EMR_POLYDRAW16              , "PolyDraw16" },
  332.     
  333.     { EMR_EOF                     , "// EMREOF(%d, %d, %d)" },
  334.     { EMR_SETCOLORADJUSTMENT      , "SetColorAdjustment" },
  335.     { EMR_SETPALETTEENTRIES       , "SetPaletteEntries" },
  336.     { EMR_POLYDRAW                , "PolyDraw" },
  337.     
  338.     { EMR_GDICOMMENT              , "// GdiComment(%d, %c%c%c%c, 0x%x)" },
  339.     { EMR_FILLRGN                 , "FillRgn" },
  340.     { EMR_FRAMERGN                , "FrameRgn" },
  341.     { EMR_INVERTRGN               , "InvertRgn" },
  342.     { EMR_PAINTRGN                , "PaintRgn" },
  343.     { EMR_MASKBLT                 , "MaskBlt" },
  344.     { EMR_PLGBLT                  , "PlgBlt" },
  345.     { EMR_SETDIBITSTODEVICE       , "SetDIBSToDevice" },
  346.     { EMR_CREATEDIBPATTERNBRUSHPT , "CreateDIBPatternBrushPT" },
  347.     { EMR_POLYTEXTOUTA            , "PolyTextOutA" },
  348.     { EMR_POLYTEXTOUTW            , "PolyTextOutW" },
  349.     { EMR_CREATECOLORSPACE        , "CreateColorSpace" },
  350.     { EMR_GLSRECORD               , "GlsRecord" },
  351.     { EMR_GLSBOUNDEDRECORD        , "GlsBOundedRecord" },
  352.     { EMR_PIXELFORMAT             , "PixelFormat" },
  353.  
  354.     { EMR_COLORCORRECTPALETTE      , "ColorCorrectPalette" },
  355.     { EMR_SETICMPROFILEA          , "SetICMProfileA" },
  356.     { EMR_SETICMPROFILEW          , "SetICMProfileW" },
  357.     { EMR_ALPHABLEND              , "AlphaBlend" },
  358.     { EMR_TRANSPARENTBLT          , "TransParentBlt" },
  359.     { EMR_GRADIENTFILL              , "GradientFill" },
  360.  
  361. //    { EMR_DRAWESCAPE              , "DrawEscape" },
  362. //    { EMR_EXTESCAPE               , "ExtEscape" },
  363. //    { EMR_STARTDOC                , "StartDoc" },
  364. //    { EMR_FORCEUFIMAPPING         , "ForceEuFiMapping" },
  365. //    { EMR_NAMEDESCAPE              , "NamedEscape" },
  366. //    { EMR_TRANSPARENTDIB          , "TransParentDIB" },
  367. //    { EMR_SETLINKEDUFIS           , "SetLinkEDUFIS" },
  368. //    { EMR_SETTEXTJUSTIFICATION    , "SetTextJustification" }
  369. //  { EMR_EXTSELECTCLIPRGN        , "ExtSelectClipRgn" },
  370. //    { EMR_SMALLTEXTOUT            , "TextOut" },
  371. //    { EMR_CREATEMONOBRUSH         , "CreateMonoBrush" },
  372.     
  373. };
  374.  
  375. typedef struct
  376. {
  377.     EMR    emr;     
  378.     POINTL ptlReference;     
  379.     DWORD  nChars;     
  380.     DWORD  fOptions;     
  381.     DWORD  iGraphicsMode;
  382.     FLOAT  exScale;
  383.     FLOAT  eyScale;
  384.     char   Text[1];
  385. } EMRSMALLTEXTOUT;
  386.           
  387.  
  388. inline const void * Offset(const void * base, long ofst)
  389. {
  390.     return (const void *) ( (const char *) base + ofst);
  391. }
  392.  
  393. const TCHAR Format_ENHMETAHEADER [] =
  394.     "4iType: %d\0" 
  395.     "4nSize: %d\0" 
  396.     "grclBounds: { %d, %d, %d, %d}\0"
  397.     "grclFrame: { %d, %d, %d, %d}\0" 
  398.     "4dSignature: 0x%08x\0" 
  399.     "4nVersion: 0x%x\0" 
  400.     "4nBytes: %d\0" 
  401.     "4nRecords: %d\0"
  402.     "2nHandles: %d\0"
  403.     "2sReserved: %d\0" 
  404.     "4nDescription: %d\0" 
  405.     "4offDescription: %d\0" 
  406.     "4nPalEntries: %d\0" 
  407.     "8szlDevice: { %d, %d }\0" 
  408.     "8szlMillimeters: { %d, %d }\0"
  409.     "4cbPixelFormat: %d\0"
  410.     "4offPixelFormat: %d\0"
  411.     "4bOpenGL: %d\0"
  412.     "8szMicroMeters: { %d, %d }\0";
  413.  
  414.  
  415.  
  416. bool KEmfDC::Decode(const EMR * emr, KTreeView * pTree)
  417. {
  418.     if ( pTree && emr->iType==EMR_HEADER )
  419.     {
  420.         pTree->InsertTree(TVI_LAST, TVI_ROOT, "1: ENHMETAHEADER", Format_ENHMETAHEADER, emr);
  421.         return true;
  422.     }
  423.  
  424.     const TCHAR * rslt = DecodeRecord(emr);
  425.  
  426.     if ( pTree )
  427.     {
  428.         TCHAR temp[1024];
  429.  
  430.         m_nSeq ++;
  431.         wsprintf(temp, "%d: ", m_nSeq);
  432.         _tcscat(temp, rslt);
  433.  
  434.         wsprintf(temp + _tcslen(temp), ", %d bytes", emr->nSize);
  435.         
  436.         pTree->InsertItem(temp);
  437.     }
  438.  
  439.     return true;
  440. }
  441.  
  442.  
  443. const TCHAR * KEmfDC::DecodeRecord(const EMR * emr)
  444. {
  445.     fmt.Newline();
  446.  
  447.     for (int i=0; i< sizeof(Pattern)/sizeof(Pattern[0]); i++)
  448.         if ( Pattern[i].type == emr->iType)
  449.         {
  450.             fmt.Format(Pattern[i].funcname, (const long *) & emr[1], Pattern[i].dic);
  451.             
  452.             return fmt.m_buffer;
  453.         }
  454.  
  455.     switch ( emr->iType )
  456.     {        
  457.         case EMR_HEADER:
  458.             fmt.Write("// Header");
  459.             break;
  460.  
  461.         case EMR_BITBLT:
  462.             {
  463.                 EMRBITBLT  * bitblt = (EMRBITBLT *) emr;
  464.  
  465.                 if ( bitblt->cbBitsSrc==0 ) // no bitmap
  466.                     fmt.Format("PatBlt(hDC,%d,%d,%d,%d,", & bitblt->xDest);
  467.                 else
  468.                 {
  469.                     fmt.Format("BitBlt(hDC,%d,%d,%d,%d,", & bitblt->xDest);
  470.  
  471.                 //    assert(false);
  472.                     fmt.Write("hMemDC");
  473.                 
  474.                     fmt.Format(",%d,%d,", & bitblt->xSrc);
  475.                 }
  476.  
  477.                 fmt.Write(Lookup(bitblt->dwRop, Dic_ROP3));
  478.                 fmt.Write(");");
  479.             }
  480.             break;
  481.  
  482.         case EMR_STRETCHBLT:
  483.             {
  484.                 EMRSTRETCHBLT * cmd = (EMRSTRETCHBLT *) emr;
  485.  
  486.                 if ( cmd->cbBitsSrc==0 ) // no bitmap
  487.                     fmt.Format("PatBlt(hDC,%d,%d,%d,%d,", & cmd->xDest);
  488.                 else
  489.                 {
  490.                     TCHAR format[64];
  491.  
  492.                     fmt.AddDIB( cmd, 
  493.                             cmd->offBmiSrc,  cmd->cbBmiSrc,
  494.                             cmd->offBitsSrc, cmd->cbBitsSrc,
  495.                             format, false);
  496.                 
  497.                     fmt.Newline();
  498.                     fmt.Format("StretchDIBits(hDC, %d,%d", & cmd->xDest);
  499.                     fmt.Format(",%d,%d",                   & cmd->cxDest);
  500.                     fmt.Format(", %d,%d,",                   & cmd->xSrc);
  501.  
  502.                     if ( ! fmt.IsOpen() )
  503.                     {
  504.                         fmt.Format("%d,%d, pBits, pBMI",       & cmd->cxSrc);
  505.                         fmt.Write(format);
  506.                     }
  507.                     else
  508.                         fmt.Format("%d,%d, #b, #B",               & cmd->cxSrc);
  509.                     
  510.                     fmt.Format(", %L,", & cmd->iUsageSrc, Dic_DIBColor);
  511.                 }
  512.                 
  513.                 fmt.Write(Lookup(cmd->dwRop, Dic_ROP3));
  514.                 fmt.Write(");");
  515.             }
  516.             break;
  517.  
  518.         case EMR_EXTSELECTCLIPRGN:
  519.             {
  520.                 EMREXTSELECTCLIPRGN * extselectcliprgn = (EMREXTSELECTCLIPRGN *) emr;
  521.  
  522.                 if ( extselectcliprgn->cbRgnData == 0 )
  523.                     fmt.Write("SelectClipRgn(hDC, NULL);");
  524.                 else
  525.                 {
  526.                     fmt.AddRegion(extselectcliprgn->cbRgnData, (const RGNDATA *) & extselectcliprgn->RgnData);
  527.                     
  528.                     fmt.Newline();
  529.                     fmt.Format("ExtSelectClipRgn(hDC, hRegion, %L);", & extselectcliprgn->iMode, Dic_RegionOper);
  530.  
  531.                     fmt.Newline();
  532.                     fmt.Write("DeleteObject(hRegion);");
  533.                 }
  534.             }
  535.             break;
  536.  
  537. /*        case EMR_SMALLTEXTOUT:
  538.             {
  539.                 EMRSMALLTEXTOUT * smalltextout = (EMRSMALLTEXTOUT *) emr;
  540.  
  541.                 fmt.Format("ExtTextOutA(hDC, %d,%d,",
  542.                             & smalltextout->ptlReference.x);
  543.  
  544.                 fmt.WriteDec(smalltextout->fOptions & 0xFC00);
  545.                 fmt.Write(",NULL,");
  546.                 fmt.WriteString(smalltextout->Text, smalltextout->nChars, false);
  547.                 fmt.Write(",");
  548.                 fmt.WriteDec(smalltextout->nChars);
  549.                 fmt.Write(",NULL);");
  550.             }
  551.             break;
  552. */            
  553.         case EMR_EXTTEXTOUTA:
  554.         case EMR_EXTTEXTOUTW:
  555.             {
  556.                 EMREXTTEXTOUTW * cmd = (EMREXTTEXTOUTW *) emr;
  557.  
  558.                 if ( (cmd->emrtext.offDx!=0) && (cmd->emrtext.nChars!=0) )
  559.                 {
  560.                     fmt.Format("const int Dx_%m[]=", NULL);
  561.                     fmt.WriteArray(Offset(emr, cmd->emrtext.offDx), cmd->emrtext.nChars, sizeof(long));
  562.                     fmt.Put(';');
  563.  
  564.                     fmt.Newline();
  565.                 }
  566.  
  567.                 if (cmd->emrtext.fOptions & ( ETO_CLIPPED | ETO_OPAQUE) )
  568.                 {
  569.                     fmt.Format("const RECT Rect_%n={%d,%d,%d,%d};", & cmd->emrtext.rcl);
  570.                     fmt.Newline();
  571.                 }
  572.  
  573.                 if (emr->iType == EMR_EXTTEXTOUTA)
  574.                     fmt.Write("ExtTextOutA");
  575.                 else
  576.                     fmt.Write("ExtTextOutW");
  577.                 
  578.                 fmt.Format("(hDC, %d,%d,", & cmd->emrtext.ptlReference);
  579.                 
  580.                 if ( cmd->emrtext.fOptions == 0)
  581.                     fmt.Put('0');
  582.                 else
  583.                     fmt.Write(cmd->emrtext.fOptions, Dic_ExtTextOption);
  584.                 
  585.                 fmt.Put(',');
  586.                 
  587.                 if (cmd->emrtext.fOptions & (ETO_CLIPPED | ETO_OPAQUE) )
  588.                     fmt.Format("& Rect_%n,", NULL);
  589.                 else
  590.                     fmt.Write("NULL,");
  591.  
  592.                 if (emr->iType == EMR_EXTTEXTOUTW)
  593.                     fmt.Put('L');
  594.  
  595.                 if (emr->iType == EMR_EXTTEXTOUTA)
  596.                     fmt.WriteString(Offset(emr, cmd->emrtext.offString), cmd->emrtext.nChars, false);
  597.                 else
  598.                     fmt.WriteString(Offset(emr, cmd->emrtext.offString), cmd->emrtext.nChars, true);
  599.  
  600.                 fmt.Write(",");
  601.                 fmt.WriteDec(cmd->emrtext.nChars);
  602.  
  603.                 if ( (cmd->emrtext.offDx!=0) && (cmd->emrtext.nChars!=0) )
  604.                     fmt.Format(",Dx_%m);", NULL);
  605.                 else
  606.                     fmt.Write(",NULL);");
  607.             }
  608.             break;
  609.  
  610.         case EMR_POLYPOLYGON16:
  611.         case EMR_POLYPOLYLINE16:
  612.         case EMR_POLYPOLYGON:
  613.         case EMR_POLYPOLYLINE:
  614.             {
  615.                 EMRPOLYPOLYGON * polypolygon = ( EMRPOLYPOLYGON *) emr;
  616.  
  617.                 fmt.Format("static const int Count_%n[]=", 0);
  618.                 fmt.WriteArray( polypolygon->aPolyCounts, polypolygon->nPolys, sizeof(polypolygon->aPolyCounts[0]));
  619.                 fmt.Put(';');
  620.  
  621.                 fmt.Newline();
  622.                 fmt.Format("static const int Vertex_%m[]=", 0);
  623.  
  624.                 switch ( emr->iType )
  625.                 {
  626.                     case EMR_POLYPOLYGON16:
  627.                     case EMR_POLYPOLYLINE16:
  628.                         fmt.WriteArray(& polypolygon->aPolyCounts[polypolygon->nPolys], polypolygon->cptl * 2, sizeof(short));
  629.                         break;
  630.  
  631.                     case EMR_POLYPOLYGON:
  632.                     case EMR_POLYPOLYLINE:
  633.                         fmt.WriteArray(& polypolygon->aPolyCounts[polypolygon->nPolys], polypolygon->cptl * 2, sizeof(long));
  634.                         break;
  635.                 }
  636.                 
  637.                 fmt.Put(';');
  638.  
  639.                 fmt.Newline();
  640.     
  641.                 switch ( emr->iType )
  642.                 {
  643.                     case EMR_POLYPOLYGON16:
  644.                     case EMR_POLYPOLYGON:
  645.                         fmt.Write("PolyPolygon");
  646.                         break;
  647.  
  648.                     case EMR_POLYPOLYLINE16:
  649.                     case EMR_POLYPOLYLINE:
  650.                         fmt.Write("PolyPolyline");
  651.                         break;
  652.                 }
  653.                 fmt.Format("(hDC, (const POINT *) Vertex_%m, Count_%n, %d);", & polypolygon->nPolys);
  654.             }
  655.             break;
  656.  
  657.         case EMR_STRETCHDIBITS:
  658.             {
  659.                 EMRSTRETCHDIBITS * cmd = (EMRSTRETCHDIBITS *) emr;
  660.  
  661.                 TCHAR format[64];
  662.  
  663.                 fmt.Newline();
  664.  
  665.                 bool newdib = fmt.AddDIB( cmd, 
  666.                                     cmd->offBmiSrc,  cmd->cbBmiSrc,
  667.                                     cmd->offBitsSrc, cmd->cbBitsSrc,
  668.                                     format, false);
  669.                 
  670.                 if ( ! fmt.IsOpen() )
  671.                 {
  672.                     fmt.Newline();
  673.                     fmt.Format("StretchDIBits(hDC, %d,%d", & cmd->xDest);
  674.                     fmt.Format(",%d,%d",                   & cmd->cxDest);
  675.  
  676.                     fmt.Format(", %d,%d,%d,%d, pBits, pBMI",    & cmd->xSrc);
  677.                     fmt.Write(format);
  678.                 }
  679.                 else
  680.                 {
  681.                     if ( newdib )
  682.                     {
  683.                         fmt.Write("// ");
  684.                         fmt.Write(format);
  685.                         fmt.Newline();
  686.                     }
  687.  
  688.                     TCHAR temp[32];
  689.                     wsprintf(temp, "Dib_%d.", fmt.m_curPackedDIB+1);
  690.                     fmt.Write(temp);
  691.  
  692.                     fmt.Format("StretchDIBits(hDC, %d,%d", & cmd->xDest);
  693.                     fmt.Format(",%d,%d",                   & cmd->cxDest);
  694.                     fmt.Format(", %d,%d,%d,%d",               & cmd->xSrc);
  695.                 }
  696.  
  697.                 fmt.Format(", %L", & cmd->iUsageSrc, Dic_DIBColor);
  698.                 fmt.Format(", %L);", & cmd->dwRop,    Dic_ROP3);
  699.             }
  700.             break;
  701.  
  702.         case EMR_CREATEMONOBRUSH:
  703.             {
  704.                 EMRCREATEMONOBRUSH * cmd = (EMRCREATEMONOBRUSH *) emr;
  705.  
  706.                 assert( (cmd->offBmi + cmd->cbBmi) == cmd->offBits);
  707.  
  708.                 fmt.Format("const unsigned long DIB_%n[]=", NULL);
  709.                 fmt.WriteArray(Offset(cmd, cmd->offBmi), (cmd->cbBmi + cmd->cbBits)/sizeof(long), sizeof(long), false);
  710.                 fmt.Put(';');
  711.                 
  712.                 fmt.Newline();
  713.                 fmt.Format("#o=CreateDIBPatternBrushPt((const BITMAPINFO *) DIB_%n,%L);", & cmd->ihBrush, Dic_DIBColor);
  714.             }
  715.             break;
  716.  
  717.         case EMR_EXTCREATEPEN:
  718.             {
  719.                 EMREXTCREATEPEN * cmd = (EMREXTCREATEPEN *) emr;
  720.  
  721.                 fmt.Format("static const LOGBRUSH LogBrush_%m = #R;", & cmd->elp.elpBrushStyle);
  722.                 
  723.                 fmt.Newline();
  724.                 fmt.Format("#o=ExtCreatePen(", & cmd->ihPen);
  725.  
  726.                 assert(cmd->cbBmi == 0);
  727.                 assert(cmd->cbBits == 0);
  728.  
  729.                 fmt.Write(Lookup(cmd->elp.elpPenStyle, Dic_PenStyle));
  730.                 fmt.Put(',');
  731.                 fmt.WriteDec(cmd->elp.elpWidth);
  732.                 
  733.                 fmt.Format(",& LogBrush_%m,%d,NULL);", & cmd->elp.elpNumEntries);
  734.             }
  735.             break;
  736.  
  737.         default:            
  738.             fmt.Format("// Unknown record [%d]", & emr->iType);
  739.     }
  740.  
  741.     return fmt.m_buffer;
  742. }
  743.  
  744.  
  745. // Decompile from an EMF file
  746. bool KEmfDC::DeCompile(const TCHAR * outfile, const char * FileName, 
  747.                   KTreeView * pTree, HENHMETAFILE & hEmf)
  748. {
  749.     if ( ! Open(FileName) )
  750.         return false;
  751.     
  752.     return DeCompileBuffer(outfile, m_View, pTree, hEmf);
  753. }
  754.  
  755.  
  756. // Decompile from an EMF object
  757. bool KEmfDC::DeCompile(const TCHAR * outfile, HENHMETAFILE hEmf, KTreeView * pTree)
  758. {
  759.     int size = GetEnhMetaFileBits(hEmf, 0, NULL);
  760.  
  761.     if ( size<=0 )
  762.         return false;
  763.  
  764.     BYTE * pBits = new BYTE[size];
  765.  
  766.     HCURSOR hOld = SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT)));
  767.  
  768.     GetEnhMetaFileBits(hEmf, size, pBits);
  769.     bool rslt = DeCompileBuffer(outfile, pBits, pTree, hEmf);
  770.  
  771.     DestroyCursor(SetCursor(hOld));
  772.  
  773.     delete [] pBits;
  774.  
  775.     return rslt;
  776. }
  777.  
  778.  
  779. bool IsEMFHeader(const void * buffer)
  780. {
  781.     try
  782.     {
  783.         const ENHMETAHEADER * header = (const ENHMETAHEADER *) buffer;
  784.  
  785.         return ( (header->iType      == EMR_HEADER) && 
  786.                  (header->nVersion   == 0x10000)    &&
  787.                  (header->dSignature == ENHMETA_SIGNATURE) );
  788.     }
  789.     catch (...)
  790.     {
  791.         return false;
  792.     }
  793.  
  794.     return false;
  795. }
  796.  
  797.  
  798. extern HINSTANCE hModule;
  799.  
  800. // main entry for decompiling from a memory buffer
  801. bool KEmfDC::DeCompileBuffer(const TCHAR * outfilename, const void * buffer, KTreeView * pTree, HENHMETAFILE & hEmf)
  802. {
  803.     const EMR * emr = (const EMR *) buffer;
  804.     
  805.     // if not normal EMF file
  806.     while ( ! IsEMFHeader(emr) )
  807.     {
  808.         if ( IsEMFHeader(emr+1) )
  809.         {
  810.             emr ++;
  811.  
  812.             if ( hEmf==NULL )
  813.                 hEmf = SetEnhMetaFileBits(emr[-1].nSize, (const BYTE *) emr);
  814.             
  815.             break;
  816.         }
  817.         else
  818.             emr = (const EMR *) ( ( const char * ) emr + emr->nSize );
  819.     }
  820.  
  821.     const ENHMETAHEADER * pHeader = (const ENHMETAHEADER *) emr;
  822.     
  823.     if ( pTree==NULL )
  824.     {
  825.         fmt.Open(outfilename);
  826.  
  827.         HRSRC hRsc = FindResource(hModule, MAKEINTRESOURCE(IDR_PRE), RT_RCDATA);
  828.         
  829.         if ( hRsc )
  830.         {
  831.             HGLOBAL hResData  = LoadResource(hModule, hRsc);
  832.             const char * pPgm = (const char *) LockResource(hResData);
  833.  
  834.             fmt.Write(pPgm);
  835.         }
  836.  
  837.         fmt.Indent(1);
  838.         fmt.Newline(); fmt.Write("HGDIOBJ hObj["); fmt.WriteDec((long) pHeader->nHandles); fmt.Write("] = { NULL };");
  839.         fmt.Newline();
  840.     }
  841.     m_nSeq = 1;
  842.  
  843.     bool bOptimize = false;
  844.  
  845.     // enumuerate all EMF records
  846.     while ( (emr->iType>=EMR_MIN) && (emr->iType<=EMR_MAX) )
  847.     {
  848.         bool rslt = true;
  849.  
  850.         if ( bOptimize )
  851.         {
  852.             const EMR * next = (const EMR *) ( ( const char * ) emr + emr->nSize );
  853.  
  854.             if ( next->iType == emr->iType )
  855.                 switch ( emr->iType )
  856.                 {
  857.                     case EMR_SETWINDOWORGEX:
  858.                     case EMR_SETWINDOWEXTEX:
  859.                     case EMR_SETVIEWPORTORGEX:
  860.                     case EMR_SETVIEWPORTEXTEX:
  861.                     case EMR_SETTEXTCOLOR:
  862.                     case EMR_SETBKCOLOR:
  863.                     case EMR_SETBRUSHORGEX:
  864.                     case EMR_SELECTCLIPPATH:
  865.                     case EMR_SETTEXTALIGN:
  866.         
  867.                     case EMR_SETBKMODE:
  868.                     case EMR_SETARCDIRECTION:
  869.                     case EMR_SETPOLYFILLMODE:
  870.                     case EMR_SETMAPMODE:
  871.                     case EMR_SETSTRETCHBLTMODE:
  872.                     case EMR_SETMAPPERFLAGS:
  873.                     case EMR_SETICMMODE:
  874.                     case EMR_SETROP2:
  875.  
  876.                     case EMR_SETMITERLIMIT:
  877.                     case EMR_SETWORLDTRANSFORM:
  878.                     case EMR_MOVETOEX:
  879.                         fmt.Write("/* */");
  880.                         break;
  881.                 
  882.                     default:
  883.                         rslt = Decode(emr, pTree);
  884.                 }
  885.             else 
  886.                 rslt = Decode(emr, pTree);
  887.         }
  888.         else
  889.             rslt = Decode(emr, pTree);
  890.         
  891.         if (! rslt ) 
  892.             break;
  893.  
  894.         if ( emr->iType== EMR_EOF )
  895.             break;
  896.  
  897.         emr = (const EMR *) ( ( const char * ) emr + emr->nSize );
  898.     }
  899.     
  900.     if ( pTree==NULL )
  901.     {
  902.         fmt.Indent(-1);
  903.  
  904.         HRSRC hRsc = FindResource(hModule, MAKEINTRESOURCE(IDR_POST), RT_RCDATA);
  905.         
  906.         if ( hRsc )
  907.         {
  908.             HGLOBAL hResData  = LoadResource(hModule, hRsc);
  909.             const char * pPgm = (const char *) LockResource(hResData);
  910.  
  911.             fmt.Write(pPgm);
  912.         }
  913.  
  914.         fmt.Close();
  915.     }
  916.     
  917.     return true;
  918. }