home *** CD-ROM | disk | FTP | other *** search
/ DTP Toolbox / DTPToolbox.iso / utilities / archiveutils / wmf.lha / src / wmf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-04  |  14.2 KB  |  546 lines
  1. /*
  2. *  Windows Metafile Reader
  3. * 
  4. * $Log: wmf.c,v $
  5. *  Revision 1.16  1995/12/04  19:23:10  fuscoj
  6. *  Added debug code.
  7. *
  8. *  Revision 1.15  1995/02/20  21:21:03  JFusco
  9. *  Pre-release.
  10. *
  11. *  Revision 1.14  1994/11/08  22:10:52  JFusco
  12. *  Added iff save.
  13. *
  14. *  Revision 1.13  1994/06/27  22:40:55  JFusco
  15. *  Removed color printf()'s.
  16. *
  17. *  Revision 1.12  1994/06/26  18:03:53  JFusco
  18. *  Better support for colors and brushes, still no fill patterns.
  19. *
  20. *  Revision 1.11  1994/06/25  02:28:03  JFusco
  21. *  Better fills (?).  Tries to match luminance of color values.
  22. *
  23. *  Revision 1.10  1994/06/22  22:22:09  JFusco
  24. *  Checking to determine if Handles are being handled properly.
  25. *
  26. *  Revision 1.9  1994/06/20  23:23:06  JFusco
  27. *  Added polygon fill routines
  28. *
  29. *  Revision 1.8  1994/06/19  22:59:29  JFusco
  30. *  Removed printfs.  Uses stderr for really important info.
  31. *
  32. *  Revision 1.7  1994/06/18  03:10:00  JFusco
  33. *  Lots of changes, too numerous to mention.
  34. *  Added amiga.c and window.c so it now draws to the screen.
  35. *  
  36. */
  37.  
  38. #include <sys/types.h> /* ULONG, UWORD, etc. */
  39. #include <stdio.h>
  40. #include <stdlib.h>
  41. #include <string.h>
  42. #include <assert.h>
  43.  
  44. #include "dformat.h"
  45. #include "wmf.h"
  46. #include "window.h"
  47.  
  48. /* Unconditional pointer test or DIE!!!. */
  49. #define ASSERT(a)   if (!(a)) { perror("no memory!\n"); CleanExit(1); }
  50. #ifndef TRUE
  51. #define TRUE 1
  52. #endif
  53. #ifdef DEBUG
  54. int AbortFlag=0;
  55. int RecCtr=0;
  56. #define DBGREC printf("RecCtr=%d\n",RecCtr);
  57. #else
  58. #define DBGREC
  59. #endif
  60.  
  61. /* Local Prototypes. */
  62. void FunctionHandler( struct rec_tmpl * );
  63. char *wmf_func_name( unsigned short, unsigned char );
  64. unsigned CreateHandle( wmf_objects, struct rec_tmpl * );
  65.  
  66. char            *filename=NULL, *savename=NULL;
  67. wmf_hdr_t       FileHdr;
  68. static wmf_handle_t    *Handle;
  69. static wmf_place_hdr_t PlaceHdr;
  70.  
  71. unsigned     window_okay = 0;
  72.  
  73. main(int argc, char **argv)
  74. {
  75.    FILE *fin;
  76.    unsigned short hbuf[2];
  77.    struct rec_tmpl *Rec;
  78.  
  79.    if ((argc<2) || (! (fin = fopen( argv[1], "rb" )))) {
  80.       fprintf(stderr,"WMF viewer version 1.0 by John Fusco, 1994\n");
  81.       fprintf(stderr,"usage: wmf {wmf_filename} [{save_as_iff}]\n");
  82.       exit(1);
  83.    }
  84.    filename = argv[1];
  85.    if (argc==3) savename = argv[2];
  86.  
  87.    /* Read 4 bytes to determine if this is a normal or placeable metafile. */
  88.    fread( (char *) hbuf, 1, 4, fin );
  89.    reformat_short( hbuf, sizeof(hbuf) );
  90.  
  91.    /* Most files should have the place header. */
  92.    if (hbuf[0] == 0xcdd7 && hbuf[1]==0x9ac6) {
  93.       memcpy( &PlaceHdr, &hbuf[0], 4);
  94.       fread((char *)&PlaceHdr.unused0, 1,sizeof(PlaceHdr)-4,fin);
  95.       reformat_short(&PlaceHdr.unused0, sizeof(PlaceHdr)-4);
  96.  
  97.       /* Set the window extent to maximum until we're told otherwise. */
  98.       WindowExt.X = abs( PlaceHdr.Left - PlaceHdr.Right );
  99.       WindowExt.Y = abs( PlaceHdr.Top - PlaceHdr.Bottom );
  100.  
  101.       /* We can use what we have if necessary. */
  102.       window_okay = TRUE;
  103.  
  104.       /* Read the file header, which immediately follows. */
  105.       fread((char *)&FileHdr, 1,sizeof(FileHdr),fin);
  106.       reformat_short( (unsigned short *)&FileHdr, 4);
  107.    }
  108.    else {
  109.       /* No place header, just a file header. */
  110.       memcpy( &FileHdr, &hbuf[0], sizeof(hbuf));
  111.       fread((char *)&FileHdr.Ver, 1,sizeof(FileHdr)-4,fin);
  112.    }
  113.  
  114.    /* Finish little endian to big endian conversion. */
  115.    reformat_short(&FileHdr.Ver, 14);
  116.    fix_mixed_longs( &FileHdr.Fsize, sizeof(FileHdr.Fsize));
  117.    fix_mixed_longs( &FileHdr.Largest, sizeof(FileHdr.Largest));
  118.  
  119.    /* Sanity checks. */
  120.    if ( FileHdr.Type != 1  || 
  121.         FileHdr.Hsize != 9 || 
  122.         FileHdr.Largest > FileHdr.Fsize ) {
  123.       fprintf(stderr,"Not a Windows Metafile!\n");
  124.       exit(1);
  125.    }
  126.  
  127.    /* All wmf sizes are in 16-bit words. */
  128.    FileHdr.Largest <<= 1;
  129.    Rec = (struct rec_tmpl *) malloc(FileHdr.Largest);
  130.    Handle = (wmf_handle_t *)calloc(sizeof(wmf_handle_t),FileHdr.numHandles);
  131.    if (Rec==NULL || Handle==NULL) {
  132.       perror("allocating initial space.");
  133.       exit(1);
  134.    }
  135.  
  136. #ifdef DEBUG
  137.    fprintf(stderr,"Top Left     x=%6d y=%6d\n",PlaceHdr.Left,PlaceHdr.Top);
  138.    fprintf(stderr,"Bottom Right x=%6d y=%6d\n",PlaceHdr.Right,PlaceHdr.Bottom);
  139.    fprintf(stderr,"%d pixels per inch\n",PlaceHdr.pixelsPerInch);
  140.    fprintf(stderr,"%d Handles used.\n\n",FileHdr.numHandles);
  141. #endif
  142.  
  143.    while ( fread((char *)Rec, 1, 6, fin ) == 6 ) {
  144.  
  145. #ifdef DEBUG
  146.       RecCtr++;
  147. #endif
  148.       /* Little endian to big endian conversion. */
  149.       reformat_long( &Rec->Size, 4);
  150.       reformat_short(&Rec->Func, 2);
  151.  
  152.       Rec->Size <<= 1;
  153.       if (Rec->Size>FileHdr.Largest) {
  154.          fprintf(stderr,"Record too large: %ld bytes; expected %ld\n",
  155.          Rec->Size, FileHdr.Largest);
  156.          break;
  157.       }
  158.  
  159.       /* Read the rest of the record. */
  160.       Rec->Size -= 6;
  161.       if (fread((char *)Rec->Data, 1, Rec->Size, fin ) != Rec->Size ) break;
  162.  
  163.       /* Convert data, any embedded longs will have to be corrected. */
  164.       reformat_short( Rec->Data, Rec->Size );
  165.  
  166.       FunctionHandler( Rec );
  167.  
  168. #ifdef DEBUG
  169.       if (AbortFlag) break;
  170. #endif
  171.    };
  172.  
  173.    fclose(fin);
  174.    if (savename) {
  175.       AmigaSave( savename );
  176.    }
  177.    else {
  178.       AmigaWait();
  179.    }
  180.    CleanExit(0);
  181. }
  182.  
  183. void FunctionHandler( struct rec_tmpl *Rec )
  184. {
  185.    switch( Rec->Func ) {
  186. #ifdef DEBUG
  187.    case WMF_AnimatePalette:
  188.    case WMF_Arc:
  189.    case WMF_BitBlt:
  190.    case WMF_BitBlt3:
  191.    case WMF_Chord:
  192.    case WMF_DrawText:
  193.    case WMF_Ellipse:
  194.    case WMF_Escape:
  195.    case WMF_ExcludeClipRect:
  196.    case WMF_ExtTextOut:
  197.    case WMF_FloodFill:
  198.    case WMF_InsertClipRect:
  199.    case WMF_LineTo:
  200.    case WMF_MoveTo:
  201.    case WMF_OffsetClipRgn:
  202.    case WMF_OffsetViewportOrg:
  203.    case WMF_OffsetWindowOrg:
  204.    case WMF_PatBlt:
  205.    case WMF_Pie:
  206.    case WMF_PolyPolygon:
  207.    case WMF_RealizePalette:
  208.    case WMF_Rectangle:
  209.    case WMF_ResizePalette:
  210.    case WMF_RestoreDC:
  211.    case WMF_RoundRect:
  212.    case WMF_SaveDC:
  213.    case WMF_ScaleViewportExt:
  214.    case WMF_ScaleWindowExt:
  215.    case WMF_SelectClipRgn:
  216.    case WMF_SelectPalette:
  217.    case WMF_SetBkColor:
  218.    case WMF_SetBkMode:
  219.    case WMF_SetDIBitsToDevice:
  220.    case WMF_SetMapMode:
  221.    case WMF_SetMapperFlags:
  222.    case WMF_SetPaletteEntries:
  223.    case WMF_SetPixel:
  224.    case WMF_SetStretchBltMode:
  225.    case WMF_SetTextAlign:
  226.    case WMF_SetTextCharExtra:
  227.    case WMF_SetTextColor:
  228.    case WMF_SetTextJustification:
  229.    case WMF_SetViewportExt:
  230.    case WMF_SetViewportOrg:
  231.    case WMF_StretchBlt:
  232.    case WMF_StretchBlt3:
  233.    case WMF_StretchDIBits:
  234.    case WMF_TextOut:
  235.         MyDeepestApologies( Rec->Func );
  236.         break;
  237. #endif
  238.    /* Got to keep track of these even if I don't implement them. */
  239.    case WMF_CreateFontIndirect:
  240.         CreateHandle( FONT, Rec );
  241.         break;
  242.  
  243.    case WMF_CreatePalette:
  244.         CreateHandle( PALETTE, Rec );
  245.         break;
  246.  
  247.    case WMF_CreatePatternBrush:
  248.         CreateHandle( PATTERNBRUSH, Rec );
  249.         break;
  250.  
  251.    case WMF_CreatePatternBrush3:
  252.         CreateHandle( PATTERNBRUSH3, Rec );
  253.         break;
  254.  
  255.    case WMF_CreateRegion:
  256.         MyDeepestApologies( Rec->Func );
  257.         fprintf(stderr,"Did you know this function is undocumented!\n");
  258.         CleanExit(1);
  259.         break;
  260.  
  261.    /* Stuff I've actually implemented!!! (or plan to).*/
  262.    case WMF_CreatePenIndirect:
  263.         {
  264.           static WarnPenColor=1;
  265.           pen_t *Pen = (pen_t *) Rec->Data;
  266.           fix_mixed_longs( &Pen->Color, 4 );
  267.           if (Pen->Color.IDX.Type==1 && WarnPenColor) {
  268.              WarnPenColor=0;
  269.              fprintf(stderr,"Color index not implemented: %08lx\n",
  270.                                                            Pen->Color);
  271.           }
  272.         }
  273.         CreateHandle( PEN, Rec );
  274.         break;
  275.  
  276.    case WMF_CreateBrushIndirect:
  277.         {
  278.           static WarnBrushColor=1;
  279.           brush_t *Brush = (brush_t *) Rec->Data;
  280.           fix_mixed_longs( &Brush->Color, 4 );
  281.           if (Brush->Color.IDX.Type==1 && WarnBrushColor) {
  282.              DBGREC;
  283.              WarnBrushColor=0;
  284.              fprintf(stderr,"Color index not implemented: %08lx\n",
  285.                                                            Brush->Color);
  286.           }
  287.         }
  288.         CreateHandle( BRUSH, Rec );
  289.         break;
  290.  
  291.    case WMF_SelectObject:
  292.         assert( Rec->Data[0]<FileHdr.numHandles && Rec->Data[0] >= 0 );
  293.     SelectObject( Rec->Data[0] );
  294.         break;
  295.  
  296.    case WMF_DeleteObject:
  297.         assert( Rec->Data[0]<FileHdr.numHandles && Rec->Data[0] >= 0 );
  298.         {
  299.            unsigned idx = Rec->Data[0];
  300.            Handle[idx].Type = NOTANOBJ;
  301.            free( Handle[idx].Data );
  302.            Handle[idx].Data = NULL;
  303.         }
  304.         break;
  305.  
  306.  
  307.    case WMF_Polygon:
  308.         {
  309.           unsigned i;
  310.           poly_point_tmpl_t *Poly= (poly_point_tmpl_t *) Rec->Data;
  311.  
  312.           PolygonMoveWC( Poly->Point[0].X, Poly->Point[0].Y );
  313.           for (i=1; i<Poly->numPoints; i++) {
  314.             PolygonDrawWC( Poly->Point[i].X, Poly->Point[i].Y );
  315.           }
  316.           PolygonEndWC();
  317.         }
  318.         break;
  319.  
  320.    case WMF_Polyline:
  321.         {
  322.           unsigned i;
  323.           poly_point_tmpl_t *Poly= (poly_point_tmpl_t *) Rec->Data;
  324.  
  325.           MoveWC( Poly->Point[0].X, Poly->Point[0].Y );
  326.           for (i=1; i<Poly->numPoints; i++) {
  327.             DrawWC( Poly->Point[i].X, Poly->Point[i].Y );
  328.           }
  329.         }
  330.         break;
  331.  
  332.    case WMF_SetPolyFillMode:
  333.         {
  334.            static warn=0;
  335.            if (warn==0) {
  336.               DBGREC;
  337.               warn = 1;
  338.               fprintf(stderr,"Using default fill mode\n");
  339.            }
  340.         }
  341.         break;
  342.  
  343.    case WMF_SetWindowExt:
  344.         memcpy( &WindowExt, &Rec->Data[0], sizeof(WindowExt));
  345.         InitVirtualWindow( &PlaceHdr );
  346.         OpenAmigaWindow();
  347.         break;
  348.  
  349.    case WMF_SetWindowOrg:
  350.         memcpy( &WindowOrg, &Rec->Data[0], sizeof(WindowOrg));
  351.         break;
  352.  
  353.    case WMF_SetROP2:
  354.         SetDrawingMode( Rec->Data[0] ); 
  355.         break;
  356.  
  357.    case WMF_Null:
  358.         break;
  359.  
  360.    default:
  361.         DBGREC;
  362.         fprintf(stderr,"%s: Unknown function (%x)\n", filename, Rec->Func);
  363.         break;
  364.    }
  365.    return;
  366. }
  367.  
  368. MyDeepestApologies( USHORT Func )
  369. {
  370.    DBGREC;
  371.    fprintf(stderr,"WARNING: %s unimplemented and is being ignored!\n",
  372.                    wmf_func_name( Func, 0 ));
  373. }
  374.  
  375. CleanExit(int x)
  376. {
  377.    CleanAmiga();
  378.    exit(x);
  379. }
  380.  
  381. /* Lookup values for metafile functions. */
  382. struct function_code {
  383.    unsigned short opcode;
  384.    char *name, found; 
  385. } wmf_function[] = {
  386.       {0x000,"Null",0},
  387.       {0x01e,"SaveDC",0},
  388.       {0x035,"RealizePalette",0},
  389.       {0x037,"SetPaletteEntries",0},
  390.       {0x0f7,"CreatePalette",0},
  391.       {0x102,"SetBkMode",0},
  392.       {0x103,"SetMapMode",0},
  393.       {0x104,"SetROP2",0},
  394.       {0x106,"SetPolyFillMode",0},
  395.       {0x107,"SetStretchBltMode",0},
  396.       {0x108,"SetTextCharExtra",0},
  397.       {0x127,"RestoreDC",0},
  398.       {0x12c,"SelectClipRgn",0},
  399.       {0x12d,"SelectObject",0},
  400.       {0x12e,"SetTextAlign",0},
  401.       {0x139,"ResizePalette",0},
  402.       {0x142,"CreatePatternBrush3",0},
  403.       {0x1f0,"DeleteObject",0},
  404.       {0x1f9,"CreatePatternBrush",0},
  405.       {0x201,"SetBkColor",0},
  406.       {0x209,"SetTextColor",0},
  407.       {0x20a,"SetTextJustification",0},
  408.       {0x20b,"SetWindowOrg",0},
  409.       {0x20c,"SetWindowExt",0},
  410.       {0x20d,"SetViewportOrg",0},
  411.       {0x20e,"SetViewportExt",0},
  412.       {0x20f,"OffsetWindowOrg",0},
  413.       {0x211,"OffsetViewportOrg",0},
  414.       {0x213,"LineTo",0},
  415.       {0x214,"MoveTo",0},
  416.       {0x220,"OffsetClipRgn",0},
  417.       {0x231,"SetMapperFlags",0},
  418.       {0x234,"SelectPalette",0},
  419.       {0x2fa,"CreatePenIndirect",0},
  420.       {0x2fb,"CreateFontIndirect",0},
  421.       {0x2fc,"CreateBrushIndirect",0},
  422.       {0x324,"Polygon",0},
  423.       {0x325,"Polyline",0},
  424.       {0x400,"ScaleWindowExt",0},
  425.       {0x412,"ScaleViewportExt",0},
  426.       {0x415,"ExcludeClipRect",0},
  427.       {0x416,"InsertClipRect",0},
  428.       {0x418,"Ellipse",0},
  429.       {0x419,"FloodFill",0},
  430.       {0x41b,"Rectangle",0},
  431.       {0x41f,"SetPixel",0},
  432.       {0x436,"AnimatePalette",0},
  433.       {0x521,"TextOut",0},
  434.       {0x538,"PolyPolygon",0},
  435.       {0x61c,"RoundRect",0},
  436.       {0x61d,"PatBlt",0},
  437.       {0x626,"Escape",0},
  438.       {0x62f,"DrawText",0},
  439.       {0x6ff,"CreateRegion",0},
  440.       {0x817,"Arc",0},
  441.       {0x81a,"Pie",0},
  442.       {0x830,"Chord",0},
  443.       {0x922,"BitBlt",0},
  444.       {0x940,"BitBlt3",0},
  445.       {0xa32,"ExtTextOut",0},
  446.       {0xb23,"StretchBlt",0},
  447.       {0xb41,"StretchBlt3",0},
  448.       {0xd33,"SetDIBitsToDevice",0},
  449.       {0xf43,"StretchDIBits",0},
  450.       {0xffff,"Unknown Function",0} /* This must be last */
  451. };
  452.  
  453. char *wmf_func_name( unsigned short func, unsigned char dup )
  454. {
  455.    unsigned i;
  456.  
  457.    /* Last function will be "Unknown" if we got through the loop
  458.    /* without a find. */
  459.    for(i=0; i<sizeof(wmf_function)/sizeof(wmf_function[0]); i++) {
  460.       if (wmf_function[i].opcode >= func) break;
  461.    }
  462.    if ((wmf_function[i].opcode == func) && ! (wmf_function[i].found) ) {
  463.       if (dup) wmf_function[i].found = 1;
  464.       return( wmf_function[i].name );
  465.    }
  466.    else if (wmf_function[i].found)
  467.      return( NULL );
  468.    else
  469.      return( wmf_function[i].name ); /* Unknown function. */
  470. }
  471.  
  472. SelectObject( unsigned short idx )
  473. {
  474.    /* NOTANOBJ, BRUSH, FONT, PALETTE, PATTERNBRUSH, PATTERNBRUSH3, PEN */
  475.    switch ( Handle[idx].Type ) {
  476.  
  477.    case PEN:
  478.       SetPenStyleAmiga( Handle[idx].Data );
  479.       break;
  480.  
  481.    case BRUSH:
  482.       SetBrushStyleAmiga( Handle[idx].Data );
  483.       break;
  484.  
  485.    case FONT:
  486.       {
  487.          static warn=0;
  488.          if (!(warn)) {
  489.             warn=1;
  490.             DBGREC;
  491.             fprintf(stderr,"Font objects not selectable\n"); 
  492.          }
  493.       }
  494.       break;
  495.  
  496.    case PALETTE:
  497.       {
  498.          static warn=0;
  499.          if (!(warn)) {
  500.             warn=1;
  501.             DBGREC;
  502.             fprintf(stderr,"Palette objects not selectable\n"); 
  503.          }
  504.       }
  505.       break;
  506.  
  507.    case PATTERNBRUSH:
  508.    case PATTERNBRUSH3:
  509.       {
  510.          static warn=0;
  511.          if (!(warn)) {
  512.             warn=1;
  513.             DBGREC;
  514.             fprintf(stderr,"Pattern brush objects not selectable\n"); 
  515.          }
  516.       }
  517.       break;
  518.  
  519.    default:
  520.       DBGREC;
  521.       fprintf(stderr,"Unimplemented object selected %ld\n",Handle[idx].Type); 
  522.       break;
  523.    };
  524. }
  525.  
  526. unsigned CreateHandle( wmf_objects Type, struct rec_tmpl *Rec )
  527. {
  528.    unsigned i;
  529.  
  530.    /* Find free slot. */
  531.    for (i=0; i<FileHdr.numHandles; i++) {
  532.       if (Handle[i].Type == NOTANOBJ) break;
  533.    };
  534.  
  535.    if (i>=FileHdr.numHandles) {
  536.       fprintf(stderr,"Corrupt WMF file!  Bad handle.\n");
  537.       CleanExit(1);
  538.    };
  539.       
  540.    Handle[i].Type = Type;
  541.    Handle[i].Data = (USHORT *) malloc( Rec->Size );
  542.    ASSERT(Handle[i].Data);
  543.    memcpy( &Handle[i].Data[0], &Rec->Data[0], Rec->Size );
  544.    return i;
  545. }
  546.