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. { BOOL retvalue; // Get friendly pointer to the polypolygon data. POLYPOLYGON_INFO16 *pPolyInfo = (POLYPOLYGON_INFO16 *) pRec->rdParm; // Used to read coordinates from the data structure DocCoord Coord; // Used to set the bound rectangle of the path. DocRect BoundingRect; // Find out how many polygons there are UINT32 NumPolys = (UINT32) pPolyInfo->PolyCount; // Find out how big this path is so we can give the path class a hint about how big // to make it's initial arrays. // Get pointer to start of polygon vertex counts INT16 *pVertCount = pPolyInfo->VertCounts; UINT32 NumSlots = 0; // Iterate through all the polygons to find the number of slots for this path. while (NumPolys > 0) { // Find out how many points there are NumSlots += (UINT32) *pVertCount; // Try next polygon pVertCount++; NumPolys--; } // Create a new NodePath object NodePath *pPath = new NodePath; if (pPath==NULL) return FALSE; // try and set up the path if (!pPath->SetUpPath(NumSlots)) { // 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(); // Reposition the vertex count pointer, and polygon count pVertCount = pPolyInfo->VertCounts; NumPolys = (UINT32) pPolyInfo->PolyCount; // Get pointer to start of polygon points POINT_16 *pCoord = (POINT_16 *) (pPolyInfo->VertCounts + NumPolys); // Iterate through all the polygons. while (NumPolys > 0) { // Find out how many points there are UINT32 NumPoints = (UINT32) *pVertCount; // Add the moveto to the path 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--; } // Try next polygon pVertCount++; NumPolys--; } // Remember current point pCoord--; CurrentPoint.x = pCoord->x; CurrentPoint.y = pCoord->y; // Terminate path properly. if (!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("dpp 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 // 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()); // Add attributes retvalue = AddAttributes(pPath); AddNodeToMetaFileGroup(pPath); return retvalue; NoMemory: // Error - Out of memory while reading metafile // 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::DecodeRectangle (  METARECORD *  pMetaRec  )  [protected]

Decodes the metafile rectangle command. We insert a Path into the tree of the correct size. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/95 Parameters: pMetaRec  - The metafile record [INPUTS] Returns: TRUE if we decoded it ok, FALSE if there was a problem Definition at line 2563 of file metafilt.cpp. { BOOL retvalue; TRACEUSER( "Jonathan", _T("Decoding Rectangle\n")); // Create a new NodePath pbject NodePath *pPath = new NodePath; if (pPath==NULL) return FALSE; // try and set up the path if (!pPath->SetUpPath(12,12)) { // 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 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)); // Insert the move to DocCoord Coord; Coord.x = Rect.lo.x; Coord.y = Rect.lo.y; if (!pPath->InkPath.InsertMoveTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; // Insert each of the line sections Coord.y = Rect.hi.y; if (!pPath->InkPath.InsertLineTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; Coord.x = Rect.hi.x; if (!pPath->InkPath.InsertLineTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; Coord.y = Rect.lo.y; if (!pPath->InkPath.InsertLineTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; Coord.x = Rect.lo.x; if (!pPath->InkPath.InsertLineTo(Coord)) // Not enough dynamic heap to insert the moveto command goto NoMemory; // Terminate path properly. if (!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("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 // Make sure that the path is not filled pPath->InkPath.IsFilled = TRUE; // 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::DecodeStretchBlt (  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 1761 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding Stretch Blt\n")); AllUnderstood = FALSE; return TRUE; }

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

Decodes the StretchDIB record from a metafile and makes a NodeBitmap object out of it. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/95 Parameters: pRec  - the Metafile record [INPUTS] Returns: TRUE if it decoded the record ok, FALSE if there was a problem Definition at line 1882 of file metafilt.cpp. { TRACEUSER( "Jonathan", _T("Decoding Stretch DIB\n")); // Get the bitmap info block LPWORD pWords = (LPWORD) pRec->rdParm; // Step over the Rop field and all the src coord fields // there are 7 words worth in a StretchDIBits function pWords+=7; // 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); // Create a NodeBitmap to put it in NodeBitmap* pNodeBitmap = BuildNodeBitmap(pBitmap, BoundsRect); // return Happy return TRUE; }

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

Decodes the TextOut function and makes a text story. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/95 Parameters: pMetaRec  - the record to decode [INPUTS] Returns: TRUE if it worked, FALSE if there was a problem Definition at line 2701 of file metafilt.cpp. { // Get the bitmap info block LPWORD pWords = (LPWORD) pMetaRec->rdParm; // Read in the number of chars in the string INT16 Count = (UINT16) *pWords++; // 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; } // Get a coord to house the string DocCoord Position(0,0); // Get the coordinates Position.y = (INT16) *pWords++; Position.x = (INT16) *pWords++; // transform them TransformCoord(&Position); // Build the text story TRACEUSER( "Jonathan", _T("Text Story : %s\n"), pString); 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::DoExport (  Operation *  , CCLexFile *  pFile, Document *  pDoc, METAFILEPICT *  pMetaInfo )

Definition at line 3668 of file metafilt.cpp. { // Get pointer to the spread to export. Spread *pSpread = GetFirstSpread(pDoc); ExportClipRect.MakeEmpty(); // Set up device context and render region for this export. // This will show a progress hourglass for the objects being rendered if (!PrepareToExport(NULL, pSpread)) { CleanUpAfterExport(); return FALSE; } // put out some sensible stuff on the front MetafileDC.SetMapMode(pMetaView->GetMetafileMapMode()); pMetaInfo->mm = pMetaView->GetMetafileMapMode(); // Export the data to the file BOOL ok = ExportRender(ExportRegion); HMETAFILE hMetafile = NULL; if (ok) { // get a metafile handle from the metafile DC hMetafile = MetafileDC.Close(); if (hMetafile==NULL) { ERROR1RAW(_R(IDE_MF_NOCLOSE)); ok = FALSE; } } // If at this point, something has gone wrong, tidy up if (!ok) { // Get rid of the metafile if (hMetafile) DeleteMetaFile(hMetafile); // Tidy up and fail CleanUpAfterExport(); return FALSE; } // Put up a progress display/hourglass String_64 ProgressString(_R(IDT_EXPORTMSG_METAFILE2)); ProgressString = GetExportProgressString(pFile, _R(IDT_EXPORTMSG_METAFILE2)); BeginSlowJob(100, FALSE, &ProgressString); // Fill in the info about the metafile that we know // make it bigger as the coords we use are smaller than most. FIXED16 PixelSize; pMetaView->GetPixelSize(&PixelSize, &PixelSize); INT32 Size = PixelSize.MakeLong(); pMetaInfo->xExt = ExportClipRect.Width() / Size; pMetaInfo->yExt = ExportClipRect.Height() / Size; pMetaInfo->hMF = hMetafile; // All done - deallocate dynamic objects, stop the progress display/hourglass // and return success. (Also closes file). CleanUpAfterExport(); EndSlowJob(); return ok; }

BOOL MetaFileFilter::DoExport (  Operation *  , CCLexFile *  , PathName *  , Document *  , BOOL  )  [virtual]

Reimplemented from Filter. Definition at line 3550 of file metafilt.cpp. { // Used to open the file up before starting DoExport. But this meant a cancel on the export // options dialog had filled the file, if it was already present. So now up up here if // not open already. In the PreviewBitmap case the file will already be open. if (!pFile->isOpen()) { if (pFile->IsKindOf(CC_RUNTIME_CLASS(CCDiskFile))) { BOOL ok = OpenExportFile((CCDiskFile*) pFile, pPath); if (!ok) return FALSE; } else { TRACEUSER( "JustinF", _T("Tried to open non-CCDiskFile in MetaFileFilter::DoExport\n")); return FALSE; } } // Get pointer to the spread to export. Spread* pSpread = GetFirstSpread(pDoc); ExportClipRect.MakeEmpty(); // Set up device context and render region for this export. // This will show a progress hourglass for the objects being rendered if (!PrepareToExport(pFile, pSpread)) { CleanUpAfterExport(); return FALSE; } // put out some sensible stuff on the front MetafileDC.SetMapMode(pMetaView->GetMetafileMapMode()); // Export the data to the file BOOL ok = ExportRender(ExportRegion); HMETAFILE hMetafile = NULL; // If there have been no errors so far, find out about the metafile if (ok) { // get a metafile handle from the metafile DC hMetafile = MetafileDC.Close(); if (hMetafile == NULL) { ERROR1RAW( _R(IDE_MF_NOCLOSE) ); ok = FALSE; } } // and clean up if (!ok) { if (hMetafile) DeleteMetaFile(hMetafile); CleanUpAfterExport(); return FALSE; } // Put up a progress display/hourglass // (0 - 100, FALSE => no delay, show it NOW!, use the filters export message) String_64 ProgressString(_R(IDT_EXPORTMSG_METAFILE2)); ProgressString = GetExportProgressString(pFile, _R(IDT_EXPORTMSG_METAFILE2)); BeginSlowJob(100, FALSE, &ProgressString); // build standard placeable metafile header METAFILEHEADER Header; Header.key = METAFILEHEADERKEY; Header.hmf = 0; Header.inch = pMetaView->GetMetafileDPI(); Header.reserved = 0L; Header.checksum = 0; // And fill in the details about the Bounding rect FIXED16 PixelSize; pMetaView->GetPixelSize(&PixelSize, &PixelSize); INT32 Size = PixelSize.MakeLong(); Header.bbox.left = (short) (ExportClipRect.lo.x / Size); Header.bbox.top = (short) (ExportClipRect.lo.y / Size); Header.bbox.right = (short) (ExportClipRect.hi.x / Size); Header.bbox.bottom = (short) (ExportClipRect.hi.y / Size); // calculate checksum as Word checks this LPWORD p = (LPWORD) &Header; INT32 i = 10; while (i--) { // Just OR together all the WORDs in the Header Header.checksum ^= *p++; } // actually write to the file ok = WriteToFile( hMetafile, &Header ); DeleteMetaFile( hMetafile ); // All done - deallocate dynamic objects, stop the progress display/hourglass // and return success. (Also closes file). CleanUpAfterExport(); EndSlowJob(); // return, saying if it worked or not return ok; }

BOOL MetaFileFilter::DoImport (  SelOperation *  Op, CCLexFile *  , Document *  DestDoc, BOOL  AutoChosen, ImportPosition *  Pos = NULL, KernelBitmap **  ppImportedBitmap = NULL, DocCoord *  pPosTranslate = NULL, String_256 *  URL = NULL )  [virtual]

Reimplemented from Filter. Definition at line 1376 of file metafilt.cpp. { // Set up value for each import InFile = 0; // We need to know which document later on TheDocument = DestDoc; // Let's get ready if (!PrepareToImport()) return FALSE; // Make sure that there is a layer to put the bitmap onto if (!MakeSureLayerExists(DestDoc)) // There is no layer and one could not be made, so we will have to fail return FALSE; // Find the layer on the first page of this document... pLayer = GetActiveLayer(DestDoc); ENSURE(pLayer != NULL, "Spread has no active layer"); NodeGroup* pGroup = new NodeGroup; if (!pGroup) return FALSE; pNode = pGroup; // Put the group in the tree AttachNodeDirection dir; Node *pInsertPoint = pLayer->FindLastChild(); if (pInsertPoint) { if (pInsertPoint->IsAnInsertionNode()) dir = PREV; else dir = NEXT; } else { pInsertPoint = pLayer; dir = LASTCHILD; } Op->DoInsertNewNode(pGroup, // Node to insert pInsertPoint, // Context dir, // AttachDirection TRUE, // InvalidateRegion TRUE, // ClearSelection TRUE, // SelectNewObject FALSE); // NormaliseAttributes // Set last inserted node to zero so the next node is inserted as a child of pGroup pLastInsertedNode = 0; ImportInfo.pOp = Op; if (pPos == NULL) { ImportInfo.Pos.pSpread = GetFirstSpread(DestDoc); DocCoord centre = ImportInfo.Pos.pSpread->FindFirstPageInSpread()->GetPageRect().Centre(); ImportInfo.Pos.Position.x = centre.x; ImportInfo.Pos.Position.y = centre.y; } else ImportInfo.Pos = *pPos; // now read the file etc using virtual function so does different things on different // sub-classes AllUnderstood = TRUE; BOOL Worked = OpenAndIterateMetafile( pDiskFile ); CleanUpAfterImport(); if (InFile) { _lclose(InFile); InFile = 0; } if (!Worked) { // pGroup->CascadeDelete(); // delete pGroup; return FALSE; } // Get the final group under the mouse cursor (or coords // set above if this is not a drag'n'drop) pGroup->InvalidateBoundingRect(); DocCoord GroupCentre = pGroup->GetBoundingRect().Centre(); DocCoord GroupTrans; GroupTrans.x = ImportInfo.Pos.Position.x - GroupCentre.x; GroupTrans.y = ImportInfo.Pos.Position.y - GroupCentre.y; Trans2DMatrix trans(GroupTrans.x, GroupTrans.y); pGroup->Transform(trans); pGroup->InvalidateBoundingRect(); Op->DoInvalidateNodeRegion(pGroup, FALSE, FALSE, FALSE); // Post import if ((TheDocument!=NULL) && (pNode!=NULL)) TheDocument->PostImport(); // If it worked, but there was something we did not understand, explain to the user if ((Worked) && (!AllUnderstood)) { Error::SetError(_R(IDS_MEATFILE_WARN), 0); InformWarning(); Error::ClearError(); } return Worked; }

HMETAFILE MetaFileFilter::GetMetaFileHandle (  LPSTR  Filename, METADATA *  pMetaData )  [protected]

Given a filename, obtain a handle to the metafile, and provide basic info about the metafile. (Based on code written by Andy for MetaView). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 29/03/94 Parameters: Filename  - name of the file to attempt to load as a metafile. [INPUTS] pMetaData  - various data about the metafile, if it was loaded successfully. [OUTPUTS] Returns: Handle to the loaded metafile, or NULL if an error occured. Errors: Unable to open file; Unable to read enough data from file; Header looks invalid; Out of memory. See also: METADATA Definition at line 1590 of file metafilt.cpp. { OFSTRUCT OpenBuf; // Try to open the file OpenBuf.cBytes = sizeof(OpenBuf); InFile = OpenFile(Filename, &OpenBuf, OF_READ); // Did it work ok? if (InFile == HFILE_ERROR) return NULL; // Read in the first dword of the file to see if this is a placeable metafile INT32 BytesRead = _lread(InFile, &pMetaData->Header, sizeof(DWORD)); if (BytesRead != sizeof(DWORD)) { // Unable to read from the file - return error. _lclose(InFile); InFile = 0; return NULL; } METAHEADER MetaHeader; // Is this a placeable metafile? if (pMetaData->Header.key != METAFILEHEADERKEY) { // Not placable - if it looks OK, let the system read it // Go to the start of the file, read the header in, and close the file. _llseek(InFile, 0L, 0); _lread(InFile, &MetaHeader, sizeof(MetaHeader)); _lclose(InFile); InFile = 0; if (!MetaFileHeaderIsOk(&MetaHeader)) // Can't handle this file - return ERROR return NULL; // Looks ok - get the system to try and read it pMetaData->Placeable = FALSE; return ::GetMetaFile(Filename); } // Read the placeable header in. BytesRead = _lread(InFile, (LPVOID) &(pMetaData->Header.hmf), sizeof(METAFILEHEADER)-sizeof(DWORD)); // Did it work? if (BytesRead!=(sizeof(METAFILEHEADER)-sizeof(DWORD))) { // No - return error _lclose(InFile); InFile = 0; return NULL; } // Read standard metafile header in. BytesRead = _lread(InFile, (LPSTR) &MetaHeader, sizeof(METAHEADER)); // Did it work? if (BytesRead != sizeof(METAHEADER)) { // No - return error. _lclose(InFile); InFile = 0; return NULL; } // Allocate memory for the metafile bits. GLOBALHANDLE MemHandle = GlobalAlloc(GHND, (MetaHeader.mtSize * 2L)); if (MemHandle == NULL) { // Didn't get the memory - return error _lclose(InFile); InFile = 0; return NULL; } // Lock the memory. LPSTR MemPtr = (LPSTR) GlobalLock(MemHandle); if (MemPtr == NULL) { // Unable to lock memory - return error GlobalFree(MemHandle); _lclose(InFile); InFile = 0; return NULL; } // Seek past the header _llseek(InFile, sizeof(METAFILEHEADER), 0); // Read metafile bits. BytesRead = _lread(InFile, MemPtr, (UINT32)(MetaHeader.mtSize * 2)); // Did we read the correct number of bytes? if ((UINT32) BytesRead == (MetaHeader.mtSize * 2)) { // Read the data ok - set the metafile bits. HMETAFILE MetaFileHandle; MetaFileHandle = SetMetaFileBitsEx(BytesRead, (LPBYTE) MemPtr); if (MetaFileHandle != NULL) { // At last - it's all worked; return the metafile handle pMetaData->Placeable = TRUE; return MetaFileHandle; } } // Failure - clean up and return error. GlobalUnlock(MemHandle); GlobalFree(MemHandle); _lclose(InFile); InFile = 0; return NULL; }

INT32 MetaFileFilter::HowCompatible (  PathName &  Filename, ADDR  HeaderStart, UINT32  HeaderSize, UINT32  FileSize )  [virtual]

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. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 29/03/94 Parameters: Filename  - name of the file. [INPUTS] HeaderStart - Address of the first few bytes of the file. HeaderSize - the number of bytes in the header pointed to by FileStart. FileSize - the size of the whole file, in bytes. Returns: A number between 0 and 10 - see base class version for details See also: Filter::HowCompatible; MetaFilefilter::MetaFileHeaderIsOk Reimplemented from Filter. Definition at line 1544 of file metafilt.cpp. { // Check to see if this is a placeable metafile. METAFILEHEADER *pMetaFileHeader = (METAFILEHEADER *) HeaderStart; if (pMetaFileHeader->key == METAFILEHEADERKEY) // It's a metafile return 10; // Not a placeable metafile - examine header for sane METAHEADER structure. METAHEADER *pMetaHeader = (METAHEADER *) HeaderStart; if (MetaFileHeaderIsOk(pMetaHeader)) { // Could be a metafile - check extension String Extension = Filename.GetType(); if (_tcsicmp((TCHAR *) Extension, "wmf") == 0) // Likely to be a metafile return 9; else // Could still be a metafile, but less likely return 5; } else // We can't handle this file return 0; }

BOOL MetaFileFilter::Init (  void   )  [virtual]

Initialise the filter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Returns: TRUE if it worked, FLASE if it failed Implements Filter. Definition at line 1071 of file metafilt.cpp. { // Get the OILFilter object // This is deleted in the base class destructor pOILFilter = new MetaFileOILFilter(this); if (pOILFilter==NULL) // Error state already set by new return FALSE; MetaFile = NULL; MetaFileDC = NULL; Handles = NULL; // Register ourselves with the clipboard: We can provide import and export mappings // between internal "vector" format and windows metafiles (CF_METAFILEPICT). // Our mapping has a priority level of 100. InternalClipboardFormat Format(CLIPTYPE_VECTOR); MetaFileClipMap::CreateAndRegister(CLIPMAP_IMPORTONLY, this, Format, CF_METAFILEPICT, 100); // All ok return TRUE; }

BOOL MetaFileFilter::IsDefaultDocRequired (  const TCHAR *  pcszPathName  )  [virtual]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: pcszPathName  pointer to the pathname to check [INPUTS] Returns: TRUE if the filter requires a default document, FALSE if not. See also: Filter::IsDefaultDocRequired; FilterFamily::IsDefaultDocRequired; CCamDoc::OnOpenDocument; FilterFamily::DoImport; Filter::DoImport; Reimplemented from Filter. Definition at line 1115 of file metafilt.cpp. { // No need to check the pathname, just return TRUE as all this current filter has no // concept of page size, layout etc and hence will require the default document. return TRUE; }

BOOL MetaFileFilter::MetaFileHeaderIsOk (  METAHEADER *  pHeader  )  [protected]

Evaluate a metafile header structure, to see if it looks like a real metafile. This is done as part of the auto-recognition process. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 29/03/94 Parameters: pHeader  - the header to check. [INPUTS] Returns: TRUE if the header looks ok; FALSE if not. See also: MetaFileFilter::HowCompatible Definition at line 1511 of file metafilt.cpp. { return( (pHeader->mtType == 1) && // disk-based (pHeader->mtHeaderSize >= 9) && (pHeader->mtHeaderSize < 100) && // assumes header wont get huge (pHeader->mtSize >= 9) && // minimum file size (pHeader->mtSize < 0xFF000000L) && // assume <24 bit file length (pHeader->mtVersion >= 0x200)); // allow Windows 2 MFs }

BOOL MetaFileFilter::OpenAndIterateMetafile (  CCLexFile *  pDiskFile  )  [protected, virtual]

Virtual fn which opens and enumerates the metafile. This can be overriden for other metafile-based readers (e.g. AldusFormatfilter). Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 10/3/95 Returns: TRUE if OK, FALSE if not (and sets error code). See also: MetaFileFilter::DoImport Definition at line 1255 of file metafilt.cpp. { // Try to open the file. if (!pDiskFile->IS_KIND_OF(CCDiskFile)) { TRACEUSER( "JustinF", _T("Non-CCDiskFile in MetaFileFilter::OpenAndIterateMetafile\n")); return FALSE; } METADATA MetaData; PathName Path = ((CCDiskFile*) pDiskFile)->GetPathName(); String_256 PathString = Path.GetPath(); MetaFile = GetMetaFileHandle((TCHAR*) PathString, &MetaData); if (MetaFile == NULL) { // MetaFile failed to open TRACEUSER( "Jonathan", _T("Could not open metafile\n")); ERROR(_R(IDT_IMPORT_NOTFOUND), FALSE); } // Set the placeable flag so the callback knows what kind of file this is. Placeable = MetaData.Placeable; // If this is a placeable, get the size and origin of this file. if (Placeable) { // Origin is bottom left of bounding box MetaFileOrigin.x = MetaData.Header.bbox.left; MetaFileOrigin.y = MetaData.Header.bbox.bottom; // Find out the width and height of the bbox FlipYCoords = FALSE; IsYExtentNegative = FALSE; // See which way up it all is INT32 YExtent = MetaData.Header.bbox.top-MetaFileOrigin.y; if (YExtent < 0) IsYExtentNegative = TRUE; // adjust the origin if needed if (MetaFileOrigin.y > MetaData.Header.bbox.top) YShift = -YExtent; // Scaling factor is defined in units per inch // Convert to millipoints: (n / units per inch) * 72000 Dpi = MetaData.Header.inch; ScaleFactor = (72000 / MetaData.Header.inch); TRACEUSER( "Jonathan", _T("Placable metafile -\n (%ld, %ld) %ld\n"), MetaFileOrigin.x, MetaFileOrigin.y, ScaleFactor); TRACEUSER( "Jonathan", _T("Bbox (%ld, %ld)\n (%ld, %ld)\n"), MetaData.Header.bbox.left, MetaData.Header.bbox.bottom, MetaData.Header.bbox.right, MetaData.Header.bbox.top); TRACEUSER( "Jonathan", _T("Is Negative %d\n"), IsYExtentNegative); } else { // Sensible default values for non-placeable metafiles. MetaFileOrigin.x = 0; MetaFileOrigin.y = 0; ScaleFactor = 72000 / 96; FlipYCoords = FALSE; YShift = 0; // By default windows has the 0,0 at the top left, we have it at the bottom left IsYExtentNegative = TRUE; Dpi = 96; TRACEUSER( "Jonathan", _T("Non-Placable metafile -\n Origin (%ld, %ld) ScaleFactor %ld\n"), MetaFileOrigin.x, MetaFileOrigin.y, ScaleFactor); TRACEUSER( "Jonathan", _T("Is Negative %d\n"), IsYExtentNegative); } // Find out the size of the file, in bytes. FileSize = GetMetaFileBitsEx(MetaFile, 0, NULL); if (FileSize == 0) { if (IsUserName("Rik")) TRACE( _T("Couldn't take size of the MetaFile\n")); ERROR(_R(IDT_IMPORT_NOTFOUND), FALSE); } // Create a device context for our metafile MetaFileDC = CreateMetaFile(NULL); if (MetaFileDC == NULL) { return FALSE; } // Set the progress indicator, this next bit might take a while. String_64 ImportMessage(_R(IDT_IMPORTMSG_METAFILE)); ImportMessage = GetImportProgressString(pDiskFile, _R(IDT_IMPORTMSG_METAFILE)); BeginSlowJob(FileSize, TRUE, &ImportMessage); // Process the metafile by enumerating it via GDI BOOL Worked = ::EnumMetaFile(MetaFileDC, MetaFile, DecodeMetaFile, (LPARAM) this); EndSlowJob(); return Worked; }

BOOL MetaFileFilter::PrepareToExport (  CCLexFile *  , Spread *  pSpread )  [protected, virtual]

Definition at line 3746 of file metafilt.cpp. { // the member variable OutputFile is deliberately a vanilla CCLexFile because // metafile output must be made to work to all file types, especially memory files OutputFile = pFile; // work out the clip rect by exporting the whole drawing // Start out with an empty clip rect DocRect SpreadRect; SpreadRect.MakeEmpty(); // We need to take into account the fact that some layers may not be visible Node* pNode = pSpread->FindFirstChild(); while (pNode!=NULL) { // See if this is a layer if (IS_A(pNode, Layer)) { // It sure is... lets see if it is visible Layer* pLayer = (Layer*) pNode; if (pLayer->IsVisible()) { // This one is visible, so union it in DocRect LayerRect = pLayer->GetBoundingRect(); SpreadRect = SpreadRect.Union(LayerRect); } } // Get the next sibling pNode = pNode->FindNext(); } // Set the clip rect DocRect ClipRect = SpreadRect; ExportClipRect = SpreadRect; // we need a View to Attach to, so that: // default Quality setting // CalcPixelWidth etc get called //View *pView = View::GetCurrent(); pMetaView = new MetafileView(); if (pMetaView==NULL) return FALSE; // Init the view if (!pMetaView->Init()) { delete pMetaView; pMetaView = NULL; return FALSE; } // now lets get a render region suitably contructed FIXED16 XScale, YScale; pMetaView->GetScaleFactor(&XScale, &YScale); Matrix Identity(XScale, YScale); // Don't use view scale; set to 1 FIXED16 Scale(1); // Create the region ExportRegion = OSRenderRegion::Create(ClipRect, Identity, Scale, RENDERTYPE_METAFILE16, pMetaView, TRUE ); if (ExportRegion == NULL) // Error already set by new, so just return return FALSE; // lets create a metafile DC now if (!MetafileDC.Create( NULL )) // create it in memory ERROR1( FALSE, _R(IDE_MF_NOCREATE) ); // need a refernce DC - don't just use the view window because it will get messed up // We use a fresh new screen DC if (!ReferenceDC.CreateIC( "DISPLAY", NULL, NULL, NULL )) ERROR1( FALSE, _R(IDE_MF_NOCREATE) ); // if we don't do this then a load of Getxxx calls will fail MetafileDC.SetAttribDC( ReferenceDC.m_hDC ); // this (i) stops paper etc from being rendered, and (ii) stops background rendering screwing us up MetafileDC.m_bPrinting = TRUE; // Attach to the right device return ExportRegion->AttachDevice(pMetaView, &MetafileDC, pSpread); }

BOOL MetaFileFilter::PrepareToImport (   )  [protected]

Sets up the MetaFile filter so it can read in a metafile. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Returns: TRUE if it succeeds, FALSE if not. Errors: None Definition at line 1133 of file metafilt.cpp. { // Not attached to a metafile ENSURE(MetaFile == NULL, "PrepareToImport: still attached to a metafile!"); MetaFile = NULL; ENSURE(MetaFileDC == NULL, "PrepareToImport: still attached to a metafile DC!"); MetaFileDC = NULL; // Get some attributes if (!SetUpCurrentAttrs()) return FALSE; // Get a handle table ENSURE(Handles == NULL, "PrepareToImport: still got a handle table!"); Handles = new HandleTable(this); if (Handles==NULL) // Error state already set by new return FALSE; // For progress cursor update. FileSize = 0; BytesRead = 0; // Prepare pseudo-graphics mode CurrentMappingMode = MM_TEXT; MetaFileOrigin.x = 0; MetaFileOrigin.y = 0; // Default to Black text TextColour = DocColour(0,0,0); return TRUE; }

void MetaFileFilter::ScaleCoord (  DocCoord *  C  )  [protected]

Definition at line 3423 of file metafilt.cpp. { // Scale the coordinates if (Placeable) { // Scale the X Coord C->x *= ScaleFactor; C->y *= ScaleFactor; } else { switch (CurrentMappingMode) { case MM_TEXT: // Scale is in pixels // Convert to millipoints C->x *= ScaleFactor; C->y *= ScaleFactor; break; case MM_LOMETRIC: // Scale of 0.1mm per unit // Convert to millipoints: n * (72000 / (10 * 25.4)) C->x *= (72000 / 254); C->y *= (72000 / 254); break; case MM_HIMETRIC: // Scale of 0.01mm per unit // Convert to millipoints: n * (72000 / (100 * 25.4)) C->x *= (72000 / 2540); C->y *= (72000 / 2540); break; case MM_LOENGLISH: // Scale of 0.01 inches per unit // Convert to millipoints: (n / 100) * 72000 C->x *= (72000 / 100); C->y *= (72000 / 100); break; case MM_HIENGLISH: // Scale of 0.001 inches per unit // Convert to millipoints: (n / 1000) * 72000 C->x *= (72000 / 1000); C->y *= (72000 / 1000); break; case MM_TWIPS: // Scale of 1/1440th of an inch per unit // Convert to millipoints: (n / 1440) * 72000 C->x *= (72000 / 1440); C->y *= (72000 / 1440); break; //case MM_ISOTROPIC: // ENSURE(FALSE, "Can't cope with ISOTROPIC mapping in metafiles!"); // break; //case MM_ANISOTROPIC: // ENSURE(FALSE, "Can't cope with ANISOTROPIC mapping in metafiles!"); // break; default: C->x *= ScaleFactor; C->y *= ScaleFactor; break; } } // Scale the Y Coord if (FlipYCoords) C->y = -C->y; }

void MetaFileFilter::SetLogicalFont (  LOGFONT_16 *  pNewFont  )

Makes a note of the selected font ready for when it is used. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/95 Parameters: pNewFont  - the details about the newly selected font [INPUTS] Definition at line 2846 of file metafilt.cpp. { // record the font // Copy the values from the 16 bit version to the 32 bit version SelectedFont.lfHeight = pNewFont->lfHeight; SelectedFont.lfWidth = pNewFont->lfWidth; SelectedFont.lfEscapement = pNewFont->lfEscapement; SelectedFont.lfOrientation = pNewFont->lfOrientation; SelectedFont.lfWeight = pNewFont->lfWeight; SelectedFont.lfItalic = pNewFont->lfItalic; SelectedFont.lfUnderline = pNewFont->lfUnderline; SelectedFont.lfStrikeOut = pNewFont->lfStrikeOut; SelectedFont.lfCharSet = pNewFont->lfCharSet; SelectedFont.lfOutPrecision = pNewFont->lfOutPrecision; SelectedFont.lfClipPrecision = pNewFont->lfClipPrecision; SelectedFont.lfQuality = pNewFont->lfQuality; SelectedFont.lfPitchAndFamily = pNewFont->lfPitchAndFamily; camStrcpy(SelectedFont.lfFaceName, pNewFont->lfFaceName); // Scale the text size according to the current mapping mode. switch (CurrentMappingMode) { case MM_TEXT: // Scale is in pixels SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / Dpi; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / Dpi; break; case MM_LOMETRIC: // Scale of 0.1mm per unit // Convert to 96 dpi SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / 254; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / 254; break; case MM_HIMETRIC: // Scale of 0.01mm per unit // Convert to millipoints: n * (72000 / (100 * 25.4)) SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / 2540; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / 2540; break; case MM_LOENGLISH: // Scale of 0.01 inches per unit // Convert to millipoints: (n / 100) * 72000 SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / 100; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / 100; break; case MM_HIENGLISH: // Scale of 0.001 inches per unit // Convert to millipoints: (n / 1000) * 72000 SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / 1000; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / 1000; break; case MM_TWIPS: // Scale of 1/1440th of an inch per unit // Convert to millipoints: (n / 1440) * 72000 SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / 1440; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / 1440; break; default: SelectedFont.lfHeight = (SelectedFont.lfHeight * 96) / Dpi; SelectedFont.lfWidth = (SelectedFont.lfWidth * 96) / Dpi; break; } }

void MetaFileFilter::TransformCoord (  DocCoord *  C  )  [protected]

Definition at line 3398 of file metafilt.cpp. { // Convert from metafile origin C->x -= MetaFileOrigin.x; C->y -= MetaFileOrigin.y; // Add in any offset that may be needed C->y += YShift; // Scale it ScaleCoord(C); }

BOOL MetaFileFilter::WriteToFile (  HMETAFILE  , METAFILEHEADER *  )  [protected, virtual]

Definition at line 3879 of file metafilt.cpp. { // write header first OutputFile->write( PlaceableHeader, sizeof(METAFILEHEADER) ); // now the actual data UINT32 size = GetMetaFileBitsEx( hMetafile, 0, NULL ); // does NOT invalidate hMetafile ERROR1IF( size==0, FALSE, _R(IDE_MF_NOMEMLOCK) ); LPVOID block = CCMalloc( size ); ERROR1IF( block==NULL, FALSE, _R(IDS_OUT_OF_MEMORY) ); size = GetMetaFileBitsEx( hMetafile, size, block ); if (size) { OutputFile->write( block, size ); CCFree( block ); return TRUE; } else { CCFree( block ); ERROR1( FALSE, _R(IDE_MF_NOMEMLOCK) ); } }

---

Friends And Related Function Documentation

friend class MetaFileClipMap [friend]

Definition at line 237 of file metafilt.h.

---

Member Data Documentation

BOOL MetaFileFilter::AllUnderstood [protected]

Definition at line 368 of file metafilt.h.

INT32 MetaFileFilter::BytesRead [protected]

Definition at line 354 of file metafilt.h.

INT32 MetaFileFilter::CurrentMappingMode [protected]

Definition at line 319 of file metafilt.h.

DocCoord MetaFileFilter::CurrentPoint [protected]

Definition at line 365 of file metafilt.h.

INT32 MetaFileFilter::Dpi [protected]

Definition at line 362 of file metafilt.h.

DocRect MetaFileFilter::ExportClipRect [protected]

Definition at line 381 of file metafilt.h.

RenderRegion* MetaFileFilter::ExportRegion [protected]

Definition at line 380 of file metafilt.h.

INT32 MetaFileFilter::FileSize [protected]

Definition at line 353 of file metafilt.h.

BOOL MetaFileFilter::FlipYCoords [protected]

Definition at line 321 of file metafilt.h.

HandleTable* MetaFileFilter::Handles [protected]

Definition at line 347 of file metafilt.h.

friend MetaFileFilter::HandleTable [protected]

Definition at line 350 of file metafilt.h.

CImportInfo MetaFileFilter::ImportInfo [protected]

Definition at line 340 of file metafilt.h.

HFILE MetaFileFilter::InFile [private]

Definition at line 392 of file metafilt.h.

BOOL MetaFileFilter::IsYExtentNegative [protected]

Definition at line 322 of file metafilt.h.

INT32 MetaFileFilter::LastProgressUpdate [protected]

Definition at line 354 of file metafilt.h.

HMETAFILE MetaFileFilter::MetaFile [protected]

Definition at line 271 of file metafilt.h.

CMetaFileDC MetaFileFilter::MetafileDC [protected]

Definition at line 379 of file metafilt.h.

HDC MetaFileFilter::MetaFileDC [protected]

Definition at line 272 of file metafilt.h.

DocCoord MetaFileFilter::MetaFileOrigin [protected]

Definition at line 320 of file metafilt.h.

CCLexFile* MetaFileFilter::OutputFile [protected]

Definition at line 377 of file metafilt.h.

BOOL MetaFileFilter::Placeable [protected]

Definition at line 358 of file metafilt.h.

Node* MetaFileFilter::pLastInsertedNode [private]

Definition at line 385 of file metafilt.h.

Layer* MetaFileFilter::pLayer [protected]

Definition at line 326 of file metafilt.h.

MetafileView* MetaFileFilter::pMetaView [protected]

Definition at line 382 of file metafilt.h.

Node* MetaFileFilter::pNode [protected]

Definition at line 329 of file metafilt.h.

CDC MetaFileFilter::ReferenceDC [protected]

Definition at line 378 of file metafilt.h.

MILLIPOINT MetaFileFilter::ScaleFactor [protected]

Definition at line 361 of file metafilt.h.

LOGFONT MetaFileFilter::SelectedFont [protected]

Definition at line 310 of file metafilt.h.

DocColour MetaFileFilter::TextColour [protected]

Definition at line 344 of file metafilt.h.

INT32 MetaFileFilter::YShift [protected]

Definition at line 323 of file metafilt.h.

---

The documentation for this class was generated from the following files:

• wxOil/metafilt.h (r1785/r1282)
• wxOil/metafilt.cpp (r1785/r1282)

---