MetaFileFilter Class Reference

Encapsulates a filter for importing Windows MetaFiles (16-bit only at the moment). More...

#include <metafilt.h>

Inheritance diagram for MetaFileFilter:

List of all members.

Public Member Functions
	MetaFileFilter ()
	MetaFile filter constructor - this initialises the default attributes.
	~MetaFileFilter ()
	Destructor for the metafile filter. Does nothing at present.
BOOL	Init ()
	Initialise the filter.
virtual BOOL	IsDefaultDocRequired (const TCHAR *pcszPathName)
	Works out if opening a file of this type requires a default document to be loaded. If the file format supplies the document then return FALSE otherwise return TRUE. An example would be opening a bitmap file. This has no document defined in the file format and so we need to laod the default document before importing the bitmap into this file. In this baseclass version return FALSE and hence assume that the filters that need to will override this function to return TRUE.
INT32	HowCompatible (PathName &Filename, ADDR HeaderStart, UINT32 HeaderSize, UINT32 FileSize)
	Find out how compatible a file is with this import filter, i.e. does it look like a metafile? It evaluates the header structure, and checks the file extension.
BOOL	DoImport (SelOperation *Op, CCLexFile *, Document *DestDoc, BOOL AutoChosen, ImportPosition *Pos=NULL, KernelBitmap **ppImportedBitmap=NULL, DocCoord *pPosTranslate=NULL, String_256 *URL=NULL)
BOOL	DoExport (Operation *, CCLexFile *, PathName *, Document *, BOOL)
BOOL	DoExport (Operation *, CCLexFile *pFile, Document *pDoc, METAFILEPICT *pMetaInfo)
void	SetLogicalFont (LOGFONT_16 *pNewFont)
	Makes a note of the selected font ready for when it is used.
Protected Member Functions
BOOL	PrepareToImport ()
	Sets up the MetaFile filter so it can read in a metafile.
void	CleanUpAfterImport ()
	Delete dynamic objects used in the import process.
BOOL	MetaFileHeaderIsOk (METAHEADER *pHeader)
	Evaluate a metafile header structure, to see if it looks like a real metafile. This is done as part of the auto-recognition process.
virtual BOOL	OpenAndIterateMetafile (CCLexFile *pDiskFile)
	Virtual fn which opens and enumerates the metafile. This can be overriden for other metafile-based readers (e.g. AldusFormatfilter).
HMETAFILE	GetMetaFileHandle (LPSTR Filename, METADATA *)
	Given a filename, obtain a handle to the metafile, and provide basic info about the metafile. (Based on code written by Andy for MetaView).
INT32	DecodeMetafileRecord (METARECORD *pMetaRec)
BOOL	DecodePolygon (METARECORD *pRec, BOOL FillPolygon)
	Given a Metafile record for a polygon, decode it and convert it into a Camelot path. This function is used to decode the Polygon and PolyLine records in a metafile. The only difference between the two is that polygons are filled and polylines are not, hence the FillPolygon flag that gets passed in.
BOOL	DecodePolyPolygon (METARECORD *)
	Given a Metafile record for a 'poly-polygon', decode it and convert it into a Camelot path.
BOOL	DecodeLineTo (METARECORD *pMetaRec)
	Decodes the metafile LineTo function and updates the current position.
BOOL	DecodeRectangle (METARECORD *pMetaRec)
	Decodes the metafile rectangle command. We insert a Path into the tree of the correct size.
BOOL	DecodeEllipse (METARECORD *pMetaRec)
	Decodes the metafile ellipse function.
BOOL	DecodeTextStory (METARECORD *pMetaRec)
	Decodes the TextOut function and makes a text story.
BOOL	DecodeExtTextStory (METARECORD *pMetaRec)
	Decodes the ExtTextOut function.
BOOL	DecodeStretchDIB (METARECORD *)
	Decodes the StretchDIB record from a metafile and makes a NodeBitmap object out of it.
BOOL	DecodeDIBStretchBlt (METARECORD *pMetaRec)
	Decodes the StretchBlt function in a Metafile. It builds a NodeBitmap and adds it to the tree.
BOOL	DecodeBitBlt (METARECORD *pMetaRec)
	Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc.
BOOL	DecodeStretchBlt (METARECORD *pMetaRec)
	Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc.
