2668 lines
89 KiB
C
2668 lines
89 KiB
C
|
|
/****************************************************************************
|
|
Module Quickdrw: Implementation
|
|
*****************************************************************************
|
|
|
|
This is the interpreter engine for the picture convertor. It uses a
|
|
modified CGrafPort structure to hold the intermediate results of a
|
|
translation that can later be accessed from the Gdi module. As such,
|
|
it provides an input cache for all attributes, with calls made
|
|
directly to the Gdi module for primitives.
|
|
|
|
It is called by the API module and will call the Get module in order
|
|
to read individual data or record elements from the data stream.
|
|
|
|
Module prefix: QD
|
|
|
|
****************************************************************************/
|
|
|
|
#include "headers.c"
|
|
#pragma hdrstop
|
|
|
|
/* C libraries */
|
|
#include "string.h"
|
|
#include <ctype.h>
|
|
|
|
/* quickdrw's own interface */
|
|
#include "qdopcode.i"
|
|
#include "qdcoment.i"
|
|
|
|
/* imported modules */
|
|
#include <math.h>
|
|
#include "filesys.h"
|
|
#include "getdata.h"
|
|
|
|
/*********************** Exported Data Initialization ***********************/
|
|
|
|
|
|
/******************************* Private Data *******************************/
|
|
|
|
/*--- QuickDraw grafPort simulation --- */
|
|
|
|
#define Version1ID 0x1101
|
|
#define Version2ID 0x02FF
|
|
|
|
|
|
/*--- QuickDraw opcode fields --- */
|
|
|
|
/* -1 is casted to Word to prevent warning in WIN32 compilation */
|
|
#define Reserved (Word) -1
|
|
|
|
#define Variable -1
|
|
#define CommentSize -2
|
|
#define RgnOrPolyLen -3
|
|
#define WordDataLen -4
|
|
#define DWordDataLen -5
|
|
#define HiByteLen -6
|
|
|
|
typedef struct
|
|
{
|
|
Word function;
|
|
Integer length;
|
|
} opcodeEntry, far * opcodeEntryLPtr;
|
|
|
|
/* The following opcode table was taken from "Inside Macintosh, Volume V" on
|
|
pages V-97 to V-102 and supplemented by System 7 opcodes from "Inside
|
|
Macintosh, Volume VI", page 17-20. */
|
|
|
|
#define LookupTableSize 0xA2
|
|
|
|
private opcodeEntry opcodeLookup[LookupTableSize] =
|
|
{
|
|
/* 0x00 */ { NOP, 0 },
|
|
/* 0x01 */ { Clip, RgnOrPolyLen },
|
|
/* 0x02 */ { BkPat, 8 },
|
|
/* 0x03 */ { TxFont, 2 },
|
|
/* 0x04 */ { TxFace, 1 },
|
|
/* 0x05 */ { TxMode, 2 },
|
|
/* 0x06 */ { SpExtra, 4 },
|
|
/* 0x07 */ { PnSize, 4 },
|
|
/* 0x08 */ { PnMode, 2 },
|
|
/* 0x09 */ { PnPat, 8 },
|
|
/* 0x0A */ { FillPat, 8 },
|
|
/* 0x0B */ { OvSize, 4 },
|
|
/* 0x0C */ { Origin, 4 },
|
|
/* 0x0D */ { TxSize, 2 },
|
|
/* 0x0E */ { FgColor, 4 },
|
|
/* 0x0F */ { BkColor, 4 },
|
|
/* 0x10 */ { TxRatio, 8 },
|
|
/* 0x11 */ { Version, 1 },
|
|
/* 0x12 */ { BkPixPat, Variable },
|
|
/* 0x13 */ { PnPixPat, Variable },
|
|
/* 0x14 */ { FillPixPat, Variable },
|
|
/* 0x15 */ { PnLocHFrac, 2 },
|
|
/* 0x16 */ { ChExtra, 2 },
|
|
/* 0x17 */ { Reserved, 0 },
|
|
/* 0x18 */ { Reserved, 0 },
|
|
/* 0x19 */ { Reserved, 0 },
|
|
/* 0x1A */ { RGBFgCol, 6 },
|
|
/* 0x1B */ { RGBBkCol, 6 },
|
|
/* 0x1C */ { HiliteMode, 0 },
|
|
/* 0x1D */ { HiliteColor, 6 },
|
|
/* 0x1E */ { DefHilite, 0 },
|
|
/* 0x1F */ { OpColor, 6 },
|
|
/* 0x20 */ { Line, 8 },
|
|
/* 0x21 */ { LineFrom, 4 },
|
|
/* 0x22 */ { ShortLine, 6 },
|
|
/* 0x23 */ { ShortLineFrom, 2 },
|
|
/* 0x24 */ { Reserved, WordDataLen },
|
|
/* 0x25 */ { Reserved, WordDataLen },
|
|
/* 0x26 */ { Reserved, WordDataLen },
|
|
/* 0x27 */ { Reserved, WordDataLen },
|
|
/* 0x28 */ { LongText, Variable },
|
|
/* 0x29 */ { DHText, Variable },
|
|
/* 0x2A */ { DVText, Variable },
|
|
/* 0x2B */ { DHDVText, Variable },
|
|
/* 0x2C */ { FontName, WordDataLen },
|
|
/* 0x2D */ { LineJustify, WordDataLen },
|
|
/* 0x2E */ { Reserved, WordDataLen },
|
|
/* 0x2F */ { Reserved, WordDataLen },
|
|
/* 0x30 */ { frameRect, 8 },
|
|
/* 0x31 */ { paintRect, 8 },
|
|
/* 0x32 */ { eraseRect, 8 },
|
|
/* 0x33 */ { invertRect, 8 },
|
|
/* 0x34 */ { fillRect, 8 },
|
|
/* 0x35 */ { Reserved, 8 },
|
|
/* 0x36 */ { Reserved, 8 },
|
|
/* 0x37 */ { Reserved, 8 },
|
|
/* 0x38 */ { frameSameRect, 0 },
|
|
/* 0x39 */ { paintSameRect, 0 },
|
|
/* 0x3A */ { eraseSameRect, 0 },
|
|
/* 0x3B */ { invertSameRect, 0 },
|
|
/* 0x3C */ { fillSameRect, 0 },
|
|
/* 0x3D */ { Reserved, 0 },
|
|
/* 0x3E */ { Reserved, 0 },
|
|
/* 0x3F */ { Reserved, 0 },
|
|
/* 0x40 */ { frameRRect, 8 },
|
|
/* 0x41 */ { paintRRect, 8 },
|
|
/* 0x42 */ { eraseRRect, 8 },
|
|
/* 0x43 */ { invertRRect, 8 },
|
|
/* 0x44 */ { fillRRect, 8 },
|
|
/* 0x45 */ { Reserved, 8 },
|
|
/* 0x46 */ { Reserved, 8 },
|
|
/* 0x47 */ { Reserved, 8 },
|
|
/* 0x48 */ { frameSameRRect, 0 },
|
|
/* 0x49 */ { paintSameRRect, 0 },
|
|
/* 0x4A */ { eraseSameRRect, 0 },
|
|
/* 0x4B */ { invertSameRRect, 0 },
|
|
/* 0x4C */ { fillSameRRect, 0 },
|
|
/* 0x4D */ { Reserved, 0 },
|
|
/* 0x4E */ { Reserved, 0 },
|
|
/* 0x4F */ { Reserved, 0 },
|
|
/* 0x50 */ { frameOval, 8 },
|
|
/* 0x51 */ { paintOval, 8 },
|
|
/* 0x52 */ { eraseOval, 8 },
|
|
/* 0x53 */ { invertOval, 8 },
|
|
/* 0x54 */ { fillOval, 8 },
|
|
/* 0x55 */ { Reserved, 8 },
|
|
/* 0x56 */ { Reserved, 8 },
|
|
/* 0x57 */ { Reserved, 8 },
|
|
/* 0x58 */ { frameSameOval, 0 },
|
|
/* 0x59 */ { paintSameOval, 0 },
|
|
/* 0x5A */ { eraseSameOval, 0 },
|
|
/* 0x5B */ { invertSameOval, 0 },
|
|
/* 0x5C */ { fillSameOval, 0 },
|
|
/* 0x5D */ { Reserved, 0 },
|
|
/* 0x5E */ { Reserved, 0 },
|
|
/* 0x5F */ { Reserved, 0 },
|
|
/* 0x60 */ { frameArc, 12 },
|
|
/* 0x61 */ { paintArc, 12 },
|
|
/* 0x62 */ { eraseArc, 12 },
|
|
/* 0x63 */ { invertArc, 12 },
|
|
/* 0x64 */ { fillArc, 12 },
|
|
/* 0x65 */ { Reserved, 12 },
|
|
/* 0x66 */ { Reserved, 12 },
|
|
/* 0x67 */ { Reserved, 12 },
|
|
/* 0x68 */ { frameSameArc, 4 },
|
|
/* 0x69 */ { paintSameArc, 4 },
|
|
/* 0x6A */ { eraseSameArc, 4 },
|
|
/* 0x6B */ { invertSameArc, 4 },
|
|
/* 0x6C */ { fillSameArc, 4 },
|
|
/* 0x6D */ { Reserved, 4 },
|
|
/* 0x6E */ { Reserved, 4 },
|
|
/* 0x6F */ { Reserved, 4 },
|
|
/* 0x70 */ { framePoly, RgnOrPolyLen },
|
|
/* 0x71 */ { paintPoly, RgnOrPolyLen },
|
|
/* 0x72 */ { erasePoly, RgnOrPolyLen },
|
|
/* 0x73 */ { invertPoly, RgnOrPolyLen },
|
|
/* 0x74 */ { fillPoly, RgnOrPolyLen },
|
|
/* 0x75 */ { Reserved, RgnOrPolyLen },
|
|
/* 0x76 */ { Reserved, RgnOrPolyLen },
|
|
/* 0x77 */ { Reserved, RgnOrPolyLen },
|
|
/* 0x78 */ { frameSamePoly, 0 },
|
|
/* 0x79 */ { paintSamePoly, 0 },
|
|
/* 0x7A */ { eraseSamePoly, 0 },
|
|
/* 0x7B */ { invertSamePoly, 0 },
|
|
/* 0x7C */ { fillSamePoly, 0 },
|
|
/* 0x7D */ { Reserved, 0 },
|
|
/* 0x7E */ { Reserved, 0 },
|
|
/* 0x7F */ { Reserved, 0 },
|
|
/* 0x80 */ { frameRgn, RgnOrPolyLen },
|
|
/* 0x81 */ { paintRgn, RgnOrPolyLen },
|
|
/* 0x82 */ { eraseRgn, RgnOrPolyLen },
|
|
/* 0x83 */ { invertRgn, RgnOrPolyLen },
|
|
/* 0x84 */ { fillRgn, RgnOrPolyLen },
|
|
/* 0x85 */ { Reserved, RgnOrPolyLen },
|
|
/* 0x86 */ { Reserved, RgnOrPolyLen },
|
|
/* 0x87 */ { Reserved, RgnOrPolyLen },
|
|
/* 0x88 */ { frameSameRgn, 0 },
|
|
/* 0x89 */ { paintSameRgn, 0 },
|
|
/* 0x8A */ { eraseSameRgn, 0 },
|
|
/* 0x8B */ { invertSameRgn, 0 },
|
|
/* 0x8C */ { fillSameRgn, 0 },
|
|
/* 0x8D */ { Reserved, 0 },
|
|
/* 0x8E */ { Reserved, 0 },
|
|
/* 0x8F */ { Reserved, 0 },
|
|
/* 0x90 */ { BitsRect, Variable },
|
|
/* 0x91 */ { BitsRgn, Variable },
|
|
/* 0x92 */ { Reserved, WordDataLen },
|
|
/* 0x93 */ { Reserved, WordDataLen },
|
|
/* 0x94 */ { Reserved, WordDataLen },
|
|
/* 0x95 */ { Reserved, WordDataLen },
|
|
/* 0x96 */ { Reserved, WordDataLen },
|
|
/* 0x97 */ { Reserved, WordDataLen },
|
|
/* 0x98 */ { PackBitsRect, Variable },
|
|
/* 0x99 */ { PackBitsRgn, Variable },
|
|
/* 0x9A */ { DirectBitsRect, WordDataLen },
|
|
/* 0x9B */ { DirectBitsRgn, WordDataLen },
|
|
/* 0x9C */ { Reserved, WordDataLen },
|
|
/* 0x9D */ { Reserved, WordDataLen },
|
|
/* 0x9E */ { Reserved, WordDataLen },
|
|
/* 0x9F */ { Reserved, WordDataLen },
|
|
/* 0xA0 */ { ShortComment, 2 },
|
|
/* 0xA1 */ { LongComment, CommentSize }
|
|
};
|
|
|
|
#define RangeTableSize 7
|
|
|
|
private opcodeEntry opcodeRange[RangeTableSize] =
|
|
{
|
|
/* 0x00A2 - 0x00AF */ { 0x00AF, WordDataLen },
|
|
/* 0x00B0 - 0x00CF */ { 0x00CF, 0 },
|
|
/* 0x00D0 - 0x00FE */ { 0x00FE, DWordDataLen },
|
|
/* 0x00FF - 0x00FF */ { opEndPic, 0 },
|
|
/* 0x0100 - 0x07FF */ { 0x8000, HiByteLen },
|
|
/* 0x8000 - 0x80FF */ { 0x80FF, 0 },
|
|
/* 0x8100 - 0xFFFF */ { 0xFFFF, DWordDataLen }
|
|
};
|
|
|
|
/*--- EPS Filter PostScript Strings ---*/
|
|
|
|
#define MAC_PS_TRAILER "pse\rpsb\r"
|
|
#define MAC_PS_PREAMBLE "pse\rcurrentpoint\r/picTop exch def\r/picLeft exch def\rpsb\r"
|
|
|
|
#define SUPERPAINT_TEXTSTARTJUNK "P2_b ["
|
|
#define SUPERPAINT_TEXTSTOPJUNK "] sb end\r"
|
|
|
|
/*--- GrafPort allocation ---*/
|
|
|
|
#define PARSEPOLY 1
|
|
#define SKIPALTPOLY 2
|
|
#define USEALTPOLY 3
|
|
|
|
#define MASKPOLYBITS 0x07
|
|
#define FRAMEPOLY 0x01
|
|
#define FILLPOLY 0x02
|
|
#define CLOSEPOLY 0x04
|
|
#define FILLREQUIRED 0x08
|
|
#define CHECK4SPLINE 0x10
|
|
|
|
#define POLYLIST ((sizeof( Integer ) + sizeof( Rect )) / sizeof( Integer ))
|
|
#define BBOX 1
|
|
|
|
private CGrafPort grafPort;
|
|
private Integer resolution;
|
|
private Boolean skipFontID;
|
|
private Integer maxPoints;
|
|
private Integer numPoints;
|
|
private Integer far * numPointsLPtr;
|
|
private Rect polyBBox;
|
|
private Point far * polyListLPtr;
|
|
private Handle polyHandle;
|
|
private Byte polyMode;
|
|
private Byte polyParams;
|
|
private RGBColor polyFgColor;
|
|
private RGBColor polyBkColor;
|
|
private Boolean zeroDeltaExpected;
|
|
|
|
private Boolean textMode;
|
|
private Boolean newTextCenter;
|
|
private Point textCenter;
|
|
private Boolean textClipCheck;
|
|
private Real degCos;
|
|
private Real degSin;
|
|
|
|
private Boolean shadedObjectStarted;
|
|
private Boolean superPaintFile;
|
|
private Boolean badSuperPaintText;
|
|
|
|
/*--- last Primitive sent ---*/
|
|
|
|
private Rect saveRect;
|
|
private Rect saveRRect;
|
|
private Rect saveOval;
|
|
private Point saveOvalSize;
|
|
private Rect saveArc;
|
|
private Integer saveStartAngle;
|
|
private Integer saveArcAngle;
|
|
|
|
/*--- Global allocated contstants ---*/
|
|
|
|
private Pattern SolidPattern = { 0xFF, 0xFF, 0xFF, 0xFF,
|
|
0xFF, 0xFF, 0xFF, 0xFF };
|
|
|
|
|
|
/*********************** Private Routine Declarations ***********************/
|
|
|
|
private void ReadHeaderInfo( void );
|
|
/* read the fixed size PICT header from the file. This provides information
|
|
about the file size (however, it may be invalid and is ignored) and the
|
|
picture bounding box, followed by the PICT version information. */
|
|
|
|
private void ReadPictVersion( void );
|
|
/* Read the PICT version number from the data file. If this isn't a
|
|
version 1 or 2 file, the routine returns IE_UNSUPP_VERSION error. */
|
|
|
|
private void ReadOpcode( opcodeEntry far * nextOpcode );
|
|
/* Reads the next opcode from the stream, depending on the PICT version */
|
|
|
|
private void TranslateOpcode( opcodeEntry far * currOpcodeLPtr );
|
|
/* read in the remaining data from the stream, based upon the opcode function
|
|
and then call the appropriate routine in Gdi module */
|
|
|
|
private void SkipData( opcodeEntry far * currOpcodeLPtr );
|
|
/* skip the data - the opcode won't be translated and Gdi module won't be
|
|
called to create anything in the metafile */
|
|
|
|
private void OpenPort( void );
|
|
/* initialize the grafPort */
|
|
|
|
private void ClosePort( void );
|
|
/* close grafPort and de-allocate any memory blocks */
|
|
|
|
private void NewPolygon( void );
|
|
/* initialize the state of the polygon buffer - flush any previous data */
|
|
|
|
private void AddPolySegment( Point start, Point end );
|
|
/* Add the line segment to the polygon buffer */
|
|
|
|
private void DrawPolyBuffer( void );
|
|
/* Draw the polygon definition if the points were read without errors */
|
|
|
|
private void AdjustTextRotation( Point far * newPt );
|
|
/* This will calculate the correct text position if text is rotated */
|
|
|
|
private Integer EPSComment(Word comment);
|
|
/* parse EPS Comment */
|
|
|
|
private Integer EPSData(Integer state);
|
|
/* process EPS Data */
|
|
|
|
private Boolean EPSBbox(PSBuf far *, Rect far *);
|
|
/* parse EPS bounding box description */
|
|
|
|
private char far* parse_number(char far* ptr, Integer far *iptr);
|
|
/* parse numeric string (local to EPSBbox) */
|
|
|
|
#define IsCharDigit(c) (IsCharAlphaNumeric(c) && !IsCharAlpha(c))
|
|
|
|
/**************************** Function Implementation ***********************/
|
|
|
|
void QDConvertPicture( Handle dialogHandle )
|
|
/*====================*/
|
|
/* create a Windows metafile using the previously set parameters, returning
|
|
the converted picture information in the pictResult structure. */
|
|
|
|
{
|
|
opcodeEntry currOpcode;
|
|
|
|
/* Open the file - if an error occured, return to main */
|
|
IOOpenPicture( dialogHandle );
|
|
|
|
/* Tell Gdi module to open the metafile */
|
|
GdiOpenMetafile();
|
|
|
|
/* initialize the grafPort */
|
|
OpenPort();
|
|
|
|
/* read and validate size, bounding box, and PICT version */
|
|
ReadHeaderInfo();
|
|
|
|
do
|
|
{
|
|
/* read the next opcode from the data stream */
|
|
ReadOpcode( &currOpcode );
|
|
|
|
/* read the ensuing data and call Gdi module entry points */
|
|
TranslateOpcode( &currOpcode );
|
|
|
|
/* align next memory read to Word boundary in the case of PICT 2 */
|
|
if (grafPort.portVersion == 2)
|
|
{
|
|
IOAlignToWordOffset();
|
|
}
|
|
|
|
/* update the status dialog with current progress */
|
|
IOUpdateStatus();
|
|
|
|
/* break out of loop if end picture opcode is encountered */
|
|
} while (currOpcode.function != opEndPic);
|
|
|
|
/* close grafPort and de-allocate any used memory blocks */
|
|
ClosePort();
|
|
|
|
/* Tell Gdi module that picture is ending - perform wrapup */
|
|
GdiCloseMetafile();
|
|
|
|
/* Close the file */
|
|
IOClosePicture();
|
|
|
|
} /* ReFileToPicture */
|
|
|
|
|
|
void QDGetPort( CGrafPort far * far * port )
|
|
/*============*/
|
|
/* return handle to grafPort structure */
|
|
{
|
|
*port = &grafPort;
|
|
}
|
|
|
|
|
|
void QDCopyBytes( Byte far * src, Byte far * dest, Integer numBytes )
|
|
/*==============*/
|
|
/* copy a data from source to destination */
|
|
{
|
|
/* loop through entire data length */
|
|
while (numBytes--)
|
|
{
|
|
*dest++ = *src++;
|
|
}
|
|
|
|
} /* CopyBytes */
|
|
|
|
|
|
/******************************* Private Routines ***************************/
|
|
|
|
|
|
private void ReadHeaderInfo( void )
|
|
/*-------------------------*/
|
|
/* read the fixed size PICT header from the file. This provides information
|
|
about the file size (however, it may be invalid and is ignored) and the
|
|
picture bounding box, followed by the PICT version information. */
|
|
{
|
|
Word unusedSize;
|
|
|
|
/* read file size - this value is ignored since it may be totally bogus */
|
|
GetWord( &unusedSize );
|
|
|
|
/* the next rectangle contains the picture bounding box */
|
|
GetRect( &grafPort.portRect );
|
|
|
|
/* Read the next record that indicates a PICT1 or PICT2 version picture */
|
|
ReadPictVersion();
|
|
|
|
/* Call Gdi module and provide bounding box coordinates. Note that these
|
|
may have been altered from rectangle specified above if a spatial
|
|
resolution other than 72 dpi is used in the picture. */
|
|
GdiSetBoundingBox( grafPort.portRect, resolution );
|
|
|
|
} /* ReadHeaderInfo */
|
|
|
|
|
|
private void ReadPictVersion( void )
|
|
/*--------------------------*/
|
|
/* Read the PICT version number from the data file. If this isn't a
|
|
version 1 or 2 file, the routine returns IE_UNSUPP_VERSION error. */
|
|
{
|
|
opcodeEntry versionOpcode;
|
|
Word versionCheck = 0;
|
|
Word opcodeCheck = 0;
|
|
|
|
/* The following loop was added in order to read PixelPaint files
|
|
successfully. Although technically an invalid PICT image, these files
|
|
contain a series of NOP opcodes, followed by the version opcode. In
|
|
this case, we continue reading until the version opcode (non-zero
|
|
value) is encountered, after which the checking continues. */
|
|
do
|
|
{
|
|
/* read the first two bytes from the data stream - for PICT 1 this is
|
|
both the opcode and version; for PICT 2 this is the opcode only. */
|
|
GetWord( &versionCheck );
|
|
|
|
} while ((versionCheck == NOP) && (ErGetGlobalError() == ErNoError));
|
|
|
|
/* determine if a valid version opcode was encountered */
|
|
if (versionCheck == Version1ID )
|
|
{
|
|
/* version 1 == 0x1101 */
|
|
grafPort.portVersion = 1;
|
|
}
|
|
/* check for version 2 opcode which is a Word in length */
|
|
else if (versionCheck == Version)
|
|
{
|
|
/* Since we have only read the opcode, read the next word which should
|
|
contain the identifier for PICT 2 data. */
|
|
GetWord( &versionCheck );
|
|
if (versionCheck == Version2ID)
|
|
{
|
|
grafPort.portVersion = 2;
|
|
|
|
/* make sure that the next record is a header opcode. */
|
|
GetWord( &opcodeCheck );
|
|
if (opcodeCheck == HeaderOp)
|
|
{
|
|
/* set up a record structure for call to TranslateOpcode(). */
|
|
versionOpcode.function = HeaderOp;
|
|
versionOpcode.length = 24;
|
|
TranslateOpcode( &versionOpcode );
|
|
}
|
|
else
|
|
{
|
|
/* Header wasn't followed by correct Header opcode - error. */
|
|
ErSetGlobalError( ErBadHeaderSequence );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* if version 2 identifier is invalid, return error state. */
|
|
ErSetGlobalError( ErInvalidVersionID );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* if check for version 1 and 2 fails, return error state. */
|
|
ErSetGlobalError( ErInvalidVersion );
|
|
}
|
|
|
|
} /* ReadPictVersion */
|
|
|
|
|
|
|
|
|
|
private void ReadOpcode( opcodeEntry far * nextOpcode )
|
|
/*---------------------*/
|
|
/* Reads the next opcode from the stream, depending on the PICT version */
|
|
{
|
|
opcodeEntryLPtr checkEntry;
|
|
|
|
/* Initialize the function, since we may be reading a version 1 opcode
|
|
that is only 1 byte in length. */
|
|
nextOpcode->function = 0;
|
|
|
|
/* Depending on the PICT version, we will read either a single byte
|
|
or word for the opcode. */
|
|
if (grafPort.portVersion == 1)
|
|
{
|
|
GetByte( (Byte far *)&nextOpcode->function );
|
|
}
|
|
else
|
|
{
|
|
GetWord( &nextOpcode->function );
|
|
}
|
|
|
|
/* check the current error code and force an exit from read loop if
|
|
something went wrong. */
|
|
if (ErGetGlobalError() != NOERR)
|
|
{
|
|
nextOpcode->function = opEndPic;
|
|
nextOpcode->length = 0;
|
|
return;
|
|
}
|
|
|
|
/* Check the opcode function number to determine if we can perform
|
|
a direct lookup, or if the opcode is part of the range table. */
|
|
if (nextOpcode->function < LookupTableSize )
|
|
{
|
|
nextOpcode->length = opcodeLookup[nextOpcode->function].length;
|
|
}
|
|
else
|
|
{
|
|
/* Walk through the range table to determine the data length of the
|
|
ensuing information past the opcode. */
|
|
for (checkEntry = opcodeRange;
|
|
checkEntry->function < nextOpcode->function;
|
|
checkEntry++) ;
|
|
|
|
nextOpcode->length = checkEntry->length;
|
|
}
|
|
|
|
} /* ReadOpcode */
|
|
|
|
|
|
private void TranslateOpcode( opcodeEntry far * currOpcodeLPtr )
|
|
/*--------------------------*/
|
|
/* read in the remaining data from the stream, based upon the opcode function
|
|
and then call the appropriate routine in Gdi module */
|
|
{
|
|
Word function = currOpcodeLPtr->function;
|
|
|
|
/* perform appropriate action based on function code */
|
|
switch (function)
|
|
{
|
|
case NOP:
|
|
/* no data follows */
|
|
break;
|
|
|
|
case Clip:
|
|
{
|
|
Boolean doClip = FALSE;
|
|
|
|
/* read in clip region into grafPort */
|
|
GetRegion( &grafPort.clipRgn );
|
|
|
|
/* if in textmode, we need avoid clip regions, since they are used
|
|
to draw Postscript encoded text *or* bitmap representations.
|
|
We allow a clipping region to pass through only if it is being
|
|
set to the bounds of the picture image (fix for MacDraw, Canvas,
|
|
and SuperPaint images containing rotated text.) */
|
|
if (textMode && textClipCheck)
|
|
{
|
|
Word far * sizeLPtr;
|
|
|
|
/* the most common case is a sequence of : null clip, text,
|
|
non-null clip, bitmap. If first clip == portRect, then
|
|
we actually want to set the clip - doClip is set to TRUE. */
|
|
sizeLPtr = (Word far *)GlobalLock( grafPort.clipRgn );
|
|
doClip = *sizeLPtr == RgnHeaderSize &&
|
|
EqualRect( (Rect far *)(sizeLPtr + 1), &grafPort.portRect );
|
|
GlobalUnlock( grafPort.clipRgn );
|
|
|
|
/* perform this check only once after initial picTextBegin */
|
|
textClipCheck = FALSE;
|
|
}
|
|
|
|
/* issue the clip only if not in text mode, or a sanctioned clip */
|
|
if (!textMode || doClip)
|
|
{
|
|
/* Call Gdi to set the new clip region */
|
|
GdiSelectClipRegion( grafPort.clipRgn );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case BkPat:
|
|
/* flag the pixel map type a Foreground/Background pixel pattern */
|
|
/* and read pattern into old data position */
|
|
grafPort.bkPixPat.patType = QDOldPat;
|
|
GetPattern( &grafPort.bkPixPat.pat1Data );
|
|
|
|
/* Notify Gdi that background color may have changed */
|
|
GdiMarkAsChanged( GdiBkPat );
|
|
break;
|
|
|
|
case TxFont:
|
|
/* read text font index */
|
|
GetWord( (Word far *)&grafPort.txFont );
|
|
|
|
/* check if the font name was provided in previous opcode */
|
|
if (!skipFontID)
|
|
{
|
|
/* Make sure that the font name is a null string */
|
|
grafPort.txFontName[0] = cNULL;
|
|
}
|
|
|
|
/* Notify Gdi that text font index may have changed */
|
|
GdiMarkAsChanged( GdiTxFont );
|
|
break;
|
|
|
|
case TxFace:
|
|
/* read font attributes */
|
|
GetByte( (Byte far *)&grafPort.txFace );
|
|
|
|
/* Notify Gdi that text style elements may have changed */
|
|
GdiMarkAsChanged( GdiTxFace );
|
|
break;
|
|
|
|
case TxMode:
|
|
/* read text transfer mode */
|
|
GetWord( (Word far *)&grafPort.txMode );
|
|
|
|
/* Notify Gdi that text transfer mode may have changed */
|
|
GdiMarkAsChanged( GdiTxMode );
|
|
break;
|
|
|
|
case SpExtra:
|
|
/* read text space extra */
|
|
GetFixed( (Fixed far *)&grafPort.spExtra );
|
|
|
|
/* Notify Gdi that space extra may have changed */
|
|
GdiMarkAsChanged( GdiSpExtra );
|
|
break;
|
|
|
|
case PnSize:
|
|
/* read x and y components of pen size */
|
|
GetPoint( (Point far *)&grafPort.pnSize );
|
|
|
|
/* Notify Gdi that pen size may have changed */
|
|
GdiMarkAsChanged( GdiPnSize );
|
|
break;
|
|
|
|
case PnMode:
|
|
/* read pen transfer mode */
|
|
GetWord( (Word far *)&grafPort.pnMode );
|
|
|
|
/* Notify Gdi that transferm mode may have changed */
|
|
GdiMarkAsChanged( GdiPnMode );
|
|
break;
|
|
|
|
case PnPat:
|
|
/* flag the pixel map type a Foreground/Background pixel pattern */
|
|
/* and read pattern into old data position */
|
|
grafPort.pnPixPat.patType = QDOldPat;
|
|
GetPattern( &grafPort.pnPixPat.pat1Data );
|
|
|
|
/* Notify Gdi that pen pattern may have changed */
|
|
GdiMarkAsChanged( GdiPnPat );
|
|
break;
|
|
|
|
case FillPat:
|
|
/* flag the pixel map type a Foreground/Background pixel pattern */
|
|
/* and read pattern into old data position */
|
|
grafPort.fillPixPat.patType = QDOldPat;
|
|
GetPattern( &grafPort.fillPixPat.pat1Data );
|
|
|
|
/* Notify Gdi that fill pattern may have changed */
|
|
GdiMarkAsChanged( GdiFillPat );
|
|
break;
|
|
|
|
case OvSize:
|
|
/* save point in new grafPort field */
|
|
GetPoint( &saveOvalSize );
|
|
break;
|
|
|
|
case Origin:
|
|
{
|
|
Point offset;
|
|
|
|
/* read the new origin in to the upper-left coordinate space */
|
|
GetWord( (Word far *)&offset.x );
|
|
GetWord( (Word far *)&offset.y );
|
|
|
|
/* call gdi module to reset the origin */
|
|
GdiOffsetOrigin( offset );
|
|
break;
|
|
}
|
|
|
|
case TxSize:
|
|
GetWord( (Word far *)&grafPort.txSize );
|
|
|
|
/* Notify Gdi that text size may have changed */
|
|
GdiMarkAsChanged( GdiTxSize );
|
|
break;
|
|
|
|
case FgColor:
|
|
GetOctochromeColor( &grafPort.rgbFgColor );
|
|
|
|
/* Notify Gdi that foreground color may have changed */
|
|
GdiMarkAsChanged( GdiFgColor );
|
|
break;
|
|
|
|
case BkColor:
|
|
GetOctochromeColor( &grafPort.rgbBkColor );
|
|
|
|
/* Notify Gdi that background color may have changed */
|
|
GdiMarkAsChanged( GdiBkColor );
|
|
break;
|
|
|
|
case TxRatio:
|
|
/* save the numerator and denominator in the grafPort */
|
|
GetPoint( &grafPort.txNumerator );
|
|
GetPoint( &grafPort.txDenominator );
|
|
|
|
/* Notify Gdi that text ratio may have changed */
|
|
GdiMarkAsChanged( GdiTxRatio );
|
|
break;
|
|
|
|
case Version:
|
|
/* just skip over the version information */
|
|
IOSkipBytes( currOpcodeLPtr->length );
|
|
break;
|
|
|
|
case BkPixPat:
|
|
GetPixPattern( &grafPort.bkPixPat );
|
|
|
|
/* Notify Gdi that background pattern may have changed */
|
|
GdiMarkAsChanged( GdiBkPat );
|
|
break;
|
|
|
|
case PnPixPat:
|
|
GetPixPattern( &grafPort.pnPixPat );
|
|
|
|
/* Notify Gdi that pen pattern may have changed */
|
|
GdiMarkAsChanged( GdiPnPat );
|
|
break;
|
|
|
|
case FillPixPat:
|
|
GetPixPattern( &grafPort.fillPixPat );
|
|
|
|
/* Notify Gdi that fill pattern may have changed */
|
|
GdiMarkAsChanged( GdiFillPat );
|
|
break;
|
|
|
|
case PnLocHFrac:
|
|
GetWord( (Word far *)&grafPort.pnLocHFrac );
|
|
break;
|
|
|
|
case ChExtra:
|
|
GetWord( (Word far *)&grafPort.chExtra );
|
|
|
|
/* Notify Gdi that text character extra may have changed */
|
|
GdiMarkAsChanged( GdiChExtra );
|
|
break;
|
|
|
|
case RGBFgCol:
|
|
GetRGBColor( &grafPort.rgbFgColor );
|
|
|
|
/* Notify Gdi that foregroudn color may have changed */
|
|
GdiMarkAsChanged( GdiFgColor );
|
|
break;
|
|
|
|
case RGBBkCol:
|
|
GetRGBColor( &grafPort.rgbBkColor );
|
|
|
|
/* Notify Gdi that background color may have changed */
|
|
GdiMarkAsChanged( GdiBkColor );
|
|
break;
|
|
|
|
case HiliteMode:
|
|
/* don't do anything for hilite mode */
|
|
break;
|
|
|
|
case HiliteColor:
|
|
{
|
|
RGBColor rgbUnused;
|
|
|
|
GetRGBColor( &rgbUnused );
|
|
break;
|
|
|
|
}
|
|
|
|
case DefHilite:
|
|
/* don't do anything for hilite */
|
|
break;
|
|
|
|
case OpColor:
|
|
{
|
|
RGBColor rgbUnused;
|
|
|
|
GetRGBColor( &rgbUnused );
|
|
break;
|
|
}
|
|
|
|
case Line:
|
|
case LineFrom:
|
|
case ShortLine:
|
|
case ShortLineFrom:
|
|
{
|
|
Point newPt;
|
|
SignedByte deltaX;
|
|
SignedByte deltaY;
|
|
|
|
/* see if we need to read the updated pen location first */
|
|
if (function == ShortLine || function == Line)
|
|
{
|
|
/* read in the new pen location */
|
|
GetCoordinate( &grafPort.pnLoc );
|
|
}
|
|
|
|
/* determine what the next data record contains */
|
|
if (function == Line || function == LineFrom)
|
|
{
|
|
/* get the new coordinate to draw to */
|
|
GetCoordinate( &newPt );
|
|
}
|
|
else /* if (function == ShortLine || function == ShortLineFrom) */
|
|
{
|
|
/* the the new x and y deltas */
|
|
GetByte( &deltaX );
|
|
GetByte( &deltaY );
|
|
|
|
/* calculate the endpoint for call to gdi */
|
|
newPt.x = grafPort.pnLoc.x + (Integer)deltaX;
|
|
newPt.y = grafPort.pnLoc.y + (Integer)deltaY;
|
|
}
|
|
|
|
/* check if buffering line segments (polygon mode != FALSE) */
|
|
if (polyMode)
|
|
{
|
|
/* add the line segment to the polygon buffer */
|
|
AddPolySegment( grafPort.pnLoc, newPt );
|
|
}
|
|
else
|
|
{
|
|
/* Call Gdi to draw line */
|
|
GdiLineTo( newPt );
|
|
}
|
|
|
|
/* update the new pen location in the grafPort */
|
|
grafPort.pnLoc = newPt;
|
|
break;
|
|
}
|
|
|
|
case LongText:
|
|
{
|
|
Str255 txString;
|
|
Point location;
|
|
|
|
/* read the new pen (baseline) location */
|
|
GetCoordinate( &grafPort.txLoc );
|
|
GetString( (StringLPtr)txString );
|
|
|
|
/* adjust for any text rotation that may be set */
|
|
location = grafPort.txLoc;
|
|
AdjustTextRotation( &location );
|
|
|
|
/* call Gdi to print the text at current pen location */
|
|
GdiTextOut( txString, location );
|
|
break;
|
|
}
|
|
|
|
case DHText:
|
|
case DVText:
|
|
case DHDVText:
|
|
{
|
|
Byte deltaX = 0;
|
|
Byte deltaY = 0;
|
|
Str255 txString;
|
|
Point location;
|
|
|
|
/* if command is DHText or DHDVText, read horizontal offset */
|
|
if (function != DVText)
|
|
{
|
|
GetByte( &deltaX );
|
|
}
|
|
|
|
/* if command is DVText or DHDVText, then read the vertical offset */
|
|
if (function != DHText)
|
|
{
|
|
GetByte( &deltaY );
|
|
}
|
|
|
|
/* update the current pen postion */
|
|
grafPort.txLoc.x += deltaX;
|
|
grafPort.txLoc.y += deltaY;
|
|
|
|
/* now read in the string */
|
|
GetString( (StringLPtr)txString );
|
|
|
|
/* adjust for any text rotation that may be set */
|
|
location = grafPort.txLoc;
|
|
AdjustTextRotation( &location );
|
|
|
|
/* call Gdi to print the text at current pen location */
|
|
GdiTextOut( txString, location );
|
|
break;
|
|
}
|
|
|
|
case FontName:
|
|
{
|
|
Word dataLen;
|
|
|
|
GetWord( (Word far *)&dataLen );
|
|
GetWord( (Word far *)&grafPort.txFont );
|
|
GetString( grafPort.txFontName );
|
|
|
|
/* Notify Gdi that font name may have changed */
|
|
GdiMarkAsChanged( GdiTxFont );
|
|
break;
|
|
}
|
|
|
|
case LineJustify:
|
|
{
|
|
Word dataLen;
|
|
Fixed interCharSpacing;
|
|
Fixed textExtra;
|
|
|
|
GetWord( (Word far *)&dataLen );
|
|
GetFixed( &interCharSpacing ); // !!! where to put this ?
|
|
GetFixed( &textExtra );
|
|
|
|
/* Notify Gdi that line justification may have changed */
|
|
GdiMarkAsChanged( GdiLineJustify );
|
|
break;
|
|
}
|
|
|
|
|
|
case frameRect:
|
|
case paintRect:
|
|
case eraseRect:
|
|
case invertRect:
|
|
case fillRect:
|
|
{
|
|
/* read in the rectangle */
|
|
GetRect( &saveRect );
|
|
|
|
/* call the correct GDI routine */
|
|
GdiRectangle( function - frameRect, saveRect );
|
|
break;
|
|
}
|
|
|
|
case frameSameRect:
|
|
case paintSameRect:
|
|
case eraseSameRect:
|
|
case invertSameRect:
|
|
case fillSameRect:
|
|
{
|
|
/* notify gdi that this is the same primitive */
|
|
GdiSamePrimitive( TRUE );
|
|
|
|
/* call the correct gdi routine using last rectangle coords */
|
|
GdiRectangle( function - frameSameRect, saveRect );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
break;
|
|
}
|
|
|
|
case frameRRect:
|
|
case paintRRect:
|
|
case eraseRRect:
|
|
case invertRRect:
|
|
case fillRRect:
|
|
{
|
|
/* save the rectangle */
|
|
GetRect( &saveRRect );
|
|
|
|
/* call the correct gdi routine using last rectangle coords */
|
|
GdiRoundRect( function - frameRRect, saveRRect, saveOvalSize );
|
|
break;
|
|
}
|
|
|
|
case frameSameRRect:
|
|
case paintSameRRect:
|
|
case eraseSameRRect:
|
|
case invertSameRRect:
|
|
case fillSameRRect:
|
|
{
|
|
/* notify gdi that this is the same primitive */
|
|
GdiSamePrimitive( TRUE );
|
|
|
|
/* call the correct gdi routine using last rectangle coords */
|
|
GdiRoundRect( function - frameSameRRect, saveRRect, saveOvalSize );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
break;
|
|
}
|
|
|
|
case frameOval:
|
|
case paintOval:
|
|
case eraseOval:
|
|
case invertOval:
|
|
case fillOval:
|
|
{
|
|
/* save off bounding rectangle */
|
|
GetRect( &saveOval );
|
|
|
|
/* call the correct gdi routine using last oval coords */
|
|
GdiOval( function - frameOval, saveOval );
|
|
break;
|
|
}
|
|
|
|
case frameSameOval:
|
|
case paintSameOval:
|
|
case eraseSameOval:
|
|
case invertSameOval:
|
|
case fillSameOval:
|
|
{
|
|
/* notify gdi that this is the same primitive */
|
|
GdiSamePrimitive( TRUE );
|
|
|
|
/* call the correct gdi routine using last oval coords */
|
|
GdiOval( function - frameSameOval, saveOval );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
break;
|
|
}
|
|
|
|
case frameArc:
|
|
case paintArc:
|
|
case eraseArc:
|
|
case invertArc:
|
|
case fillArc:
|
|
{
|
|
/* read rect into the save variables, new start and arc angles */
|
|
GetRect( &saveArc );
|
|
GetWord( (Word far *)&saveStartAngle );
|
|
GetWord( (Word far *)&saveArcAngle );
|
|
#ifdef WIN32
|
|
/* have to extend the sign because GetWord doesn't */
|
|
saveStartAngle = (short)saveStartAngle;
|
|
saveArcAngle = (short)saveArcAngle;
|
|
#endif
|
|
/* call the correct gdi routine using last arc angles */
|
|
GdiArc( function - frameArc, saveArc, saveStartAngle, saveArcAngle );
|
|
break;
|
|
}
|
|
|
|
case frameSameArc:
|
|
case paintSameArc:
|
|
case eraseSameArc:
|
|
case invertSameArc:
|
|
case fillSameArc:
|
|
{
|
|
Integer startAngle;
|
|
Integer arcAngle;
|
|
|
|
/* read new start and arc angles */
|
|
GetWord( (Word far *)&startAngle );
|
|
GetWord( (Word far *)&arcAngle );
|
|
#ifdef WIN32
|
|
/* have to extend the sign because GetWord doesn't */
|
|
startAngle = (short)startAngle;
|
|
arcAngle = (short)arcAngle;
|
|
#endif
|
|
|
|
/* notify gdi that this is the may be the same primitive */
|
|
GdiSamePrimitive( (startAngle == saveStartAngle) &&
|
|
(arcAngle == saveArcAngle) );
|
|
|
|
/* save off the start and arc angles */
|
|
saveStartAngle = startAngle;
|
|
saveArcAngle = arcAngle;
|
|
|
|
/* call the correct gdi routine using last rect and arc angles */
|
|
GdiArc( function - frameSameArc, saveArc, startAngle, arcAngle );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
break;
|
|
}
|
|
|
|
case framePoly:
|
|
case paintPoly:
|
|
case erasePoly:
|
|
case invertPoly:
|
|
case fillPoly:
|
|
{
|
|
/* save the polygon in the grafPort */
|
|
GdiSamePrimitive( GetPolygon( &grafPort.polySave, (function == framePoly) ) );
|
|
|
|
/* call gdi routine to draw polygon */
|
|
if (grafPort.polySave)
|
|
{
|
|
GdiPolygon( function - framePoly, grafPort.polySave );
|
|
|
|
/* turn off filling while in polygon mode */
|
|
polyParams &= ~FILLREQUIRED;
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case frameSamePoly:
|
|
case paintSamePoly:
|
|
case eraseSamePoly:
|
|
case invertSamePoly:
|
|
case fillSamePoly:
|
|
{
|
|
/* notify gdi that this is the same primitive */
|
|
GdiSamePrimitive( TRUE );
|
|
|
|
/* call gdi routine to draw polygon */
|
|
GdiPolygon( function - frameSamePoly, grafPort.polySave );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
break;
|
|
}
|
|
|
|
case frameRgn:
|
|
case paintRgn:
|
|
case eraseRgn:
|
|
case invertRgn:
|
|
case fillRgn:
|
|
{
|
|
/* save the region in the grafPort */
|
|
GetRegion( &grafPort.rgnSave );
|
|
|
|
/* check for memory failure; GetRegion will set ErGetGlobalError */
|
|
if (!grafPort.rgnSave)
|
|
break;
|
|
|
|
/* if in polygon mode and a fillRgn is encountered, this indicates
|
|
that the polygon should be filled once parsing is completed */
|
|
if (polyMode == PARSEPOLY)
|
|
{
|
|
/* make sure that a PaintPoly() hasn't been handled already */
|
|
if (!(polyParams & (FILLPOLY | FILLREQUIRED)))
|
|
{
|
|
/* set flags to fill polygon once polygon buffer is filled */
|
|
polyParams |= FILLPOLY | FILLREQUIRED;
|
|
}
|
|
}
|
|
else if (polyMode == FALSE ||
|
|
((polyMode == USEALTPOLY) && !(polyParams & FRAMEPOLY)))
|
|
{
|
|
/* call gdi routine to draw polygon */
|
|
GdiRegion( function - frameRgn, grafPort.rgnSave );
|
|
|
|
/* make sure that the polygon isn't filled when the simulation
|
|
buffer is drawn at the end of the polygon definition */
|
|
polyParams &= ~FILLREQUIRED;
|
|
}
|
|
|
|
/* save off the current fore- and background colors for
|
|
polygon simulation routine to ensure correct fill colors */
|
|
if (polyMode && (grafPort.fillPixPat.patType == QDOldPat))
|
|
{
|
|
polyFgColor = grafPort.rgbFgColor;
|
|
polyBkColor = grafPort.rgbBkColor;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case frameSameRgn:
|
|
case paintSameRgn:
|
|
case eraseSameRgn:
|
|
case invertSameRgn:
|
|
case fillSameRgn:
|
|
{
|
|
/* notify gdi that this is the same primitive */
|
|
GdiSamePrimitive( TRUE );
|
|
|
|
/* call gdi routine to draw polygon */
|
|
GdiRegion( function - frameSameRgn, grafPort.rgnSave );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
break;
|
|
}
|
|
|
|
case BitsRect:
|
|
case BitsRgn:
|
|
case PackBitsRect:
|
|
case PackBitsRgn:
|
|
case DirectBitsRect:
|
|
case DirectBitsRgn:
|
|
{
|
|
Boolean has24bits;
|
|
Boolean hasRegion;
|
|
Rect srcRect;
|
|
Rect dstRect;
|
|
Word mode;
|
|
PixMap pixMap;
|
|
Handle pixData;
|
|
DWord unusedBaseAddr;
|
|
RgnHandle rgn;
|
|
|
|
/* determine which type of bitmap we are reading */
|
|
has24bits = (function == DirectBitsRect ||
|
|
function == DirectBitsRgn);
|
|
hasRegion = (function == DirectBitsRgn ||
|
|
function == BitsRgn ||
|
|
function == PackBitsRgn);
|
|
|
|
/* currently there is no region created */
|
|
rgn = NULL;
|
|
|
|
/* if 24-bit, read in the base address which should == 0x000000FF */
|
|
if (has24bits)
|
|
{
|
|
GetDWord( &unusedBaseAddr );
|
|
}
|
|
|
|
/* read in the header structure */
|
|
GetPixMap( &pixMap, FALSE );
|
|
|
|
/* if this isn't an 24-bit RGB bitmap, read in the color table.
|
|
Also check the rowBytes field to signify bitmap w/2 colors */
|
|
if (!has24bits && (pixMap.rowBytes & PixelMapBit))
|
|
{
|
|
GetColorTable( &pixMap.pmTable );
|
|
}
|
|
|
|
/* call io module to update status indicator */
|
|
IOUpdateStatus();
|
|
|
|
/* read source and destination rects from stream */
|
|
GetRect( &srcRect );
|
|
GetRect( &dstRect );
|
|
GetWord( &mode );
|
|
|
|
/* if there is a region included, read this also */
|
|
if (hasRegion)
|
|
{
|
|
/* read in the region */
|
|
GetRegion( &rgn );
|
|
}
|
|
|
|
/* read the pixel bit data */
|
|
GetPixData( &pixMap, &pixData );
|
|
|
|
if (ErGetGlobalError() == NOERR && !textMode)
|
|
{
|
|
/* Call Gdi to render the bitmap and de-allocate the memory */
|
|
GdiStretchDIBits( &pixMap, pixData, srcRect, dstRect, mode, rgn );
|
|
}
|
|
else
|
|
{
|
|
/* deallocate any memory that may be allocated */
|
|
if (pixMap.pmTable != NULL)
|
|
{
|
|
GlobalFree( pixMap.pmTable );
|
|
}
|
|
if (hasRegion && (rgn != NULL))
|
|
{
|
|
GlobalFree( rgn );
|
|
}
|
|
if (pixData != NULL)
|
|
{
|
|
GlobalFree( pixData );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ShortComment:
|
|
{
|
|
Word comment;
|
|
Boolean doComment;
|
|
Comment gdiComment;
|
|
|
|
/* get the comment word */
|
|
GetWord( &comment );
|
|
|
|
/* assume that we won't be generating an metafile comment */
|
|
doComment = FALSE;
|
|
|
|
/* determine the corresponding GDI comment for the comment */
|
|
switch (comment)
|
|
{
|
|
case picPostScriptBegin:
|
|
case picPostScriptEnd:
|
|
EPSComment(comment);
|
|
break;
|
|
|
|
case picLParen:
|
|
case picGrpBeg:
|
|
doComment = TRUE;
|
|
gdiComment.function = BEGIN_GROUP;
|
|
break;
|
|
|
|
case picRParen:
|
|
case picGrpEnd:
|
|
doComment = TRUE;
|
|
gdiComment.function = END_GROUP;
|
|
break;
|
|
|
|
case picBitBeg:
|
|
doComment = TRUE;
|
|
gdiComment.function = BEGIN_BANDING;
|
|
break;
|
|
|
|
case picBitEnd:
|
|
doComment = TRUE;
|
|
gdiComment.function = END_BANDING;
|
|
break;
|
|
|
|
case picPolyBegin:
|
|
/* indicate that we are in polygon mode, and reset buffer */
|
|
polyMode = PARSEPOLY;
|
|
polyParams = FRAMEPOLY;
|
|
NewPolygon();
|
|
break;
|
|
|
|
case picPolyEnd:
|
|
/* flush the polygon buffer and exit polygon mode */
|
|
DrawPolyBuffer();
|
|
polyMode = FALSE;
|
|
break;
|
|
|
|
case picPolyIgnore:
|
|
/* see if we should reset the polygon buffer */
|
|
if (polyMode == USEALTPOLY)
|
|
{
|
|
/* use the alternate polygon definition to draw */
|
|
NewPolygon();
|
|
}
|
|
else
|
|
{
|
|
/* otherwise, just use the current saved polygon buffer */
|
|
polyMode = SKIPALTPOLY;
|
|
}
|
|
break;
|
|
|
|
case picTextEnd:
|
|
/* set the global flag indicating we are exiting text mode */
|
|
grafPort.txRotation = 0;
|
|
grafPort.txFlip = QDFlipNone;
|
|
textMode = FALSE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* if there is some comment to emit, then call GDI module */
|
|
if (doComment)
|
|
{
|
|
/* make this a public comment */
|
|
gdiComment.signature = PUBLIC;
|
|
gdiComment.size = 0;
|
|
|
|
/* call the gdi entry point */
|
|
GdiShortComment( &gdiComment );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LongComment:
|
|
{
|
|
Word comment;
|
|
Integer length;
|
|
|
|
/* get the comment function */
|
|
GetWord(&comment);
|
|
|
|
/* determine what should be done with the comment */
|
|
switch (comment)
|
|
{
|
|
case picPostScriptBegin:
|
|
case picPostScriptEnd:
|
|
case picPostScriptHandle:
|
|
{
|
|
if (EPSComment(comment) == 0) /* not EPS? */
|
|
{
|
|
GetWord( &length ); /* skip it */
|
|
}
|
|
else
|
|
{
|
|
length = 0; /* EPS was already read */
|
|
}
|
|
break;
|
|
}
|
|
|
|
case picPolySmooth:
|
|
{
|
|
/* read the total length of comment */
|
|
GetWord( &length );
|
|
|
|
/* read polygon parameter mask and set flag bits */
|
|
GetByte( &polyParams );
|
|
polyParams &= MASKPOLYBITS;
|
|
polyParams |= CHECK4SPLINE;
|
|
length--;
|
|
|
|
/* if we are to fill the polygon, indicate that fill required
|
|
just in case a PaintPoly() record appears before picPolyEnd */
|
|
if (polyParams & FILLPOLY)
|
|
{
|
|
/* or in the fill required bit */
|
|
polyParams |= FILLREQUIRED;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case picTextBegin:
|
|
{
|
|
Byte unusedAlignment;
|
|
|
|
/* read the comment length */
|
|
GetWord( &length );
|
|
|
|
/* read in only relevant parameters - align, flip, rotation */
|
|
GetByte( &unusedAlignment );
|
|
GetByte( &grafPort.txFlip );
|
|
GetWord( &grafPort.txRotation );
|
|
length -= 4;
|
|
|
|
/* set the global flag indicating we are in text mode. The
|
|
only case this isn't true if for badly mangled SuperPaint
|
|
files that have invalid rotation and pt size information. */
|
|
if( !(superPaintFile && badSuperPaintText) )
|
|
{
|
|
textMode = TRUE;
|
|
textClipCheck = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case picTextCenter:
|
|
{
|
|
Fixed textCenterX;
|
|
Fixed textCenterY;
|
|
|
|
/* read the comment length */
|
|
GetWord( &length );
|
|
|
|
/* read y and x offsets to center of text rotation */
|
|
GetFixed( &textCenterY );
|
|
GetFixed( &textCenterX );
|
|
length -= 8;
|
|
|
|
/* copy only the highword of the fixed value to textCenter */
|
|
textCenter.x = (short) (HIWORD( textCenterX ));
|
|
textCenter.y = (short) (HIWORD( textCenterY ));
|
|
|
|
/* make sure that the center is rounded, not truncated */
|
|
if (LOWORD( textCenterX) & 0x8000)
|
|
textCenter.x++;
|
|
|
|
if (LOWORD( textCenterY) & 0x8000)
|
|
textCenter.y++;
|
|
|
|
/* indicate that text center needs to be re-computed */
|
|
newTextCenter = TRUE;
|
|
break;
|
|
}
|
|
|
|
case picAppComment:
|
|
{
|
|
DWord signature;
|
|
Word function;
|
|
Word realFunc;
|
|
|
|
/* read total comment length */
|
|
GetWord( &length );
|
|
|
|
/* make sure that there's enough space to read signature */
|
|
if (length < sizeofMacDWord )
|
|
{
|
|
/* if insufficient, just skip remaining data */
|
|
break;
|
|
}
|
|
|
|
/* read the signature of the application */
|
|
GetDWord( &signature );
|
|
length -= sizeofMacDWord ;
|
|
|
|
/* is this PowerPoint 'PPNT' signature and function size enough? */
|
|
if ((signature != POWERPOINT && signature != POWERPOINT_OLD) ||
|
|
(length < sizeofMacWord ))
|
|
{
|
|
/* if SuperPaint signature matches, flag for text checks */
|
|
if (signature == SUPERPAINT)
|
|
superPaintFile = TRUE;
|
|
|
|
/* if wrong signature, or insufficient space, bail */
|
|
break;
|
|
}
|
|
|
|
/* read the application function ID */
|
|
GetWord( &function );
|
|
length -= sizeofMacWord ;
|
|
|
|
/* mask out high-order bit to get "real" opcode */
|
|
realFunc = function & ~PC_REGISTERED;
|
|
|
|
/* determine what to do with the function specified */
|
|
switch (realFunc)
|
|
{
|
|
case PP_FONTNAME:
|
|
{
|
|
Byte fontFamily;
|
|
Byte charSet;
|
|
Byte fontName[32];
|
|
|
|
/* font name from GDI2QD - read the LOGFONT info */
|
|
GetByte( &fontFamily );
|
|
GetByte( &charSet );
|
|
GetString( fontName );
|
|
length = 0;
|
|
|
|
/* call Gdi module to override font selection */
|
|
GdiFontName( fontFamily, charSet, fontName );
|
|
break;
|
|
}
|
|
|
|
case PP_HATCHPATTERN:
|
|
{
|
|
Integer hatchIndex;
|
|
|
|
/* hatch pattern from GDI2QD - read hatch index value */
|
|
GetWord( (Word far *)&hatchIndex );
|
|
length = 0;
|
|
|
|
/* notify Gdi module of hatch to override fill pattern */
|
|
GdiHatchPattern( hatchIndex );
|
|
break;
|
|
}
|
|
|
|
case PP_BEGINFADE:
|
|
case PP_BEGINPICTURE:
|
|
case PP_DEVINFO:
|
|
{
|
|
DWord cmntSize;
|
|
Boolean doComment;
|
|
|
|
struct
|
|
{
|
|
Comment gdiComment;
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
Byte version;
|
|
Boolean isShape;
|
|
Integer shapeIndex;
|
|
Integer shapeParam1;
|
|
Boolean olpNIL;
|
|
Rect orectDR;
|
|
Rect orect;
|
|
Word shape;
|
|
Integer shapeParam2;
|
|
Rect location;
|
|
Integer gradient;
|
|
Boolean fromBackground;
|
|
Boolean darker;
|
|
Integer arcStart;
|
|
Integer arcSweep;
|
|
Word backR;
|
|
Word backG;
|
|
Word backB;
|
|
Rect rSImage;
|
|
} fade;
|
|
|
|
Word entity;
|
|
|
|
Point unitsPerPixel;
|
|
|
|
} parm;
|
|
|
|
} cmnt;
|
|
|
|
#ifdef WIN32
|
|
memset( &cmnt, 0, sizeof( cmnt ));
|
|
#endif
|
|
|
|
/* so far, we won't be writting the Escape comment */
|
|
doComment = FALSE;
|
|
|
|
/* can we read the comment size? */
|
|
if (length < sizeofMacDWord )
|
|
{
|
|
/* couldn't read the size - just exit */
|
|
break;
|
|
}
|
|
|
|
/* read in a size field and validate */
|
|
GetDWord( &cmntSize );
|
|
length -= sizeofMacDWord ;
|
|
|
|
/* is this is an invalid PP3 size field (Word len) */
|
|
if (HIWORD( cmntSize ) != 0)
|
|
{
|
|
/* yes - just skip the remaining data */
|
|
break;
|
|
}
|
|
|
|
/* a valid comment was found - fill in header struct */
|
|
cmnt.gdiComment.signature = POWERPOINT;
|
|
cmnt.gdiComment.function = function;
|
|
cmnt.gdiComment.size = 0;
|
|
|
|
/* check if this is a zero-length comment */
|
|
if (cmntSize == 0)
|
|
{
|
|
/* make sure that the comment gets written */
|
|
doComment = TRUE;
|
|
}
|
|
/* process the begin fade comment */
|
|
else if (realFunc == PP_BEGINFADE)
|
|
{
|
|
/* can we read the version field? */
|
|
if (length < sizeof( Byte ))
|
|
{
|
|
/* can't read version - just bail */
|
|
break;
|
|
}
|
|
|
|
/* read the version field */
|
|
GetByte( &cmnt.parm.fade.version );
|
|
length -= sizeof( Byte );
|
|
|
|
/* if this is version 1 or 2, copy the bytes */
|
|
if (cmnt.parm.fade.version == 1 || cmnt.parm.fade.version == 2)
|
|
{
|
|
Handle cmntHandle;
|
|
Comment far * cmntLPtr;
|
|
Byte far * cmntDataLPtr;
|
|
DWord escapeSize;
|
|
Word i;
|
|
|
|
/* determine size and allocate the required buffer */
|
|
escapeSize = cmntSize + sizeof( Comment );
|
|
cmntHandle = GlobalAlloc( GHND, escapeSize );
|
|
|
|
/* make sure allocation succeeded */
|
|
if (cmntHandle == NULL)
|
|
{
|
|
ErSetGlobalError( ErMemoryFull );
|
|
break;
|
|
}
|
|
|
|
/* lock the buffer and assign the comment header */
|
|
cmntLPtr = (Comment far *)GlobalLock( cmntHandle );
|
|
|
|
/* set the correct signature and parameters */
|
|
cmntLPtr->signature = POWERPOINT;
|
|
cmntLPtr->function = function;
|
|
cmntLPtr->size = cmntSize;
|
|
|
|
/* get pointer to the data and assign the version */
|
|
cmntDataLPtr = ((Byte far *)cmntLPtr) + sizeof( Comment );
|
|
*cmntDataLPtr++ = cmnt.parm.fade.version;
|
|
|
|
/* copy the byte over - start at 1 for version read */
|
|
for (i = 1; i < (Word)cmntSize; i++)
|
|
{
|
|
/* copy over byte and increment pointer */
|
|
GetByte( cmntDataLPtr++ );
|
|
}
|
|
|
|
/* put the comment into the metafile */
|
|
GdiEscape( MFCOMMENT, (Word)escapeSize, (StringLPtr)cmntLPtr );
|
|
|
|
/* release the memory allocated for the structure */
|
|
GlobalUnlock( cmntHandle );
|
|
GlobalFree( cmntHandle );
|
|
}
|
|
/* otherwise, perform swapping for PP3 fade */
|
|
else if (cmnt.parm.fade.version == 3)
|
|
{
|
|
Word unusedWord;
|
|
|
|
if (length < ( 1 + (11 * sizeofMacWord) +
|
|
( 4 * sizeofMacRect) + 4
|
|
))
|
|
/* The above magic numbers come from:
|
|
GetByte
|
|
GetWord GetWord GetWord GetWord GetWord GetWord
|
|
GetWord GetWord GetWord GetWord GetWord
|
|
GetRect GetRect GetRect GetRect
|
|
GetBoolean GetBoolean GetBoolean GetBoolean
|
|
This is to make sure enough input left for
|
|
parameters - note that the Mac size is one less
|
|
than the GDI fade */
|
|
{
|
|
/* no - just bail */
|
|
break;
|
|
}
|
|
|
|
/* read in all remaining parameters */
|
|
GetBoolean( (Boolean far *)(&cmnt.parm.fade.isShape) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.shapeIndex) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.shapeParam1) );
|
|
GetBoolean( (Boolean far *)(&cmnt.parm.fade.olpNIL) );
|
|
GetByte( (Byte far *)(&unusedWord) );
|
|
GetRect( (Rect far *)(&cmnt.parm.fade.orectDR) );
|
|
GetRect( (Rect far *)(&cmnt.parm.fade.orect) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.shape) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.shapeParam2) );
|
|
GetRect( (Rect far *)(&cmnt.parm.fade.location) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.gradient) );
|
|
GetBoolean( (Boolean far *)(&cmnt.parm.fade.fromBackground) );
|
|
GetBoolean( (Boolean far *)(&cmnt.parm.fade.darker ) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.arcStart) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.arcSweep) );
|
|
GetWord( (Word far *)(&unusedWord) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.backR) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.backG) );
|
|
GetWord( (Word far *)(&cmnt.parm.fade.backB) );
|
|
GetRect( (Rect far *)(&cmnt.parm.fade.rSImage) );
|
|
|
|
/* determine the comment size */
|
|
cmnt.gdiComment.size = sizeof( cmnt.parm.fade );
|
|
|
|
/* make sure comment gets written */
|
|
doComment = TRUE;
|
|
}
|
|
|
|
/* no more bytes to read, flag that faded object started */
|
|
length = 0;
|
|
shadedObjectStarted = TRUE;
|
|
}
|
|
else if (realFunc == PP_BEGINPICTURE)
|
|
{
|
|
/* can we read the entity reference? */
|
|
if (length < sizeofMacWord )
|
|
{
|
|
/* no - just bail */
|
|
break;
|
|
}
|
|
|
|
/* read the entity reference */
|
|
GetWord( &cmnt.parm.entity );
|
|
length -= sizeofMacWord;
|
|
|
|
/* assign the correct comment size */
|
|
cmnt.gdiComment.size = sizeof( cmnt.parm.entity );
|
|
|
|
/* make sure comment gets written */
|
|
doComment = TRUE;
|
|
}
|
|
else if (realFunc == PP_DEVINFO)
|
|
{
|
|
/* can we read the units per pixel? */
|
|
if (length < sizeofMacPoint)
|
|
{
|
|
/* no - just bail */
|
|
break;
|
|
}
|
|
|
|
/* read the units per pixel */
|
|
GetPoint( (Point far *)&cmnt.parm.unitsPerPixel );
|
|
length -= sizeofMacPoint;
|
|
|
|
/* assign the size field */
|
|
cmnt.gdiComment.size = sizeof( cmnt.parm.unitsPerPixel );
|
|
|
|
/* make sure comment gets written */
|
|
doComment = TRUE;
|
|
}
|
|
|
|
/* write out the Gdi Escape comment */
|
|
if (doComment)
|
|
{
|
|
/* call the gdi entry point */
|
|
GdiEscape( MFCOMMENT, sizeof( Comment ) + (Word)cmnt.gdiComment.size, (StringLPtr)&cmnt );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case PP_ENDFADE:
|
|
{
|
|
/* make sure that the BEGINFADE was put into metafile */
|
|
if (!shadedObjectStarted)
|
|
{
|
|
/* if not, then bail out */
|
|
break;
|
|
}
|
|
/* otherwise, just drop into the next case statement */
|
|
}
|
|
|
|
case PP_ENDPICTURE:
|
|
{
|
|
Comment gdiComment;
|
|
|
|
/* make this a private PowerPoint comment */
|
|
gdiComment.signature = POWERPOINT;
|
|
gdiComment.function = function;
|
|
gdiComment.size = 0;
|
|
|
|
/* call the gdi entry point */
|
|
GdiShortComment( &gdiComment );
|
|
|
|
/* if this is the end of fade, mask out flag check */
|
|
if (realFunc == PP_ENDFADE)
|
|
{
|
|
/* end fade was processed successfully */
|
|
shadedObjectStarted = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
/* any other comment is just skipped */
|
|
GetWord( &length );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* skip any remaining bytes to be read */
|
|
IOSkipBytes( length );
|
|
break;
|
|
}
|
|
|
|
case opEndPic:
|
|
/* do nothing - picture is closing */
|
|
break;
|
|
|
|
case HeaderOp:
|
|
{
|
|
Integer version;
|
|
Word unusedReserved1;
|
|
Fixed hRes;
|
|
Fixed vRes;
|
|
Rect unusedRect;
|
|
DWord unusedReserved2;
|
|
|
|
/* read in the the version to determine if OpenCPort() was used
|
|
to open the picture, thus containing spatial resoultion info. */
|
|
GetWord( (Word far *)&version );
|
|
|
|
/* read any other parameters - will check later if they are valid.
|
|
If version == -1, we are reading over the bounding rectangle. */
|
|
GetWord( &unusedReserved1 );
|
|
GetFixed( &hRes );
|
|
GetFixed( &vRes );
|
|
|
|
/* check if bounding rect and spatial resolution are changed */
|
|
if (version == -2)
|
|
{
|
|
/* read in the optimal source rectangle */
|
|
GetRect( &grafPort.portRect );
|
|
|
|
/* use the integer portion of hRes for the resolution dpi */
|
|
resolution = HIWORD( hRes );
|
|
}
|
|
else
|
|
{
|
|
/* otherwise, read an unused rectangle coordinate pair */
|
|
GetRect( &unusedRect );
|
|
}
|
|
|
|
/* read the trailing unused reserved LongInt */
|
|
GetDWord( &unusedReserved2 );
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
SkipData( currOpcodeLPtr );
|
|
break;
|
|
}
|
|
|
|
/* set flag to skip ensuing font index if font name was provided */
|
|
skipFontID = (currOpcodeLPtr->function == FontName);
|
|
|
|
/* if global error, set opcode to opEndPic to exit main loop */
|
|
if (ErGetGlobalError() != NOERR)
|
|
{
|
|
currOpcodeLPtr->function = opEndPic;
|
|
currOpcodeLPtr->length = 0;
|
|
}
|
|
|
|
} /* TranslateOpcode */
|
|
|
|
|
|
|
|
private void SkipData( opcodeEntry far * currOpcodeLPtr )
|
|
/*-------------------*/
|
|
/* skip the data - the opcode won't be translated and Gdi module won't be
|
|
called to create anything in the metafile */
|
|
{
|
|
LongInt readLength = 0;
|
|
|
|
if (currOpcodeLPtr->length >= 0)
|
|
{
|
|
IOSkipBytes( currOpcodeLPtr->length );
|
|
}
|
|
else
|
|
{
|
|
readLength = 0;
|
|
|
|
switch (currOpcodeLPtr->length)
|
|
{
|
|
case CommentSize:
|
|
{
|
|
Word unusedFunction;
|
|
|
|
GetWord( (Word far *)&unusedFunction );
|
|
GetWord( (Word far *)&readLength );
|
|
break;
|
|
}
|
|
|
|
case RgnOrPolyLen:
|
|
{
|
|
GetWord( (Word far *)&readLength );
|
|
readLength -= 2;
|
|
break;
|
|
}
|
|
|
|
case WordDataLen:
|
|
{
|
|
GetWord( (Word far *)&readLength );
|
|
break;
|
|
}
|
|
|
|
case DWordDataLen:
|
|
{
|
|
GetDWord( (DWord far *)&readLength );
|
|
break;
|
|
}
|
|
|
|
case HiByteLen:
|
|
{
|
|
readLength = (currOpcodeLPtr->function >> 8) * 2;
|
|
break;
|
|
}
|
|
|
|
} /* switch () */
|
|
|
|
IOSkipBytes( readLength );
|
|
|
|
} /* else */
|
|
|
|
} /* SkipData */
|
|
|
|
|
|
|
|
void OpenPort( void )
|
|
/*-----------*/
|
|
/* initialize the grafPort */
|
|
{
|
|
/* set port version to unintialized state */
|
|
grafPort.portVersion = 0;
|
|
|
|
/* no polygons or regions saved yet */
|
|
grafPort.clipRgn = NIL;
|
|
grafPort.rgnSave = NIL;
|
|
grafPort.polySave = NIL;
|
|
|
|
/* initialize all patterns to old-style patterns */
|
|
grafPort.bkPixPat.patType = QDOldPat;
|
|
grafPort.pnPixPat.patType = QDOldPat;
|
|
grafPort.fillPixPat.patType = QDOldPat;
|
|
|
|
/* make patterns all solid */
|
|
QDCopyBytes( (Byte far *)&SolidPattern,
|
|
(Byte far *)&grafPort.bkPixPat.pat1Data, sizeof( Pattern ) );
|
|
QDCopyBytes( (Byte far *)&SolidPattern,
|
|
(Byte far *)&grafPort.pnPixPat.pat1Data, sizeof( Pattern ) );
|
|
QDCopyBytes( (Byte far *)&SolidPattern,
|
|
(Byte far *)&grafPort.fillPixPat.pat1Data, sizeof( Pattern ) );
|
|
|
|
/* foreground/background set to black on white */
|
|
grafPort.rgbFgColor = RGB( 0x00, 0x00, 0x00 ); /* black */
|
|
grafPort.rgbBkColor = RGB( 0xFF, 0xFF, 0xFF ); /* white */
|
|
|
|
/* various pen attributes */
|
|
grafPort.pnLoc.x = 0; /* pen location (0,0) */
|
|
grafPort.pnLoc.y = 0;
|
|
grafPort.pnSize.x = 1; /* pen size (1,1) */
|
|
grafPort.pnSize.y = 1;
|
|
grafPort.pnVis = 0; /* pen is visible */
|
|
grafPort.pnMode = QDPatCopy; /* copy ROP */
|
|
grafPort.pnLocHFrac = 0x00008000; /* 1/2 */
|
|
|
|
/* font attributes */
|
|
grafPort.txFont = 0; /* system font */
|
|
grafPort.txFace = 0; /* plain style */
|
|
grafPort.txMode = QDSrcOr;
|
|
grafPort.txSize = 0; /* system font size */
|
|
grafPort.spExtra = 0;
|
|
grafPort.chExtra = 0;
|
|
grafPort.txNumerator.x = /* text scaling ratio */
|
|
grafPort.txNumerator.y =
|
|
grafPort.txDenominator.x =
|
|
grafPort.txDenominator.y = 1;
|
|
grafPort.txRotation = 0; /* no rotation or flipping */
|
|
grafPort.txFlip = QDFlipNone;
|
|
|
|
/* assume 72 dpi - this may be overridden in HeaderOp opcode */
|
|
resolution = 72;
|
|
|
|
/* private global initialization */
|
|
polyMode = FALSE;
|
|
textMode = FALSE;
|
|
shadedObjectStarted = FALSE;
|
|
superPaintFile = FALSE;
|
|
|
|
/* text rotation variables */
|
|
newTextCenter = FALSE;
|
|
textCenter.x = textCenter.y = 0;
|
|
|
|
/* allocate space for the polygon buffer */
|
|
maxPoints = 16;
|
|
polyHandle = GlobalAlloc( GHND, (maxPoints + 3) * sizeof( Point ) );
|
|
if (polyHandle == NULL)
|
|
{
|
|
ErSetGlobalError( ErMemoryFull);
|
|
}
|
|
else
|
|
{
|
|
/* get pointer address and address for the polygon coordinate list */
|
|
numPointsLPtr = (Integer far *)GlobalLock( polyHandle );
|
|
polyListLPtr = (Point far *)(numPointsLPtr + POLYLIST);
|
|
}
|
|
|
|
} /* OpenPort */
|
|
|
|
|
|
private void ClosePort( void )
|
|
/*--------------------*/
|
|
/* close grafPort and de-allocate any memory blocks */
|
|
{
|
|
if (grafPort.clipRgn != NULL)
|
|
{
|
|
GlobalFree( grafPort.clipRgn );
|
|
grafPort.clipRgn = NULL;
|
|
}
|
|
|
|
if (grafPort.rgnSave != NULL)
|
|
{
|
|
GlobalFree( grafPort.rgnSave );
|
|
grafPort.rgnSave = NULL;
|
|
}
|
|
|
|
if (grafPort.polySave != NULL)
|
|
{
|
|
GlobalFree( grafPort.polySave );
|
|
grafPort.polySave = NULL;
|
|
}
|
|
|
|
/* make sure that all the possible pixel pattern bitmaps are freed */
|
|
if (grafPort.bkPixPat.patData != NULL)
|
|
{
|
|
GlobalFree( grafPort.bkPixPat.patMap.pmTable );
|
|
GlobalFree( grafPort.bkPixPat.patData );
|
|
grafPort.bkPixPat.patData = NULL;
|
|
}
|
|
|
|
if (grafPort.pnPixPat.patData != NULL)
|
|
{
|
|
GlobalFree( grafPort.pnPixPat.patMap.pmTable );
|
|
GlobalFree( grafPort.pnPixPat.patData );
|
|
grafPort.pnPixPat.patData = NULL;
|
|
}
|
|
|
|
if (grafPort.fillPixPat.patData != NULL)
|
|
{
|
|
GlobalFree( grafPort.fillPixPat.patMap.pmTable );
|
|
GlobalFree( grafPort.fillPixPat.patData );
|
|
grafPort.fillPixPat.patData = NULL;
|
|
}
|
|
|
|
/* deallocate the polygon buffer */
|
|
GlobalUnlock( polyHandle );
|
|
GlobalFree( polyHandle );
|
|
|
|
} /* ClosePort */
|
|
|
|
|
|
private void NewPolygon( void )
|
|
/*---------------------*/
|
|
/* initialize the state of the polygon buffer - flush any previous data */
|
|
{
|
|
/* initialize number of points and bounding box */
|
|
numPoints = 0;
|
|
polyBBox.left = polyBBox.top = MAXINT;
|
|
polyBBox.right = polyBBox.bottom = -MAXINT;
|
|
|
|
} /* NewPolygon */
|
|
|
|
|
|
private void AddPolySegment( Point start, Point end )
|
|
/*-------------------------*/
|
|
/* Add the line segment to the polygon buffer */
|
|
{
|
|
/* make sure that we are in polygon mode before adding vertex */
|
|
if (polyMode == PARSEPOLY || polyMode == USEALTPOLY)
|
|
{
|
|
Point pt;
|
|
Byte i;
|
|
|
|
/* loop through both points ... */
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
/* determine which point to process */
|
|
pt = (i == 0) ? start : end;
|
|
|
|
/* determine if we should expect a zero delta increment in both
|
|
dimensions, implying that the quadratic B-spline definition will
|
|
actually be rendered as a straight-edged polygon */
|
|
if ((numPoints <= 1) || (polyMode == USEALTPOLY))
|
|
{
|
|
zeroDeltaExpected = FALSE;
|
|
}
|
|
|
|
/* check if we are expecting a zero delta from last point */
|
|
if (zeroDeltaExpected && (polyParams & CHECK4SPLINE))
|
|
{
|
|
/* make sure we are adding a zero-length line segment */
|
|
if ((start.x == end.x) && (start.y == end.y))
|
|
{
|
|
/* just skip including this in the polygon buffer */
|
|
zeroDeltaExpected = FALSE;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
/* MacDraw is rendering a smoothed (quadratic B-spline) - flag
|
|
the fact that we should use the polygon simulation */
|
|
polyMode = USEALTPOLY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* make sure the point is different from last point */
|
|
if (numPoints == 0 ||
|
|
polyListLPtr[numPoints - 1].x != pt.x ||
|
|
polyListLPtr[numPoints - 1].y != pt.y)
|
|
{
|
|
/* make sure that we haven't reached maximum size */
|
|
if ((numPoints + 1) >= maxPoints)
|
|
{
|
|
/* expand the number of points that can be cached by 10 */
|
|
maxPoints += 16;
|
|
|
|
/* unlock to prepare for re-allocation */
|
|
GlobalUnlock( polyHandle);
|
|
|
|
/* re-allocate the memory handle by the given amount */
|
|
polyHandle = GlobalReAlloc(
|
|
polyHandle,
|
|
(maxPoints + 3) * sizeof( Point ),
|
|
GMEM_MOVEABLE);
|
|
|
|
/* make sure that the re-allocation succeeded */
|
|
if (polyHandle == NULL)
|
|
{
|
|
/* if not, flag global error and exit from here */
|
|
ErSetGlobalError( ErMemoryFull );
|
|
return;
|
|
}
|
|
|
|
/* get new pointer addresses the polygon coordinate list */
|
|
numPointsLPtr = (Integer far *)GlobalLock( polyHandle );
|
|
polyListLPtr = (Point far *)(numPointsLPtr + POLYLIST);
|
|
}
|
|
|
|
/* insert the new point and increment number of points */
|
|
polyListLPtr[numPoints++] = pt;
|
|
|
|
/* union new point with polygon bounding box */
|
|
polyBBox.left = min( polyBBox.left, pt.x );
|
|
polyBBox.top = min( polyBBox.top, pt.y );
|
|
polyBBox.right = max( polyBBox.right, pt.x );
|
|
polyBBox.bottom = max( polyBBox.bottom, pt.y );
|
|
|
|
/* toggle the state of zeroDeltaExpected - expect same point next time */
|
|
zeroDeltaExpected = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} /* AddPolyPt */
|
|
|
|
|
|
|
|
private void DrawPolyBuffer( void )
|
|
/*-------------------------*/
|
|
/* Draw the polygon definition if the points were read without errors */
|
|
{
|
|
/* copy the point count and bounding box into the memory block */
|
|
*numPointsLPtr = sizeofMacWord + sizeofMacRect + (numPoints * sizeofMacPoint);
|
|
*((Rect far *)(numPointsLPtr + BBOX)) = polyBBox;
|
|
|
|
/* lock the polygon handle before rendering */
|
|
GlobalUnlock( polyHandle );
|
|
|
|
/* check if we should fill the polygon or if already done */
|
|
if ((polyParams & FILLPOLY) && (polyParams & FILLREQUIRED))
|
|
{
|
|
Boolean resetFg;
|
|
Boolean resetBk;
|
|
RGBColor saveFg;
|
|
RGBColor saveBk;
|
|
|
|
/* set up fore- and background colors if they have changed */
|
|
resetFg = (polyFgColor != grafPort.rgbFgColor);
|
|
resetBk = (polyBkColor != grafPort.rgbBkColor);
|
|
|
|
if (resetFg)
|
|
{
|
|
/* change the foreground color and notify Gdi of change */
|
|
saveFg = grafPort.rgbFgColor;
|
|
grafPort.rgbFgColor = polyFgColor;
|
|
GdiMarkAsChanged( GdiFgColor );
|
|
}
|
|
if (resetBk)
|
|
{
|
|
/* change the background color and notify Gdi of change */
|
|
saveBk = grafPort.rgbBkColor;
|
|
grafPort.rgbBkColor = polyBkColor;
|
|
GdiMarkAsChanged( GdiBkColor );
|
|
}
|
|
|
|
/* call gdi routine to draw polygon */
|
|
GdiPolygon( GdiFill, polyHandle );
|
|
|
|
if (resetFg)
|
|
{
|
|
/* change the foreground color and notify Gdi of change */
|
|
grafPort.rgbFgColor = saveFg;
|
|
GdiMarkAsChanged( GdiFgColor );
|
|
}
|
|
if (resetBk)
|
|
{
|
|
/* change the background color and notify Gdi of change */
|
|
grafPort.rgbBkColor = saveBk;
|
|
GdiMarkAsChanged( GdiBkColor );
|
|
}
|
|
|
|
}
|
|
|
|
/* should the polygon be framed? */
|
|
if ((polyParams & FRAMEPOLY) &&
|
|
(grafPort.pnSize.x != 0) && (grafPort.pnSize.y != 0))
|
|
{
|
|
/* notify gdi that this is the same primitive */
|
|
GdiSamePrimitive( polyParams & FILLPOLY );
|
|
|
|
GdiPolygon( GdiFrame, polyHandle );
|
|
|
|
/* notify gdi that this is no longer the same primitive */
|
|
GdiSamePrimitive( FALSE );
|
|
}
|
|
|
|
/* get pointer address and address for the polygon coordinate list */
|
|
numPointsLPtr = (Integer far *)GlobalLock( polyHandle );
|
|
polyListLPtr = (Point far *)(numPointsLPtr + POLYLIST);
|
|
|
|
} /* DrawPolyBuffer */
|
|
|
|
|
|
|
|
private void AdjustTextRotation( Point far * newPt )
|
|
/*-----------------------------*/
|
|
/* This will calculate the correct text position if text is rotated */
|
|
{
|
|
if (textMode && (grafPort.txRotation != 0) &&
|
|
((textCenter.x != 0) || (textCenter.y != 0)))
|
|
{
|
|
Point location;
|
|
Point center;
|
|
|
|
/* copy the new location to local variable */
|
|
location = *newPt;
|
|
|
|
/* ensure that a new text rotation was specified - recompute center */
|
|
if (newTextCenter)
|
|
{
|
|
Real degRadian;
|
|
|
|
/* calculate the new center of rotation */
|
|
center.x = textCenter.x + location.x;
|
|
center.y = textCenter.y + location.y;
|
|
|
|
/* calculate the sin() and cos() of the specified angle of rotation */
|
|
degRadian = ((Real)grafPort.txRotation * TwoPi) / 360.0;
|
|
degCos = cos( degRadian );
|
|
degSin = sin( degRadian );
|
|
|
|
/* use transformation matrix to compute offset to text center */
|
|
textCenter.x = (Integer)((center.x * (1.0 - degCos)) +
|
|
(center.y * degSin));
|
|
|
|
textCenter.y = (Integer)((center.y * (1.0 - degCos)) -
|
|
(center.x * degSin));
|
|
|
|
/* indicate that the new text center was computed */
|
|
newTextCenter = FALSE;
|
|
}
|
|
|
|
/* use transformation matrix to compute the new text basline location */
|
|
newPt->x = (Integer)((location.x * degCos) -
|
|
(location.y * degSin) + textCenter.x);
|
|
newPt->y = (Integer)((location.x * degSin) +
|
|
(location.y * degCos) + textCenter.y);
|
|
}
|
|
|
|
} /* AdjustTextRotation */
|
|
|
|
|
|
|
|
/****
|
|
*
|
|
* EPSComment(comment)
|
|
* Encapsulated PostScript Handler which translates Mac EPS to GDI EPS.
|
|
* This routine has intimate knowledge of the implementation of both
|
|
* Mac and GDI EPS filters. It processes Mac PostScript comments.
|
|
*
|
|
* returns:
|
|
* >0 successfully parsed EPS data
|
|
* 0 not EPS comment
|
|
* <0 error
|
|
*
|
|
* How the EPS filter works:
|
|
* The Mac EPS filter uses special features in the LaserWriter driver
|
|
* to send the PICT bounding box to the printer whre it is examined
|
|
* by PostScript code. The filter outputs a preamble which is a
|
|
* combination of QuickDraw and PostScript. This preamble is sent
|
|
* before the PostScript date from the EPS file. It sets the pen
|
|
* position for opposing corners of the PICT bounding box using
|
|
* QuickDraw and reads the pen position back in PostScript. Any
|
|
* transformations which have been set up in QuickDraw by the
|
|
* application to position or scale the picture will be applied
|
|
* to the coordinates of the bounding box sent by the preamble.
|
|
* PostScript code determines the transformation necessary to map the
|
|
* EPS bounding box onto the physical bounding box read from
|
|
* QuickDraw. These transformations are then applied to the PostScript
|
|
* picture when it is displayed.
|
|
*
|
|
* Operation of the GDI EPS filter is very similar except that it
|
|
* outputs a combination of GDI and PostScript.
|
|
*
|
|
* Implementation:
|
|
* The code can be in one of several states. Recognition of specific
|
|
* PostScript strings causes transition between states.
|
|
* PS_NONE Initial state, indicates no PostScript has been seen yet
|
|
* In this state, QuickDraw to GDI translation proceeds
|
|
* normally but PostScript data is examined.
|
|
* When a PostScript record is found with the string
|
|
* "pse\rpsb\r", the start of the PostScript preamble
|
|
* has been found and the program goes into state PS_PREAMBLE.
|
|
* PS_PREAMBLE All PostScript encountered in this state is ignored
|
|
* PostScript record starting with the string "[" is found.
|
|
* This is the PostScript bounding box specification.
|
|
* As soon as we see the bounding box, we have enough
|
|
* information to output the GDI EPS preamble and we go
|
|
* to state PS_BBOX.
|
|
* PS_BBOX PostScript is still ignored until a record beginning
|
|
* with "%!PS" is found, putting us into state PS_DATA.
|
|
* PS_DATA In this state, PostScript records are not ignored because
|
|
* PostScript seen now is from the EPS file. These records
|
|
* are translated to GDI POSTSCRIPT_DATA escapes.
|
|
* If the PostScript trailer "pse\rpsb\r" is encountered,
|
|
* it is ignored. If a PostScriptEnd comment is found
|
|
* it signals the end of the EPS data. We output the
|
|
* GDI PostScript trailer and we go back to state PS_NONE.
|
|
*
|
|
* Comment PostScriptHandle:
|
|
* if state == PS_NONE & data == "pse\rpsb\r"
|
|
* state = PS_PREAMBLE
|
|
* else if state == PS_PREAMBLE & data == "[ %d %d %d %d ]"
|
|
* state = PS_BBOX; output GDI EPS preamble
|
|
* else if state == PS_BBOX & data begins with "%!PS"
|
|
* state = PS_DATA
|
|
* else if state == PS_DATA
|
|
* if data == "pse\rpsb\r" ignore (is Mac PS trailer)
|
|
* else output PostScript data to GDI
|
|
*
|
|
* Comment PostScriptEnd:
|
|
* if state == PS_DATA
|
|
* state = PS_NONE; output GDI EPS trailer; exit
|
|
*
|
|
* QuickDraw primitives:
|
|
* translate QuickDraw to GDI normally
|
|
*
|
|
****/
|
|
#define PS_ERROR (-1)
|
|
#define PS_NONE 0
|
|
#define PS_PREAMBLE 1
|
|
#define PS_BBOX 2
|
|
#define PS_DATA 3
|
|
#define PS_ENDWAIT 4
|
|
|
|
private Integer EPSComment(Word comment)
|
|
{
|
|
static Integer state = PS_NONE;
|
|
|
|
switch (comment)
|
|
{
|
|
case picPostScriptBegin:
|
|
break;
|
|
|
|
case picPostScriptEnd:
|
|
if (state == PS_DATA)
|
|
{
|
|
GdiEPSTrailer(); // output GDI trailer
|
|
state = PS_NONE; // end, successful translation
|
|
}
|
|
break;
|
|
|
|
case picPostScriptHandle:
|
|
if ((state = EPSData(state)) < 0) // process EPS data
|
|
return (-1); // error during processing
|
|
break;
|
|
|
|
default: // not a PostScript comment
|
|
return (0);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/****
|
|
*
|
|
* Integer EPSData(Integer state)
|
|
* Process EPS Data found in the PostScriptHandle comment.
|
|
* What we do with the EPS data depends on the current state
|
|
* we are in and what the PostScript data looks like.
|
|
*
|
|
* State PS Data Action
|
|
* ----------------------------------------------------------------
|
|
* PS_NONE PS preamble string state = PS_BEGIN
|
|
* PS_PREAMBLE [ ... ] state = PS_BBOX, output GDI preamble
|
|
* PS_BBOX %!PS state = PS_DATA
|
|
* PS_DATA PS preamble string ignore, is Mac PS trailer
|
|
* PS_DATA PS data output as GDI PS data
|
|
*
|
|
* The Mac PostScript preamble string indicates that the PostScript
|
|
* data was from the Mac EPS filter. It puts us into PS_PREAMBLE state
|
|
* where we look for the bounding box specification (which begins
|
|
* with "["). When this is found, we go to state PS_BBOX and output
|
|
* the GDI EPS preamble using the bounding box. From PS_BBOX we can
|
|
* go into state PS_DATA when we find the record beginning with !PS
|
|
* which designates the start of the read EPS data.
|
|
*
|
|
* Once in state PS_DATA, PostScript data is buffered up into GDI
|
|
* printer escapes and output to the GDI stream. These are the only
|
|
* PostScript records that are translated - all others are ignored.
|
|
*
|
|
****/
|
|
private Integer EPSData(Integer state)
|
|
{
|
|
GLOBALHANDLE h;
|
|
PSBuf far* psbuf;
|
|
char far* ptr;
|
|
Word len = 0;
|
|
Rect ps_bbox;
|
|
|
|
/*
|
|
* Allocate a buffer for the PostScript data. The first WORD
|
|
* of the buffer gives the number of bytes of PostScript data.
|
|
* The actual data follows. This is the format needed for
|
|
* the GDI Escape call.
|
|
*/
|
|
GetWord(&len); // length of EPS comment
|
|
if ((h = GlobalAlloc(GHND, (DWORD) len + sizeof(PSBuf))) == 0)
|
|
{
|
|
ErSetGlobalError(ErMemoryFull); // memory allocation error
|
|
return (-1);
|
|
}
|
|
psbuf = (PSBuf far *) GlobalLock(h);
|
|
psbuf->length = len; // save byte length
|
|
ptr = (char far *) &psbuf->data; // -> PostScript data
|
|
while (len-- != 0) GetByte(ptr++); // read PS data into buffer
|
|
*ptr = 0 ; // null terminate it
|
|
ptr = (char far *) &psbuf->data; // -> PostScript data
|
|
|
|
/* If this is a superPaint file, and postscript is being processed,
|
|
check if this is a situation where text could be mangled beyond
|
|
belief and requires adjustment in the parsing process. */
|
|
if (superPaintFile && state == PS_NONE)
|
|
{
|
|
char save;
|
|
Word start = lstrlen( SUPERPAINT_TEXTSTARTJUNK );
|
|
Word stop = lstrlen( SUPERPAINT_TEXTSTOPJUNK );
|
|
|
|
/* Assume that this text is OK for now */
|
|
badSuperPaintText = FALSE;
|
|
|
|
/* If this buffer is long enough to hold the begin and end of the bogus
|
|
test Postcript commands (dealing with rotation and shearin)... */
|
|
if (psbuf->length > (start + stop))
|
|
{
|
|
/* Create a string and compare for the beginning sequence and ending
|
|
sequences. Restore the null "C" terminator after finished. */
|
|
save = *(ptr + start);
|
|
*(ptr + start) = 0;
|
|
badSuperPaintText = (lstrcmp(ptr, SUPERPAINT_TEXTSTARTJUNK) == 0 &&
|
|
lstrcmp(ptr + psbuf->length - stop, SUPERPAINT_TEXTSTOPJUNK) == 0);
|
|
*(ptr + start) = save;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If PostScript preamble is found in state PS_NONE we can advance to
|
|
* state PS_PREAMBLE. If it is found again before state PS_DATA,
|
|
* we have an incorrect sequence and should not translate this EPS.
|
|
* On the MAC, the preamble is the same as the trailer and, if found
|
|
* during state PS_ENDWAIT, it signals the end of EPS processing.
|
|
*/
|
|
if (lstrcmp(ptr, MAC_PS_PREAMBLE) == 0)
|
|
switch (state)
|
|
{
|
|
case PS_NONE: // waiting for preamble
|
|
state = PS_PREAMBLE;
|
|
break;
|
|
|
|
case PS_DATA: // ignore Mac trailer
|
|
break;
|
|
|
|
default: // error if found in other states
|
|
state = PS_NONE; // abort EPS processing
|
|
break;
|
|
}
|
|
/*
|
|
* PostScript date was not MAC EPS preamble. Process other states
|
|
*/
|
|
else switch (state)
|
|
{
|
|
case PS_PREAMBLE: // waiting for bbox
|
|
if (EPSBbox(psbuf, &ps_bbox))
|
|
{
|
|
GdiEPSPreamble(&ps_bbox);
|
|
state = PS_BBOX; // parsed bbox, wait for EPS data
|
|
}
|
|
break;
|
|
|
|
case PS_BBOX: // waiting for !PS
|
|
if ((ptr[0] == '%') &&
|
|
(ptr[1] == '!') &&
|
|
(ptr[2] == 'P') &&
|
|
(ptr[3] == 'S'))
|
|
state = PS_DATA; // found start of EPS data
|
|
else break;
|
|
|
|
case PS_DATA: // output EPS data to GDI
|
|
if (lstrcmp(ptr, MAC_PS_TRAILER) != 0)
|
|
GdiEPSData(psbuf); // but ignore PS trailer
|
|
state = PS_DATA;
|
|
break;
|
|
}
|
|
GlobalUnlock(h);
|
|
GlobalFree(h); // free PostScript buffer
|
|
return (state);
|
|
}
|
|
|
|
/****
|
|
*
|
|
* Boolean EPSBbox(PSBuf, Rect far *)
|
|
* Parse EPS bounding box string [ %d %d %d %d ] and store corners
|
|
* of bounding box in given rectangle.
|
|
*
|
|
* returns:
|
|
* 0 = cannot parse bounding box descriptor
|
|
* 1 = bounding box successfully parsed
|
|
*
|
|
****/
|
|
private Boolean EPSBbox(PSBuf far *psbuf, Rect far *bbox)
|
|
{
|
|
char far* ptr = psbuf->data;
|
|
|
|
while ((*ptr == ' ') || (*ptr == '\t') || (*ptr == '\n'))
|
|
++ptr;
|
|
if (*ptr++ != '[') return (0);
|
|
if (!(ptr = parse_number(ptr, &bbox->left))) return (0);
|
|
if (!(ptr = parse_number(ptr, &bbox->top))) return (0);
|
|
if (!(ptr = parse_number(ptr, &bbox->right))) return (0);
|
|
if (!(ptr = parse_number(ptr, &bbox->bottom))) return (0);
|
|
if (*ptr != ']') return(0);
|
|
return(1);
|
|
}
|
|
|
|
private char far* parse_number(char far* ptr, Integer far *iptr)
|
|
{
|
|
Boolean isneg = 0; // assume positive
|
|
Integer n = 0;
|
|
|
|
while ((*ptr == ' ') || (*ptr == '\t'))
|
|
++ptr; // skip whitespace
|
|
if (*ptr == '-') // number is negative?
|
|
{
|
|
isneg = 1;
|
|
++ptr;
|
|
}
|
|
if (!IsCharDigit(*ptr)) return(0); // digit must follow
|
|
do n = n * 10 + (*ptr++ - '0');
|
|
while (IsCharDigit(*ptr));
|
|
if (*ptr == '.') // skip any digits following decimal pt
|
|
{
|
|
do ++ptr;
|
|
while (IsCharDigit(*ptr));
|
|
}
|
|
while ((*ptr == ' ') || (*ptr == '\t'))
|
|
++ptr; // skip whitespace
|
|
if (isneg) n = -n; // remember the sign
|
|
*iptr = n;
|
|
return (ptr);
|
|
}
|