BOOL	DecodeDIBToDevice (METARECORD *pMetaRec)
	Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc.
BOOL	DecodeDIBBitBlt (METARECORD *pMetaRec)
	Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc.
KernelBitmap *	CreateBitmap (BITMAPINFO *pBitmapStart)
	This function expects to find the BITMAPINFO structure at the address passed in, immediatly followed by the Bitmap Bits (ie that actual bitmap data). This function will try to extract the bitmap info and the bitmap bits. It will also try to allocate memory to put a copy of the bitmap info into, and a seperate block of memory to put the bits in. It is assumed that the pointer passed in was found from inside a metafile so the memory is not owned by us. We need to make a copy so that we can keep the bitmap after the metafile is closed and thrown away by windows.
NodeBitmap *	BuildNodeBitmap (KernelBitmap *pBitmap, const DocRect &Position)
	This function creates a NodeBitmap and attaches the Kernel bitmap to it. When it creates the Node, it attaches it to the correct place in the sub tree that we are building.
void	TransformCoord (DocCoord *C)
void	ScaleCoord (DocCoord *C)
BOOL	AddAttributes (Node *pNewNode)
	Add attributes to the path object specified. The attributes are optimised so that if they are the same as the document's default attributes, they are not applied. The attributes applied are line and fill colour, and line style.
virtual BOOL	PrepareToExport (CCLexFile *, Spread *pSpread)
virtual void	CleanUpAfterExport ()
virtual BOOL	WriteToFile (HMETAFILE, METAFILEHEADER *)
Static Protected Member Functions
static INT32 CALLBACK	DecodeMetaFile (HDC hdc, HANDLETABLE FAR *pHandleTable, METARECORD FAR *pMetaRec, INT32 cObj, LPARAM lParam)
	Callback function for decoding metafiles. This is called by the SDK function EnumMetaFile, and decodes each record that it is passed into the relevant Camelot object.
Protected Attributes
HMETAFILE	MetaFile
HDC	MetaFileDC
LOGFONT	SelectedFont
INT32	CurrentMappingMode
DocCoord	MetaFileOrigin
BOOL	FlipYCoords
BOOL	IsYExtentNegative
INT32	YShift
Layer *	pLayer
Node *	pNode
CImportInfo	ImportInfo
DocColour	TextColour
HandleTable *	Handles
friend	HandleTable
INT32	FileSize
INT32	BytesRead
INT32	LastProgressUpdate
BOOL	Placeable
MILLIPOINT	ScaleFactor
INT32	Dpi
DocCoord	CurrentPoint
BOOL	AllUnderstood
CCLexFile *	OutputFile
CDC	ReferenceDC
CMetaFileDC	MetafileDC
RenderRegion *	ExportRegion
DocRect	ExportClipRect
MetafileView *	pMetaView
Private Member Functions
	CC_DECLARE_MEMDUMP (MetaFileFilter)
void	AddNodeToMetaFileGroup (NodeRenderableBounded *pNode)
	Inserts a new node into the group the meta file is being imported into.
Private Attributes
Node *	pLastInsertedNode
HFILE	InFile
Friends
class	MetaFileClipMap
Classes
struct	CImportInfo

---

Detailed Description

Encapsulates a filter for importing Windows MetaFiles (16-bit only at the moment).

Author:

Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>

Date:

08/03/94

See also:

Filter

Definition at line 235 of file metafilt.h.

---

Constructor & Destructor Documentation

MetaFileFilter::MetaFileFilter (   )

MetaFile filter constructor - this initialises the default attributes. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Definition at line 974 of file metafilt.cpp. { // Set up filter descriptions. FilterName.Load(_R(IDT_METAFILE_FILTERNAME)); FilterInfo.Load(_R(IDT_METAFILE_FILTERINFO)); FilterID = FILTERID_METAFILE; // We can import and export metafiles Flags.CanImport = TRUE ; Flags.CanExport = TRUE; OutputFile = NULL; ExportRegion = NULL; ExportMsgID = _R(IDT_EXPORTMSG_METAFILE1); // Default values FlipYCoords = FALSE; YShift = 0; IsYExtentNegative = FALSE; Dpi = 96; // Default to Black text TextColour = DocColour(0,0,0); // Set up the font SelectedFont.lfHeight = -96; SelectedFont.lfWidth = 0; SelectedFont.lfEscapement = 0; SelectedFont.lfOrientation = 0; SelectedFont.lfWeight = 0; SelectedFont.lfItalic = FALSE; SelectedFont.lfUnderline = FALSE; SelectedFont.lfStrikeOut = FALSE; SelectedFont.lfCharSet = 0; SelectedFont.lfOutPrecision = 3; SelectedFont.lfClipPrecision = 2; SelectedFont.lfQuality = 1; SelectedFont.lfPitchAndFamily = 18; camStrcpy(SelectedFont.lfFaceName, (TCHAR *)String_64(_R(IDS_METAFILT_FONT))/*"Times New Roman"*/); // Clear out the view pMetaView = NULL; };

MetaFileFilter::~MetaFileFilter (   )

Destructor for the metafile filter. Does nothing at present. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Definition at line 1057 of file metafilt.cpp. { }

---

Member Function Documentation

BOOL MetaFileFilter::AddAttributes (  Node *  pNewNode  )  [protected]

Add attributes to the path object specified. The attributes are optimised so that if they are the same as the document's default attributes, they are not applied. The attributes applied are line and fill colour, and line style. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Parameters: pPath  - pointer to the NodePath object to add attributes to. [INPUTS] pHeader - pointer to the Draw file object header which describes the path attributes. Returns: TRUE if the attributes were added ok, FALSE if not. Errors: Fails (returns FALSE) if not enough memory to add attributes. Scope: Private Definition at line 3515 of file metafilt.cpp. { // If not filled, then set the ignore bit on the fill attribute. if (pNewNode->IS_KIND_OF(NodePath)) { NodePath* pPath = (NodePath*) pNewNode; if (!pPath->InkPath.IsFilled) CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; } // Add attributes to the path, if they are different from the default... BOOL Result = AttributeManager::ApplyBasedOnDefaults(pNewNode, CurrentAttrs); // Enable the fill attribute again CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; // Return success or failure return Result; }

void MetaFileFilter::AddNodeToMetaFileGroup (  NodeRenderableBounded *  pNewNode  )  [inline, private]

Inserts a new node into the group the meta file is being imported into. Author: Jonathan_Payne (Xara Group Ltd) <camelotdev@xara.com> Date: 06/11/2000 Parameters: pNewNode  [INPUTS] Returns: True if all is OK Definition at line 1030 of file metafilt.cpp. { if (pLastInsertedNode) // The group we are adding to has some objects in it se we just need // to instert the new node as NEXT after pLastInsertedNode pNewNode->AttachNode(pLastInsertedNode, NEXT); else // pLastInsertedNode == 0 so this is the fist object to be inserted into the // group so the object is inserted as LASTCHILD of the group pNewNode->AttachNode(pNode, LASTCHILD); pNewNode->GetBoundingRect(); // Update pLastInsertedNode pointer pLastInsertedNode = pNewNode; }

NodeBitmap * MetaFileFilter::BuildNodeBitmap (  KernelBitmap *  pBitmap, const DocRect &  Position )  [protected]

This function creates a NodeBitmap and attaches the Kernel bitmap to it. When it creates the Node, it attaches it to the correct place in the sub tree that we are building. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/95 Parameters: pBitmap  - the bitmap to put in the NodeBitmap [INPUTS] Position - the rect that the bitmap will fill. Returns: A pointer to a NodeBitmap, or NULL if there was a problem Definition at line 2011 of file metafilt.cpp. { // Create a NodeBitmap to put it in NodeBitmap *pNodeBitmap = new NodeBitmap; if (pNodeBitmap==NULL) return NULL; // try and set up the bitmap if (!pNodeBitmap->SetUpPath(12,12)) { // Destroy the unwanted nodes pNodeBitmap->CascadeDelete(); delete pNodeBitmap; return NULL; } // Make the node bitmap use the bitmap we have found pNodeBitmap->GetBitmapRef()->Attach(pBitmap, GetDocument()); if (pNodeBitmap->GetBitmap() != pBitmap) { // It didn't use the bitmap we gave it, so we can delete it delete pBitmap; } // And set this in our bitmap node pNodeBitmap->CreateShape(Position); // And apply the default Bitmap attributes pNodeBitmap->ApplyDefaultBitmapAttrs(NULL); // return the bitmap we have made AddNodeToMetaFileGroup(pNodeBitmap); return pNodeBitmap; }

MetaFileFilter::CC_DECLARE_MEMDUMP (  MetaFileFilter   )  [private]

void MetaFileFilter::CleanUpAfterExport (   )  [protected, virtual]

Definition at line 3839 of file metafilt.cpp. { // Clean up the view if (pMetaView!=NULL) { delete pMetaView; pMetaView = NULL; } // Clean up the metafile DC if (MetafileDC.m_hDC) { MetafileDC.DeleteDC(); } // and the attribute DC if (ReferenceDC.m_hDC) { ReferenceDC.DeleteDC(); } // and make sure the file is closed if (OutputFile) { OutputFile->close(); // *dont* delete OutputFile because it turns out to be a static object... OutputFile = NULL; } }

void MetaFileFilter::CleanUpAfterImport (  void   )  [protected]

Delete dynamic objects used in the import process. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 24/02/94 See also: MetaFileFilter::PrepareToImport; MetaFileFilter::DoImport Definition at line 1177 of file metafilt.cpp. { DeleteCurrentAttrs(); // Release our handle to the metafile if (MetaFile != NULL) { if (!::DeleteMetaFile(MetaFile)) ENSURE(FALSE, "Error occured while closing metafile"); MetaFile = NULL; } // Release our handle to the metafile's DC if (MetaFileDC != NULL) { if (!::CloseMetaFile(MetaFileDC)) { ENSURE(FALSE, "Error occured while closing metafile"); } MetaFileDC = NULL; } // Get rid of our handle table delete Handles; Handles = NULL; }

KernelBitmap * MetaFileFilter::CreateBitmap (  BITMAPINFO *  pBitmapStart  )  [protected]

This function expects to find the BITMAPINFO structure at the address passed in, immediatly followed by the Bitmap Bits (ie that actual bitmap data). This function will try to extract the bitmap info and the bitmap bits. It will also try to allocate memory to put a copy of the bitmap info into, and a seperate block of memory to put the bits in. It is assumed that the pointer passed in was found from inside a metafile so the memory is not owned by us. We need to make a copy so that we can keep the bitmap after the metafile is closed and thrown away by windows. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/95 Parameters: pBitmapStart  - the start of the bitmap info. [INPUTS] Returns: A pointer to a KernelBitmap, or NULL if one could not be created Errors: Error _R(IDS_OUT_OF_MEMORY) if there is not enough memory for the new bitmap Definition at line 1949 of file metafilt.cpp. { // Find out about the bitmap header BITMAPINFOHEADER Header = pBitmapStart->bmiHeader; LPBYTE pData = NULL; // Allocate some ram for the bitmap LPBITMAPINFO pInfo = AllocDIB(Header.biWidth, Header.biHeight, Header.biBitCount, &pData); // See if it worked if ((pInfo==NULL) || (pData==NULL)) return NULL; // work out if there is a palette etc and if so, how big it is. INT32 OldPalSize = Header.biClrUsed * sizeof(RGBQUAD); INT32 NewPalSize = pInfo->bmiHeader.biClrUsed * sizeof(RGBQUAD); ERROR3IF(OldPalSize!=NewPalSize, "Palettes are of a different size"); // Work out where the real bits start LPBYTE pBitsStart = (LPBYTE) pBitmapStart; pBitsStart += sizeof(BITMAPINFOHEADER) + OldPalSize; // copy the bits into our new bitmap memcpy(pData, pBitsStart, Header.biSizeImage); // Copy the palette memcpy(pInfo->bmiColors, pBitmapStart->bmiColors, NewPalSize); // Finally create the WinBitmap with all this in it WinBitmap* pWinBitmap = new WinBitmap(pInfo, pData); // Check for out of memory if (pWinBitmap==NULL) return NULL; // Create a new KernelBitmap to put the WinBitmap into KernelBitmap* pKernelBmp = new KernelBitmap(pWinBitmap, FALSE); if (pKernelBmp==NULL) { delete pWinBitmap; return NULL; } // return the bitmap return pKernelBmp; }

BOOL MetaFileFilter::DecodeBitBlt (  METARECORD *  pMetaRec  )  [protected]

Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/95 Parameters: pMetaRec  - the metafile records that holds the info about the bitmap [INPUTS] Returns: TRUE if the bitmap was decoded, FALSE if there was a problem Definition at line 1740 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding Bit Blt\n")); AllUnderstood = FALSE; return TRUE; }

BOOL MetaFileFilter::DecodeDIBBitBlt (  METARECORD *  pMetaRec  )  [protected]

Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/95 Parameters: pMetaRec  - the metafile records that holds the info about the bitmap [INPUTS] Returns: TRUE if the bitmap was decoded, FALSE if there was a problem Definition at line 1801 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding DIB Bit Blt\n")); AllUnderstood = FALSE; return TRUE; }

BOOL MetaFileFilter::DecodeDIBStretchBlt (  METARECORD *  pRec  )  [protected]

Decodes the StretchBlt function in a Metafile. It builds a NodeBitmap and adds it to the tree. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/95 Parameters: pMetaRec  - the 16bit metafile record [INPUTS] Returns: TRUE if all went well, FALSE if there was a problem Definition at line 1821 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding DIBSTRETCHBLT\n")); AllUnderstood = FALSE; /* // Get the bitmap info block LPWORD pWords = (LPWORD) pRec->rdParm; // Step over the Rop field and all the src coord fields // There are 6 words worth of this in a StrecthBlt pWords+=6; // Read in all the coords for the bitmap INT16 DestYExt = (UINT16) *pWords++; INT16 DestXExt = (UINT16) *pWords++; INT16 DestY = (UINT16) *pWords++; INT16 DestX = (UINT16) *pWords++; // Get at the bitmap info structure, and the bitmap info header in that BITMAPINFO* pBmpInfo = (BITMAPINFO*) pWords; KernelBitmap* pBitmap = CreateBitmap(pBmpInfo); // There was an error, so send it up if (pBitmap==NULL) return FALSE; // First, set the rectangle to the right size for the bitmap... DocCoord Position((INT32)DestX, (INT32)DestY); DocCoord Size(Position.x + (INT32)DestXExt, Position.y + (INT32)DestYExt); // Get them in DocCoords TransformCoord(&Position); TransformCoord(&Size); // Build a rectangle DocRect BoundsRect; BoundsRect.lo.x = min(Position.x, Size.x); BoundsRect.lo.y = min(Position.y, Size.y); BoundsRect.hi.x = max(Position.x, Size.x); BoundsRect.hi.y = max(Position.y, Size.y); Poly // Create a NodeBitmap to put it in NodeBitmap* pNodeBitmap = BuildNodeBitmap(pBitmap, BoundsRect); */ // return Happy return TRUE; }

BOOL MetaFileFilter::DecodeDIBToDevice (  METARECORD *  pMetaRec  )  [protected]

Decodes the bitmap from the metafile and creates a NodeBitmap in the tree of the correct size etc. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/95 Parameters: pMetaRec  - the metafile records that holds the info about the bitmap [INPUTS] Returns: TRUE if the bitmap was decoded, FALSE if there was a problem Definition at line 1781 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding Set DIB To Device\n")); AllUnderstood = FALSE; return TRUE; }

BOOL MetaFileFilter::DecodeEllipse (  METARECORD *  pMetaRec  )  [protected]

Decodes the metafile ellipse function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/95 Parameters: pMetaRec  - the metafile record [INPUTS] Returns: TRUE if it decoded the ellipse ok, FALSE if not Definition at line 2505 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding Ellipse\n")); // Create a new NodePath pbject NodeEllipse *pElip = new NodeEllipse; if (pElip==NULL) return FALSE; // try and set up the ellipse if (!pElip->SetUpPath(12,12)) { // Couldn't initialise path - delete path (if created) and return error. pElip->CascadeDelete(); delete pElip; return FALSE; } // Get pointer to the first coord INT16 *pCoord = (INT16 *) (pMetaRec->rdParm); // Add the moveto to the path DocCoord TopRight((INT32) pCoord[1], (INT32) pCoord[2]); DocCoord BotLeft((INT32) pCoord[3], (INT32) pCoord[0]); TransformCoord(&TopRight); TransformCoord(&BotLeft); DocRect Rect(min(TopRight.x, BotLeft.x), min(TopRight.y, BotLeft.y), max(TopRight.x, BotLeft.x), max(TopRight.y, BotLeft.y)); // Create the ellipse pElip->CreateShape(Rect); pElip->InkPath.IsFilled = TRUE; // Add attributes BOOL retvalue = AddAttributes(pElip); AddNodeToMetaFileGroup(pElip); return retvalue; }

BOOL MetaFileFilter::DecodeExtTextStory (  METARECORD *  pMetaRec  )  [protected]

Decodes the ExtTextOut function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/95 Parameters: pMetaRec  - the metafile record for the ExtTextOut [INPUTS] Returns: TRUE if all went well, FALSE if there was a problem Definition at line 2768 of file metafilt.cpp. { // Get the info block LPWORD pWords = (LPWORD) pMetaRec->rdParm; // Get a coord to house the string DocCoord Position(0,0); // Get the coordinates Position.y = (INT16) *pWords++; Position.y -= SelectedFont.lfHeight; Position.x = (INT16) *pWords++; // transform the Coord TransformCoord(&Position); // Read in the number of chars in the string INT16 Count = (UINT16) *pWords++; // Read in the options flag INT16 Option = (UINT16) *pWords++; if (Option!=0) { // Read in the rectangle if its there pWords++; // left pWords++; // top pWords++; // right pWords++; // bottom } // Get a string char* pString = new char[Count+1]; if (pString==NULL) return FALSE; // Copy the chars into our new string camStrncpy(pString, (char*)pWords, Count); pString[Count] = 0; TRACE( _T("%s\n"), pString); // Find the coords while (Count>0) { pWords++; Count-=2; } // Build the text story TextStory* pNewStory = TextStory::CreateFromChars(Position, pString, NULL, GetDocument(), &SelectedFont, FALSE, &TextColour); // Clean up the string delete pString; // See if we have a new text story if (pNewStory==NULL) return FALSE; // Yes, put it in the tree AddNodeToMetaFileGroup(pNewStory); // Return return TRUE; }

BOOL MetaFileFilter::DecodeLineTo (  METARECORD *  pMetaRec  )  [protected]

Decodes the metafile LineTo function and updates the current position. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/95 Parameters: pMetaRec  - the metafile record [INPUTS] Returns: TRUE if it decoded the LineTo ok, FALSE if not Definition at line 2415 of file metafilt.cpp. { // The current position should hold the coord for the last point drawn (eg, after a // moveto or a previous line to. // Create a new NodePath object to put the line it NodePath *pPath = new NodePath; if (pPath==NULL) return FALSE; // Try and set up the path if (!pPath->SetUpPath(2)) { // Couldn't initialise path - delete path (if created) and return error. pPath->CascadeDelete(); delete pPath; return FALSE; } // Position tag at start of path. pPath->InkPath.FindStartOfPath(); pPath->InkPath.IsFilled = FALSE; // Insert a move to to the current point if (!pPath->InkPath.InsertMoveTo(CurrentPoint)) { // Clean it up pPath->CascadeDelete(); delete pPath; return FALSE; } // Decode the coord for the line to and update the current point CurrentPoint.y = (INT16) pMetaRec->rdParm[0]; CurrentPoint.x = (INT16) pMetaRec->rdParm[1]; TransformCoord(&CurrentPoint); // Insert a lineto to the new current point if (!pPath->InkPath.InsertLineTo(CurrentPoint)) { // Clean it up pPath->CascadeDelete(); delete pPath; return FALSE; } // Make sure that we have a vald path here... BOOL ChangesMade; if (!pPath->InkPath.EnsureValid(&ChangesMade)) { // We could not fix this path, so scrap it TRACE( _T("dl Found a path that was so badly damaged we had to throw it away\n")); Error::ClearError(); pPath->CascadeDelete(); delete pPath; // This path had nothing useful in it, so just return return TRUE; } #ifdef _DEBUG // See if we had to make any changes to the path if (ChangesMade) { // yep, we sure did - tell Rik all about it TRACE( _T("We had to change this path as it was corrupt\n")); } #endif // Add attributes BOOL retvalue = AddAttributes(pPath); AddNodeToMetaFileGroup(pPath); return retvalue; }

INT32 CALLBACK MetaFileFilter::DecodeMetaFile (  HDC  hdc, HANDLETABLE FAR *  pHandleTable, METARECORD FAR *  pMetaRec, INT32  cObj, LPARAM  lParam )  [static, protected]

Callback function for decoding metafiles. This is called by the SDK function EnumMetaFile, and decodes each record that it is passed into the relevant Camelot object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 08/03/94 Parameters: hdc  - the DC of the metafile. [INPUTS] pHandleTable - pointer to the handle table that GDI maintains while enumerating a metafile (NB this is not the same thing as the Camelot 'HandleTable' class). pMetaRec - pointer to the metafile record to be decoded. cObj - number of objects that have handles in the handle table (ignored). lParam - user data; actually a pointer to the relevant MetaFileFilter object. Returns: 1 => Keep enumerating the metafile 0 => An error occurred - stop enumerating the metafile now. Errors: Out of memory; Syntax error/corruption in metafile (e.g. trying to select a non-existent object). See also: MetaFileFilter Definition at line 1229 of file metafilt.cpp. { MetaFileFilter *Filter = (MetaFileFilter*)lParam; INT32 Result = Filter->DecodeMetafileRecord(pMetaRec); // If there was an error, return an error to the caller if (Result!=1) ERROR1(FALSE, _R(IDE_BADMETAFILE)); // if there was no error, return asking for the next record return 1; }

INT32 MetaFileFilter::DecodeMetafileRecord (  METARECORD *  pMetaRec  )  [protected]

BOOL MetaFileFilter::DecodePolygon (  METARECORD *  pRec, BOOL  FillPolygon )  [protected]

Given a Metafile record for a polygon, decode it and convert it into a Camelot path. This function is used to decode the Polygon and PolyLine records in a metafile. The only difference between the two is that polygons are filled and polylines are not, hence the FillPolygon flag that gets passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 29/03/94 Parameters: pRec  - the polygon record to decode. [INPUTS] FillPolygon - TRUE if the polygon should be filled with the current fill colour, FALSE if it should be just an outline Returns: TRUE if the polygon was decoded successfuly; FALSE otherwise. Errors: Out of memory. See also: MetaFileFilter; MetaFileFilter::DecodeMetaFile Definition at line 2255 of file metafilt.cpp. { DocRect BoundingRect; BOOL retvalue; // Get pointer to the polygon structure INT16 *pNumPoints; pNumPoints = (INT16 *) (pRec->rdParm); // Find out how many points there are UINT32 NumPoints; NumPoints = (UINT32) *pNumPoints; // Ignore anything with less than 2 points if (NumPoints < 2) return TRUE; // Create a new NodePath pbject NodePath *pPath = new NodePath; if (pPath==NULL) return FALSE; // Try and set it up if (!pPath->SetUpPath(NumPoints)) { // Couldn't initialise path - delete path (if created) and return error. // Destroy any half-created paths if (pPath != NULL) pPath->CascadeDelete(); // delete the unwanted path delete pPath; // Set the error for the caller of EnumMetaFile() to report return FALSE; } // Position tag at start of path. pPath->InkPath.FindStartOfPath(); // Get pointer to the first coord POINT_16 *pCoord = (POINT_16 *) (pNumPoints + 1); // Add the moveto to the path DocCoord Coord; Coord.x = pCoord->x; Coord.y = pCoord->y; TransformCoord(&Coord); if (!pPath->InkPath.InsertMoveTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; // Move past the moveto command pCoord++; NumPoints--; while (NumPoints > 0) { Coord.x = pCoord->x; Coord.y = pCoord->y; TransformCoord(&Coord); if (!pPath->InkPath.InsertLineTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; // Try next coordinate pCoord++; NumPoints--; } // Remember current point pCoord--; CurrentPoint.x = pCoord->x; CurrentPoint.y = pCoord->y; // Terminate path properly. if ((FillPolygon) && (!pPath->InkPath.CloseSubPath())) // Not enough dynamic heap to insert the closepath command goto NoMemory; // Make sure that we have a vald path here... BOOL ChangesMade; if (!pPath->InkPath.EnsureValid(&ChangesMade)) { // We could not fix this path, so scrap it TRACE( _T("dp Found a path that was so badly damaged we had to throw it away\n")); Error::ClearError(); // Destroy the path if (pPath != NULL) pPath->CascadeDelete(); // delete the unwanted path delete pPath; // and return without error return TRUE; } #ifdef _DEBUG // See if we had to make any changes to the path if (ChangesMade) { // yep, we sure did - tell Rik all about it TRACE( _T("We had to change this path as it was corrupt\n")); } #endif if (FillPolygon) { // Find out what fill colour we have (safe to do this as we only have flat fills // in metafiles), and use this to set the 'filled' flag on the path. FlatFillAttribute *pAttr; pAttr = (FlatFillAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; ENSURE(pAttr->IsKindOf(CC_RUNTIME_CLASS(FlatFillAttribute)), "Bad fill type in metafile filter"); pPath->InkPath.IsFilled = !(pAttr->Colour.IsTransparent()); } else { // Make sure that the path is not filled pPath->InkPath.IsFilled = FALSE; } // Add attributes retvalue = AddAttributes(pPath); AddNodeToMetaFileGroup(pPath); return retvalue; NoMemory: // Error - Out of memory while decoding polygon // Destroy any half-created paths if (pPath != NULL) pPath->CascadeDelete(); // delete the unwanted path delete pPath; // Set the error for the caller of EnumMetaFile() to report return FALSE; }

BOOL MetaFileFilter::DecodePolyPolygon (  METARECORD *  pRec  )  [protected]

Given a Metafile record for a 'poly-polygon', decode it and convert it into a Camelot path. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 29/03/94 Parameters: pRec  - the poly-polygon record to decode. [INPUTS] Returns: TRUE if the poly-polygon was decoded successfuly; FALSE otherwise. Errors: Out of memory. See also: MetaFileFilter; MetaFileFilter::DecodeMetaFile Definition at line 2064 of file metafilt.cpp. 02065 { 02066 BOOL retvalue; 02067 02068 // Get friendly pointer to the polypolygon data. 02069 POLYPOLYGON_INFO16 *pPolyInfo = (POLYPOLYGON_INFO16 *) pRec->rdParm; 02070 02071 // Used to read coordinates from the data structure 02072 DocCoord Coord; 02073 02074 // Used to set the bound rectangle of the path. 02075 DocRect BoundingRect; 02076 02077 // Find out how many polygons there are 02078 UINT32 NumPolys = (UINT32) pPolyInfo->PolyCount; 02079 02080 // Find out how big this path is so we can give the path class a hint about how big 02081 // to make it's initial arrays. 02082 02083 // Get pointer to start of polygon vertex counts 02084 INT16 *pVertCount = pPolyInfo->VertCounts; 02085 02086 UINT32 NumSlots = 0; 02087 02088 // Iterate through all the polygons to find the number of slots for this path. 02089 while (NumPolys > 0) 02090 { 02091 // Find out how many points there are 02092 NumSlots += (UINT32) *pVertCount; 02093 02094 // Try next polygon 02095 pVertCount++; 02096 NumPolys--; 02097 } 02098 02099 // Create a new NodePath object 02100 NodePath *pPath = new NodePath; 02101 if (pPath==NULL) 02102 return FALSE; 02103 02104 // try and set up the path 02105 if (!pPath->SetUpPath(NumSlots)) 02106 { 02107 // Couldn't initialise path - delete path (if created) and return error. 02108 // Destroy any half-created paths 02109 if (pPath != NULL) 02110 pPath->CascadeDelete(); 02111 02112 // delete the unwanted path 02113 delete pPath; 02114 02115 // Set the error for the caller of EnumMetaFile() to report 02116 return FALSE; 02117 } 02118 02119 // Position tag at start of path. 02120 pPath->InkPath.FindStartOfPath(); 02121 02122 // Reposition the vertex count pointer, and polygon count 02123 pVertCount = pPolyInfo->VertCounts; 02124 NumPolys = (UINT32) pPolyInfo->PolyCount; 02125 02126 // Get pointer to start of polygon points 02127 POINT_16 *pCoord = (POINT_16 *) (pPolyInfo->VertCounts + NumPolys); 02128 02129 // Iterate through all the polygons. 02130 while (NumPolys > 0) 02131 { 02132 // Find out how many points there are 02133 UINT32 NumPoints = (UINT32) *pVertCount; 02134 02135 // Add the moveto to the path 02136 Coord.x = pCoord->x; 02137 Coord.y = pCoord->y; 02138 TransformCoord(&Coord); 02139 if (!pPath->InkPath.InsertMoveTo(Coord)) 0214