CamelotEPSRenderRegion Class Reference

A render region for exporting files in the native EPS format. More...

#include <cameleps.h>

Inheritance diagram for CamelotEPSRenderRegion:

List of all members.

Public Member Functions
	CamelotEPSRenderRegion (DocRect ClipRect, Matrix ConvertMatrix, FIXED16 ViewScale)
	Initialise a render region for exporting Camelot EPS. Sets up the string to put in the %Creator comment.
virtual	~CamelotEPSRenderRegion ()
	destructor
void	GetValidPathAttributes ()
	See EPSRenderRegion::GetValidPathAttributes. This version checks and handles grad fill colours before calling the base class version.
void	GetRenderRegionCaps (RRCaps *pCaps)
	This function allows render regions to admit to what they can and can not render. This allows other areas of the program to come in and help render regions out in some situations, if they are unable to render everything. eg. an OSRenderRegion can not render transparancy.
BOOL	StartRender ()
	Prepare the render region for rendering (exporting).
BOOL	StopRender ()
	Deinitialise the render region after rendering (exporting).
void	DrawPathToOutputDevice (Path *DrawPath, PathShape shapePath=PATHSHAPE_PATH)
	Output all the commands required to render this path to the EPS file.
BOOL	DrawTransformedBitmap (NodeBitmap *pNodeBitmap)
	Plot an arbitrarily transformed bitmap using a matrix and an offset. The bitmap is assumed to occupy a rectangle at the origin, which has pixels 1 point across, and the matrix supplied transforms this area to the correct place. The Point parameter supplies an optional offset which can be applied after the transform. If the offset is 0,0, this means there is no offset (surprise, surprise!).
virtual SlowJobResult	DrawMaskedBitmap (const DocRect &Rect, KernelBitmap *pBitmap, MaskedRenderRegion *pMask, ProgressDisplay *Progress)
	Plots the bitmap using the mask supplied.
virtual BOOL	RenderChar (WCHAR ch, Matrix *pMatrix)
	Render a character, using the specified transform and current attributes in the render region.
virtual BOOL	NeedsPrintComponents (void)
	Lets the print component class know that they are needed in this format's export.
virtual void	ConditionalSuicide (void)
	Doesn't delete the object when invoked. This is to get around using a few if IS_A calls elsewhere in Camelot.
virtual BOOL	WriteNewLine (void)
	Outputs a new line tag to the file.
virtual void	OutputStrokeColour ()
	This simply calls EPSRenderRegion::OutputStrokeColour, as otherwise the ArtWorks version is used (which can't cope with the RGB colour tokens).
virtual void	OutputFillColour ()
	This simply calls EPSRenderRegion::OutputFillColour, otherwise this render region uses the overridden version found in ArtWorksEPSRenderRegion.
virtual BOOL	DrawParallelogramBitmap (DocCoord *Coords, OILBitmap *pBitmap, EFFECTTYPE Effect=EFFECT_RGB, DocColour *StartCol=NULL, DocColour *EndCol=NULL)
	Plot an arbitrarily transformed bitmap in the position specified.
Protected Member Functions
virtual BOOL	WriteEPSBoundingBox (void)
	Calls the base EPS bounding box function.
virtual BOOL	WriteProlog (KernelDC *)
	Output any PostScript prolog for this render region. For EPS and printing, this means output of our PostScript rendering procedures; for Native files we do nothing.
virtual BOOL	WriteSetup (KernelDC *)
	Output any PostScript setup for this render region. For EPS and printing, this means output of our PostScript code to initialise the context for rendering; for Native files we do nothing.
virtual BOOL	WriteEPSTrailerComments (void)
	Writes out an EPS trailer by calling the base class function.
BOOL	DrawClippedBitmap (Path *DrawPath)
	Render a clipped bitmap using the given path. This is because we can do clipped bitmap rendering in PostScript, and it is much cheaper to do it via PostScript instead of via the 'transparency' mask (via GDraw).
BOOL	SelectNewFont (WORD Typeface, BOOL Bold, BOOL Italic, MILLIPOINT Size)
	Get the font name being used by the Camelot EPS exporter.
BOOL	SelectNewFont (WORD Typeface, BOOL Bold, BOOL Italic, FIXED16 *abcd)
virtual BOOL	OutputGradFillColours (DocColour *StartCol, DocColour *EndCol, ColourContext *pContext=NULL)
BOOL	GetCurrFillEffect (UINT32 &EffectType)
	Return the state of the current fill effect in the EPS attributes stack.
void	ColourSeparateScanline24 (BYTE *DestBuffer, BYTE *SrcBuffer, INT32 PixelWidth)
	Copies the scanline of 24bpp RGB values from SrcBuffer to DestBuffer, running the pixels through colour separation tables en route.
Protected Attributes
EPSFontCache	FontInfo
BYTE *	SepTables

---

Detailed Description

A render region for exporting files in the native EPS format.

Author:

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

Date:

08/03/94

See also:

EPSRenderRegion; ArtWorksEPSRenderRegion

Definition at line 375 of file cameleps.h.

---

Constructor & Destructor Documentation

CamelotEPSRenderRegion::CamelotEPSRenderRegion (  DocRect  ClipRect, Matrix  ConvertMatrix, FIXED16  ViewScale )

Initialise a render region for exporting Camelot EPS. Sets up the string to put in the %Creator comment. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/94 See also: EPSRenderRegion::EPSRenderRegion Definition at line 3194 of file cameleps.cpp. : ArtWorksEPSRenderRegion(ClipRect, ConvertMatrix, ViewScale) { CreatorString = _T("Xara X"); SepTables = NULL; }

CamelotEPSRenderRegion::~CamelotEPSRenderRegion (   )  [virtual]

destructor Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/96 Definition at line 3216 of file cameleps.cpp. { if (SepTables != NULL) { CCFree(SepTables); SepTables = NULL; } }

---

Member Function Documentation

void CamelotEPSRenderRegion::ColourSeparateScanline24 (  BYTE *  DestBuffer, BYTE *  SrcBuffer, INT32  PixelWidth )  [protected]

Copies the scanline of 24bpp RGB values from SrcBuffer to DestBuffer, running the pixels through colour separation tables en route. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/96 Parameters: DestBuffer  - points to a destination 24bpp RGB scanline buffer [INPUTS] SrcBuffer - points to a source 24bpp RGB scanline buffer PixelWidth - The number of pixels to copy from Src to Dest If you're not colour-separating, then you should replace this function call with a simple memcpy. Notes: ONLY handles 24bpp RGB scanlines, and expects that SepTables points at the separation tables. The pixel bytes must be in the order R,G,B. NOTE that it handles data in RGB (postscript) format, rather than the normal Bitmap BGR format! All deep bitmap data separates to white on spot plates. The CMYK separation plates could have been written generically, but I have separated out the cases in order to squeeze a bit of speed out of the inner pixel conversion loop. The conversion algorithm is basically like this, only optimised to move as much work out of the loop as possible: MonoOn Cyan = SepTables + 0 // Find the look up tables Magenta = SepTables + 256 Yellow = SepTables + 512 UCR = SepTables + 768 BGT = SepTables + 1024 c = 255-r; m = 255-g; y = 255-b; k = min(c, m, y); kr = UCR[k]; ok = BGT[k]; c -= kr; m -= kr; y -= kr; if (c<0) c=0; if (m<0) m=0; if (y<0) y=0; oc = Cyan[c]; om = Magenta[m]; oy = Yellow[y]; MonoOff Definition at line 4100 of file cameleps.cpp. { ERROR3IF(DestBuffer == NULL || SrcBuffer == NULL || PixelWidth < 1, _T("Illegal params")); ERROR3IF(SepTables == NULL, _T("No separation tables!?")); ERROR3IF(CurrentColContext->GetColourPlate() == NULL, _T("The separation ColourPlate has gone missing!")); // --- A wee macro to find the Maximum of R,G,B, and place it into a variable called // Temp, which we define right now in function scope so it's always available BYTE Temp; #define TEMPMAX(R,G,B) \ { \ Temp = ((R) > (G)) ? (R) : (G); \ Temp = (Temp > (B)) ? Temp : (B); \ } // --- OK, let'ts get busy INT32 i; // Loop i BYTE Ink; // Temporary variable for storing the ink value in BYTE *UCR = SepTables + 768 + 255; // UCR is the 4th table, but this points at the // END of the table for optimisation - precalcs (255 - Temp) PORTNOTE("cms", "Disabled colour separations"); #ifndef EXCLUDE_FROM_XARALX BOOL PrintRGBBlackAsKey=XaraCMS::PrintRGBBlackAsKey; #else BOOL PrintRGBBlackAsKey=TRUE; #endif // I've unrolled the shared code for each plate in order to optimise the inner loop switch (CurrentColContext->GetColourPlate()->GetType()) { case COLOURPLATE_CYAN: { BYTE *LUT = SepTables + 0; // Cyan table is the 1st table for (i = 0; i < PixelWidth * 3; i += 3) { TEMPMAX(SrcBuffer[i], SrcBuffer[i+1], SrcBuffer[i+2]); if (!PrintRGBBlackAsKey || Temp > 0) { Ink = 255 - SrcBuffer[i]; // Cyan ink is (255 - Red) // Look up UCR(Key), which is UCR(255 - Temp), but the 255 is precalculated // into the base address above, so we i with (-Temp)! // Make Ink the ink value for the given plate. Crop at 0 if ((UINT32)Ink>(UINT32)UCR[-Temp]) Ink -= UCR[-Temp]; else Ink = 0; Ink = LUT[Ink]; DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255 - Ink; } else { DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255; } } } break; case COLOURPLATE_MAGENTA: { BYTE *LUT = SepTables + 256; // Magenta table is the 2nd table for (i = 0; i < PixelWidth * 3; i += 3) { TEMPMAX(SrcBuffer[i], SrcBuffer[i+1], SrcBuffer[i+2]); if (!PrintRGBBlackAsKey || Temp > 0) { Ink = 255 - SrcBuffer[i+1]; // Magenta ink is (255 - Green) // Look up UCR(Key), which is UCR(255 - Temp), but the 255 is precalculated // into the base address above, so we i with (-Temp)! // Make Ink the ink value for the given plate. Crop at 0 if ((UINT32)Ink>(UINT32)UCR[-Temp]) Ink -= UCR[-Temp]; else Ink = 0; Ink = LUT[Ink]; DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255 - Ink; } else { DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255; } } } break; case COLOURPLATE_YELLOW: { BYTE *LUT = SepTables + 512; // Yellow table is the 3rd table for (i = 0; i < PixelWidth * 3; i += 3) { TEMPMAX(SrcBuffer[i], SrcBuffer[i+1], SrcBuffer[i+2]); if (!PrintRGBBlackAsKey || Temp > 0) { Ink = 255 - SrcBuffer[i+2]; // Yellow ink is (255 - Blue) // Look up UCR(Key), which is UCR(255 - Temp), but the 255 is precalculated // into the base address above, so we i with (-Temp)! // Make Ink the ink value for the given plate. Crop at 0 if ((UINT32)Ink>(UINT32)UCR[-Temp]) Ink -= UCR[-Temp]; else Ink = 0; Ink = LUT[Ink]; DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255 - Ink; } else { DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255; } } } break; case COLOURPLATE_KEY: { BYTE *BGT = SepTables + 1024; // Black generation is the 5th table for (i = 0; i < PixelWidth * 3; i += 3) { // Get the maximum of R,G,B into Temp TEMPMAX(SrcBuffer[i], SrcBuffer[i+1], SrcBuffer[i+2]); if (!PrintRGBBlackAsKey || Temp > 0) { // Key = 255 - Temp. Look up Key in the Black Generation table Ink = BGT[255 - Temp]; DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255 - Ink; } else { DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 0; } } } break; case COLOURPLATE_SPOT: // Deep colour bitmaps cannot include spot colours, so they always separate out // to white... for (i = 0; i < PixelWidth * 3; i += 3) DestBuffer[i] = DestBuffer[i+1] = DestBuffer[i+2] = 255; break; default: ERROR3(_T("Unsupported separation plate!")); break; } // And finally, vape our helper macro #undef TEMPMAX }

void CamelotEPSRenderRegion::ConditionalSuicide (  void   )  [virtual]

Doesn't delete the object when invoked. This is to get around using a few if IS_A calls elsewhere in Camelot. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/00 Parameters: -  [INPUTS] Returns: - Reimplemented from RenderRegion. Reimplemented in NativeRenderRegion, and PrintPSRenderRegion. Definition at line 4846 of file cameleps.cpp. { // Don't delete this! }

BOOL CamelotEPSRenderRegion::DrawClippedBitmap (  Path *  DrawPath  )  [protected]

Render a clipped bitmap using the given path. This is because we can do clipped bitmap rendering in PostScript, and it is much cheaper to do it via PostScript instead of via the 'transparency' mask (via GDraw). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/95 Parameters: DrawPath  - the path to use to clip the bitmap fill. [INPUTS] Returns: TRUE if rendered ok; FALSE if not. Definition at line 5691 of file cameleps.cpp. { // Get a device context KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); // What we do is: export the path, save the graphics context, use the path as a clipping // region, render the bitmap, restore the graphics context, and optionally stroke the // path, if necessary. // make sure the eps-rr is set up with the correct path attributes, // as ExportPath() will only be rendering pure path information. GetValidPathAttributes(); // export our path. ExportPath(DrawPath, TRUE, TRUE); // Save the context pDC->OutputToken(_T("gs")); // export a 'clip' command. note that if our current winding rule is for even-odd // winding, we must export an 'eoclip' command instead. if (RR_WINDINGRULE() == EvenOddWinding) pDC->OutputToken(TEXT("eoclip")); else pDC->OutputToken(TEXT("clip")); // Render the bitmap - first, set up the parallelogram to render into. BitmapFillAttribute* pFillAttr = (BitmapFillAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; DocCoord Coords[4]; Coords[3] = *(pFillAttr->GetStartPoint()); Coords[2] = *(pFillAttr->GetEndPoint()); Coords[0] = *(pFillAttr->GetEndPoint2()); // Deduce the other co-ordinate (not used by DrawParalleogramBitmap(), but calculate // it just in case...) Coords[1].x = Coords[0].x + (Coords[2].x - Coords[3].x); Coords[1].y = Coords[0].y + (Coords[2].y - Coords[3].y); // Get the bitmap KernelBitmap *pKernelBitmap = pFillAttr->GetBitmap(); if (pKernelBitmap == NULL) return FALSE; // Render it. if (!DrawParallelogramBitmap(Coords, pKernelBitmap->ActualBitmap, GetFillEffect(), pFillAttr->GetStartColour(), pFillAttr->GetEndColour())) return FALSE; // Restore the context pDC->OutputToken(_T("gr")); // Work out if we should stroke the path TCHAR PathType[2] = _T("N"); if (!RR_STROKECOLOUR().IsTransparent()) { // Stroke path, leaving it open PathType[0] = 'S'; } PathVerb* Verbs = DrawPath->GetVerbArray(); INT32 NumCoords = DrawPath->GetNumCoords(); if (Verbs[NumCoords - 1] & PT_CLOSEFIGURE) // Path should be closed PathType[0] = tolower(PathType[0]); // Do the stroke command pDC->OutputToken(PathType); pDC->OutputNewLine(); // Ok if we got to here return TRUE; }

SlowJobResult CamelotEPSRenderRegion::DrawMaskedBitmap (  const DocRect &  Rect, KernelBitmap *  pBitmap, MaskedRenderRegion *  pMask, ProgressDisplay *  Progress )  [virtual]

Plots the bitmap using the mask supplied. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/95 Parameters: Point  - the position to plot the bitmap [INPUTS] pBitmap - The bitmap that needs plotting pMask - The mask render region to use to indicate which bits of pBitmap needs to be plotted Notes: Reimplemented from RenderRegion. Definition at line 4299 of file cameleps.cpp. { #ifndef STANDALONE KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); // Make sure the world is in one piece if ((pBitmap==NULL) || (pMask==NULL)) return SLOWJOB_FAILURE; // Are we doing actual EPS? If so, then we need to do some special stuff BOOL IsCamelotEPS = IS_A(this, CamelotEPSRenderRegion); // If mask coverage is 0% we do not need to do anything. The TRUE param indicates // that we don't care about exact coverage, which makes it return as soon as it realises // that there are pixel(s) that we'll have to plot if (pMask->FindCoverage(TRUE) == 0) return SLOWJOB_SUCCESS; // Guess we will need to be doing something... if (pBitmap->ActualBitmap == NULL) return SLOWJOB_FAILURE; // Get the 'Actual' windows Bitmap CWxBitmap *WinBM = (CWxBitmap*)pBitmap->ActualBitmap; // Is it valid ? if ((WinBM->BMInfo==NULL) || (WinBM->BMBytes==NULL)) return SLOWJOB_FAILURE; // Remember the Size of the Bitmap (in pixels) INT32 Width = WinBM->GetWidth(); INT32 Height = WinBM->GetHeight(); if ((Width == 0) || (Height == 0)) // Error - bitmap has no dimension return SLOWJOB_FAILURE; // Hideous WINOILY code in the kernel. I get the feeling this was a rush job! // Convert the bitmap from a 32bpp bitmap to a 24bpp bitmap INT32 BitmapDepth = WinBM->GetBPP(); if (BitmapDepth == 32) { // Can't plot 32bpp bitmaps to GDI as 16-bit GDI doesn't understand them, // so we convert to 24bpp bitmap in-situ and render that... // How many bytes to a source scanline? const INT32 ScanlineBytes = WinBM->GetScanlineSize(); // How many bytes to a destination scanline const INT32 DestlineBytes = DIBUtil::ScanlineSize(Width, 24); // Now convert the bitmap in-situ LPBYTE OriginalBuffer = WinBM->BMBytes; LPBYTE ConvertedBuffer = WinBM->BMBytes; INT32 i; for (i=0; i<Height; i++) { DIBUtil::Convert32to24(Width, OriginalBuffer, ConvertedBuffer); OriginalBuffer += ScanlineBytes; ConvertedBuffer += DestlineBytes; } // Update bitmap info to show it is now a 24bpp bitmap... WinBM->BMInfo->bmiHeader.biSizeImage = DestlineBytes * Height; WinBM->BMInfo->bmiHeader.biBitCount = 24; BitmapDepth = 24; // Now swap the R and B bytes around as they are in BGR format in DIBS, and // we need RGB format for PostScript. OriginalBuffer = WinBM->BMBytes; for (i=0; i<Height; i++) { ConvertedBuffer = OriginalBuffer; for (INT32 j=0; j<Width; j++) { // Swap R and B bytes around BYTE Temp = ConvertedBuffer[0]; ConvertedBuffer[0] = ConvertedBuffer[2]; ConvertedBuffer[2] = Temp; ConvertedBuffer += 3; } OriginalBuffer += DestlineBytes; } } // make sure we have a 24bpp bitmap ERROR3IF(BitmapDepth!=24, _T("Non 24bpp bitmap found in DrawMaskedBitmap")); // Work out the coords to blit to, taking into acount the differnt dpis of the // source and destination bitmaps. INT32 SrcDpi = pMask->FindMaskDpi(); INT32 DestDpi = SrcDpi; BOOL UseLevel2 = FALSE; if (IsCamelotEPS) { // EPS is output in points, so it's always 72dpi. DestDpi = 72000; // Find out if we should do level 2 output. if (EPSFilter::XSEPSExportPSType == 2) UseLevel2 = TRUE; } else { // Find destination device resolution (e.g. PostScript printer) if (RenderDC!=NULL) DestDpi = RenderDC->GetPPI().GetWidth(); // WEBSTER-ranbirr-12/11/96 #ifndef WEBSTER // If printing, then see if we should do level 2. if (IsPrinting()) { // Get the print info for this job. CCPrintInfo *pInfo = CCPrintInfo::GetCurrent(); if (pInfo != NULL) { PrintControl *pPrCtrl = pInfo->GetPrintControl(); ERROR3IF(pPrCtrl == NULL, _T("Unexpected NULL pointer")); if (pPrCtrl->GetPSLevel() == PSLEVEL_2) // Printing to a level 2 device - party on! UseLevel2 = TRUE; } } #endif //webster } // Work out the ratio between to two double Ratio = DestDpi; Ratio = Ratio/SrcDpi; TRACEUSER( "Rik", _T("Src = %ld, Dest = %ld, Ratio = %f\n"), SrcDpi, DestDpi, Ratio); // Convert the DocCoord into a windows coord DocRect ClipRect = pMask->GetClipRect(); POINT Origin; if (IsCamelotEPS) { // No GDI conversion needed for EPS - we need to convert to points later on. Origin.x = ClipRect.lo.x; Origin.y = ClipRect.lo.y; } else { // Usual GDI conversion (used for PostScript printers) WinRect WinClipRect = OSRenderRegion::DocRectToWin(RenderMatrix, ClipRect, DestDpi); Origin.x = WinClipRect.GetLeft(); Origin.y = WinClipRect.GetBottom(); } // Inform progress object how high this band is if (Progress!=NULL) Progress->StartBitmapPhaseBand(Height); // We need to create a tempory bitmap that we use to render each scan line LPBITMAPINFO TempBitmapInfo = NULL; LPBYTE TempBitmapBytes = NULL; // Get some memory for a tempory bmp 1 pixel high TempBitmapInfo = AllocDIB(Width, 1, BitmapDepth, &TempBitmapBytes); if (TempBitmapInfo==NULL) return SLOWJOB_FAILURE; // Get a buffer for RGB channel separation (for level 2) and colour separation BYTE *pRGBBuf = (BYTE *) CCMalloc(Width); ERROR2IF(pRGBBuf == NULL, SLOWJOB_FAILURE, _T("No memory for RGB buffer")); // How many bytes to a destination scanline INT32 ScanLineBytes = DIBUtil::ScanlineSize(Width, BitmapDepth); INT32 BytesPerPixel = 3; // Now convert the bitmap in-situ LPBYTE SrcBuffer = WinBM->BMBytes; LPBYTE DestBuffer = TempBitmapBytes; // If we're colour separating, make sure we've got some sep tables to work with. // We cache them once we've used them. I would do this sort of set-up in StartRender // but of course all the derived classes just override that behaviour and we're stuffed if (SepTables == NULL && RenderView->GetColourPlate() != NULL && !RenderView->GetColourPlate()->IsDisabled()) { // We are doing a colour separation - find the sep tables ColourContextCMYK *cc = (ColourContextCMYK *)RenderView->GetColourContext(COLOURMODEL_CMYK); if (cc != NULL) { SepTables = (BYTE *) CCMalloc(5 * 256 * sizeof(BYTE)); if (SepTables != NULL) { if (!cc->GetProfileTables(SepTables)) { CCFree(SepTables); SepTables = NULL; } } } ERROR3IF(SepTables == NULL, _T("Can't generate separation tables in CamelotEPSRenderRegion")); } // Now copy the Bits from our Kernel Bitmap into the Memory DC, scan line at a time MaskRegion MaskInfo; pMask->GetFirstMaskRegion(&MaskInfo); try { while (MaskInfo.Length!=0) { // Calculate the source buffer address from the x and y position SrcBuffer = WinBM->BMBytes; SrcBuffer += ScanLineBytes * MaskInfo.y; SrcBuffer += MaskInfo.x*BytesPerPixel; INT32 RegionWidth = MaskInfo.Length; // Update bitmap info to show the new scan line size TempBitmapInfo->bmiHeader.biWidth = RegionWidth; TempBitmapInfo->bmiHeader.biSizeImage = (RegionWidth*BytesPerPixel); // copy the scan line into the temporary bmp if (SepTables == NULL) { // We are not colour separating, so just do a quick memcpy memcpy(DestBuffer, SrcBuffer, RegionWidth*BytesPerPixel); } else { // We are doing some sort of colour separation, so copy the data across, colour // separating it as we go ERROR3IF(BytesPerPixel != 3, _T("non-24bpp scanline unsupported")); ColourSeparateScanline24(DestBuffer, SrcBuffer, RegionWidth); } // Work out the coords of the destination rectangle INT32 DestX = Origin.x + INT32(ceil(MaskInfo.x*Ratio)); INT32 DestY = Origin.y; // Y direction is different for our EPS and GDI PostScript, as GDI preserves // the Y +ve <=> downwards model of windows. if (IsCamelotEPS) DestY += INT32(ceil((MaskInfo.y+1)*Ratio)); else DestY -= INT32(ceil((MaskInfo.y+1)*Ratio)); INT32 DestWidth = INT32(ceil(RegionWidth*Ratio)); INT32 DestHeight = INT32(ceil(1*Ratio)); pDC->OutputToken(_T("sv")); pDC->OutputValue(RegionWidth); pDC->OutputToken(_T("1")); if (IsCamelotEPS) { // Convert to points. pDC->OutputUserSpaceValue(DestWidth); pDC->OutputUserSpaceValue(DestHeight); DocCoord Dest(DestX, DestY); pDC->OutputCoord(Dest); } else { // Pass straight through pDC->OutputValue(DestWidth); pDC->OutputValue(DestHeight); pDC->OutputValue(DestX); pDC->OutputValue(DestY); } // Tell the proc whether this is L1 or L2 compatible data if (UseLevel2) pDC->OutputToken(_T("2")); else pDC->OutputToken(_T("1")); // Rendering primitive. if (SepTables == NULL) pDC->OutputToken(_T("cbsl")); // 24-bpp colour scanline else pDC->OutputToken(_T("gbsl")); // 8-bpp greyscale scanline // Output bitmap data - format depends on whether we can do Level 2 or not if (UseLevel2) { // Separate into 3 RGB streams (because it is much more likely to compress well // with RLE if we compress each component individually), and send as RLE // compressed ASCII85 data. // If we're colour separating, then it's greyscale (R=G=B) data, so we just dump // only the first channel to the gbsl operator const INT32 NumStreams = (SepTables == NULL) ? 3 : 1; for (INT32 i = 0; i < NumStreams; i++) { ERROR3IF(RegionWidth > Width, _T("I didn't allocate enough memory!")); // Copy this component into the buffer for (INT32 j = 0; j < RegionWidth; j++) { pRGBBuf[j] = TempBitmapBytes[(j * 3) + i]; } // We are going to do ASCII85, so get ready for it. if (!pDC->StartASCII85Output(TRUE)) // TRUE => RLE please // Error return SLOWJOB_FAILURE; // Send to output stream as RLE encoded ASCII85 data. /*INT32 nBytes =*/ pDC->OutputASCII85(pRGBBuf, RegionWidth); if (!pDC->EndASCII85Output()) // Error return SLOWJOB_FAILURE; } } else { // Just output as L1 ASCIIHex encoded data if (SepTables != NULL) { // Colour separating, so reduce the 24-bit (R=G=B) greyscale to 8bpp by getting the _T("red") channel for (INT32 j = 0; j < RegionWidth; j++) pRGBBuf[j] = TempBitmapBytes[j * 3]; pDC->OutputRawBinary(pRGBBuf, RegionWidth, 1); } else { // Normal 24bpp colour output pDC->OutputRawBinary(TempBitmapBytes, RegionWidth * 3, 1); } } pDC->OutputToken(_T("rs")); pDC->OutputNewLine(); // Update the progress display if necessary. if ((Progress!=NULL) && (!Progress->BitmapPhaseBandRenderedTo(MaskInfo.y))) { // Free up the tempory DIB I made FreeDIB(TempBitmapInfo, TempBitmapBytes); return SLOWJOB_USERABORT; } // Find the next bit of scan line to plot pMask->GetNextMaskRegion(&MaskInfo); } } catch(CFileException) { FreeDIB(TempBitmapInfo, TempBitmapBytes); if (UseLevel2) CCFree(pRGBBuf); return SLOWJOB_FAILURE; } // Update bitmap info to what it was before we started TempBitmapInfo->bmiHeader.biSizeImage = (Width*3); TempBitmapInfo->bmiHeader.biWidth = Width; // Free up the tempory DIB I made FreeDIB(TempBitmapInfo, TempBitmapBytes); // Free up the buffer used for separating RGB components CCFree(pRGBBuf); #endif // All ok return SLOWJOB_SUCCESS; }

BOOL CamelotEPSRenderRegion::DrawParallelogramBitmap (  DocCoord *  Coords, OILBitmap *  pBitmap, EFFECTTYPE  Effect = EFFECT_RGB, DocColour *  StartCol = NULL, DocColour *  EndCol = NULL )  [virtual]

Plot an arbitrarily transformed bitmap in the position specified. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/95 Parameters: Coords  - the parallelogram to plot the bitmap into (should be an array of [INPUTS] 4 co-ordinates) pBitmap - the bitmap to render! Effect - if contone colours are supplied, this is how the colours should fade. StartCol, EndCol - optional colours, if non-NULL, this indicates that the bitmap is a contoned bitmap and should be rendered using these colours. Returns: TRUE if the bitmap could be rendered as specified; FALSE if it could not be (and hence wasn't). For a normal untransformed rectangle, the Coords array should start specify the parallelogram as follows: Coords[0] Coords[1] +---------------+ | | | | | | | | +---------------+ Coords[3] Coords[2] See also: NodeBitmap::Render; CamelotEPSRenderRegion::DrawTransformedBitmap Definition at line 5165 of file cameleps.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return TRUE; // If it's contoned between two no-colours, it is invisible (on this plate) so don't render anything if (StartCol != NULL && StartCol->IsTransparent() && EndCol != NULL && EndCol->IsTransparent()) return(TRUE); // Get information about the bitmap to be rendered. BitmapInfo BMInfo; if (!pBitmap->GetInfo(&BMInfo)) { ERROR3("Bitmap GetInfo failed"); // Error getting bitmap info return FALSE; } // Remember the Size of the Bitmap (in pixels) INT32 Width = BMInfo.PixelWidth; INT32 Height = BMInfo.PixelHeight; if ((Width == 0) || (Height == 0)) { // Error - bitmap has no dimension ERROR3("Bitmap width/height is 0"); return FALSE; } // Find out if this is real renderable EPS. BOOL IsCamelotEPS = IS_A(this, CamelotEPSRenderRegion); // Is it contoned? BOOL IsContoned = (StartCol != NULL) && (EndCol != NULL); if (IsContoned) { if (pBitmap->GetGreyscaleVersion() != NULL) { pBitmap = pBitmap->GetGreyscaleVersion(); if (!pBitmap->GetInfo(&BMInfo)) { ERROR3("Bitmap GetInfo failed"); // Error getting bitmap info return FALSE; } } } // Find out if we can use Level 2 features. BOOL UseLevel2 = FALSE; if (IsCamelotEPS) { // Use the EPS preference. if (EPSFilter::XSEPSExportPSType == 2) UseLevel2 = TRUE; } // WEBSTER-ranbirr-12/11/96 #ifndef WEBSTER else if (IsPrinting()) { #ifndef STANDALONE // Get the print info for this job. CCPrintInfo *pInfo = CCPrintInfo::GetCurrent(); if (pInfo != NULL) { PrintControl *pPrCtrl = pInfo->GetPrintControl(); if (pPrCtrl->GetPSLevel() == PSLEVEL_2) // Printing to a level 2 device - party on! UseLevel2 = TRUE; } #else ERROR2(FALSE,"CamelotEPSRenderRegion::DrawParallelogramBitmap trying to print in Viewer version!") #endif } #endif //webster // Work out the coords of the destination rectangle // INT32 DestX = 0; // INT32 DestY = 0; KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); pDC->OutputToken(_T("sv")); // Dimensions of bitmap pDC->OutputValue(Width); pDC->OutputValue(Height); // Number of bits per component sample INT32 BytesPerScanline; // Are we colour separating? Get SepTables if we need them // NOTE that we get them even if we have a <= 8bpp bitmap, as the pointer is also used // as a "we are separating" flag. Note also that we don't try to separate contoned bitmaps // via the normal system- we just let the old contone bitmap code output it, and separate the palette if (!IsContoned && SepTables == NULL && RenderView->GetColourPlate() != NULL) { ColourContextCMYK *cc = (ColourContextCMYK *)RenderView->GetColourContext(COLOURMODEL_CMYK); if (cc != NULL) { SepTables = (BYTE *) CCMalloc(5 * 256 * sizeof(BYTE)); if (SepTables != NULL) { if (!cc->GetProfileTables(SepTables)) { CCFree(SepTables); SepTables = NULL; } } } ERROR3IF(SepTables == NULL, "Can't generate separation tables in CamelotEPSRenderRegion"); } if (SepTables != NULL && !IsContoned) { // ALL colour separated bitmaps go out as simple 8bpp greyscales (yay! no special cases!) pDC->OutputValue((INT32)8); BytesPerScanline = Width; } else { // It's not colour separated, so output the right values for the bitmap's BPP. switch (BMInfo.PixelDepth) { case 1: case 8: pDC->OutputValue((INT32) BMInfo.PixelDepth); BytesPerScanline = ((BMInfo.PixelDepth * Width) + 7) / 8; // Round 1bpp up to multiple of bytes break; case 4: // 4bpp images get converted to 8bpp because Adobe SDK image library can't // do 4bpp on some PS printers (e.g. Canon LBP4-PS). pDC->OutputValue((INT32) 8); BytesPerScanline = Width; break; case 24: case 32: // 32bpp images are output as 24bpp to postscript // Output will be standard 24bpp pDC->OutputValue((INT32) 24); BytesPerScanline = 3 * Width; break; default: // Unknown bitmap depth ERROR3("Unsupported bitmap depth in CamelotEPSRenderRegion::DrawParallelogramBitmap"); return FALSE; } } // Now, output how many bytes per scanline will be used. pDC->OutputValue(BytesPerScanline); // Now output the matrix - colorimage expects the inverse of this matrix, i.e. // it needs the matrix which maps the destination area to the 1-1 rectangle at // the origin (cos PostScript is weird like that). pDC->OutputToken(_T("[")); // NB. We have to do some 'bespoke' matrix maths here, because we need to work // in points, and our Matrix class is not accurate enough (notably the e and // f components are integer only, and we need fractional points). double a[2],b[2],c[2],d[2], e[2], f[2]; // Find out the size of one unit, in MILLIPOINTS. double UnitSize; if (IsCamelotEPS) { // Unit is 1000 millipoints, as we always use 1 point as unit in user space // in Camelot EPS. UnitSize = 1000; } else { // Find the size of a pixel, because Windows maps a unit to a pixel. FIXED16 fxPixelSize; RenderView->GetPixelSize(&fxPixelSize, &fxPixelSize); UnitSize = fxPixelSize.MakeDouble(); } // Work out the width and height of the bitmap, assuming each pixel corresponds to // one unit. double dWidth = (double) Width; double dHeight = (double) Height; DocCoord DCOrigin = pDC->GetOrigin(); if (IsCamelotEPS) { dWidth *= UnitSize; dHeight *= UnitSize; a[0] = ((double) (Coords[2].x - Coords[3].x)) / dWidth; b[0] = ((double) (Coords[2].y - Coords[3].y)) / dWidth; c[0] = ((double) (Coords[0].x - Coords[3].x)) / dHeight; d[0] = ((double) (Coords[0].y - Coords[3].y)) / dHeight; e[0] = ((double) (Coords[3].x - DCOrigin.x)) / UnitSize; f[0] = ((double) (Coords[3].y - DCOrigin.y)) / UnitSize; } else { ERROR3IF(!pDC->IsKindOf(CC_RUNTIME_CLASS(PSPrintDC)), "KernelDC is not a PSPrintDC - how did that happen?"); // Printing to PostScript - convert to Window co-ordinates, using the DC. PSPrintDC *pPSDC = (PSPrintDC *) pDC; WinCoord PSCoords[3]; for (INT32 i = 0; i <= 3; i++) PSCoords[i] = pPSDC->TransformCoord(Coords[i]); a[0] = ((double) (PSCoords[2].x - PSCoords[3].x)) / dWidth; b[0] = ((double) (PSCoords[2].y - PSCoords[3].y)) / dWidth; c[0] = ((double) (PSCoords[0].x - PSCoords[3].x)) / dHeight; d[0] = ((double) (PSCoords[0].y - PSCoords[3].y)) / dHeight; e[0] = (double) PSCoords[3].x; f[0] = (double) PSCoords[3].y; } // Calculate the inverse of the above. double Det = a[0] * d[0] - b[0] * c[0]; if (Det==0.0) { // There is no inversion of this matrix // return the identity matrix ERROR3("Matrix Inversion Failed - Tried to Invert a non-invertable matrix" ); return FALSE; } // this section calculates the inverse of the matrix. As it takes into // account that our 3x3 matrix always has 0,0,1 down its right hand side // it has been greatly simplified. The operations combine the calculation // of the adjoint matrix and scaling it by the Determinent with a matrix // transpose (the inverse is the transpose of the adjoint scaled by the // determinent) a[1] = d[0] / Det; b[1] = -b[0] / Det; c[1] = -c[0] / Det; d[1] = a[0] / Det; e[1] = ((c[0] * f[0]) - (e[0] * d[0])) / Det ; f[1] = -(((a[0] * f[0]) - (e[0] * b[0])) / Det); pDC->OutputReal(a[1]); pDC->OutputReal(b[1]); pDC->OutputReal(c[1]); pDC->OutputReal(d[1]); if (IsCamelotEPS) { // Convert to points. pDC->OutputUserSpaceValue((MILLIPOINT) (e[1] * 1000.0)); pDC->OutputUserSpaceValue((MILLIPOINT) (f[1] * 1000.0)); } else { // Pass straight through pDC->OutputReal(e[1]); pDC->OutputReal(f[1]); } pDC->OutputToken(_T("]")); // Default values for smoothing and polarity pDC->OutputToken(_T("false")); pDC->OutputToken(_T("false")); // Normally we use ASCII Hex encoding, but for Level 2 specific output, we use ASCII85. if (UseLevel2) // Run length encoded and ASCII85 encoded pDC->OutputToken(_T("3")); else // Simple level 1 compatible ASCII Hex encoding. pDC->OutputToken(_T("1")); // Set up the image procs pDC->OutputToken(_T("beginimage")); if (SepTables != NULL && !IsContoned) { // If we are colour-separating, then output always goes out as an 8bpp greyscale image // This may seem like a gross thing to do (especially for 1/4bpp), but as 4bpp is always // expanded to 8bpp anyway, it is much better to treat all images in a nice generic manner // and save ourselves lots of work, lots of confusion, and the potential for lots of // special cases which don't work (for examples of code like this, see the old composite // printing code below). if (!pBitmap->ExportSeparatedPalette(this)) { ERROR3("ExportSeparatedPalette failed"); return FALSE; } pDC->OutputToken(_T("doclutimage")); // Colour separation to 8bpp greyscale image pDC->OutputNewLine(); // Output bitmap (scanline) data as an 8bpp greyscale if (!pBitmap->ExportSeparatedData(this, SepTables)) { ERROR3("ExportSeparatedData failed"); return FALSE; } } else { // We've specified the size, depth and position of the bitmap, so now we work // out which PostScript procedure we should render the image with. switch (BMInfo.PixelDepth) { case 1: // It's a 1bpp image - should we output a palette with it? if (IsContoned) { // (Jason here: I believe the postscript routine 1bitcopyimage doesn't work. // This is probably OK, as I think all contoned bitmaps in camelot are made 8bpp. // I've left this code in place, however, just in case it would break something) // Convert colours to RGB and output for use with the special // 1bpp contone operator. Document *pDoc = RenderView->GetDoc(); if (pDoc == NULL) { ERROR3("No document when rendering"); // Panic! return FALSE; } // Use the output context to convert the colours, and then output them... ColourContext *pContext = CurrentColContext; if (pContext == NULL) { ERROR3("No Colour context when rendering"); return(FALSE); // Panic! } ERROR3IF(pContext->GetColourModel() != COLOURMODEL_RGBT, "RGB output context expected in EPS rendering"); ColourRGBT Result; if (IsContoned) pContext->ConvertColour((DocColour *) StartCol, (ColourGeneric *)&Result); else { DocColour Black(0L, 0L, 0L); pContext->ConvertColour(&Black, (ColourGeneric *)&Result); } pDC->OutputReal(Result.Red.MakeDouble()); pDC->OutputReal(Result.Green.MakeDouble()); pDC->OutputReal(Result.Blue.MakeDouble()); if (IsContoned) pContext->ConvertColour((DocColour *) EndCol, (ColourGeneric *)&Result); else { DocColour White(255L, 255L, 255L); pContext->ConvertColour(&White, (ColourGeneric *)&Result); } pDC->OutputReal(Result.Red.MakeDouble()); pDC->OutputReal(Result.Green.MakeDouble()); pDC->OutputReal(Result.Blue.MakeDouble()); // Use special colour 1bpp operator pDC->OutputToken(_T("1bitcopyimage")); } else { // Normal black and white image pDC->OutputToken(_T("1bitbwcopyimage")); } break; case 4: case 8: if (IsContoned) { // Contoned bitmap - generate and output the contone palette. if (!pBitmap->BuildContonePalette(*StartCol, *EndCol, Effect, RenderView)) { ERROR3("Contoned palette failed"); // Error while building palette (out of memory?) return FALSE; } BOOL Success = pBitmap->ExportContonePalette(this); // Clean up contone palette pBitmap->DestroyContonePalette(); // Did it work? if (!Success) { ERROR3("Contoned palette export failed"); return FALSE; } // Use the procedure for rendering paletted images. pDC->OutputToken(_T("doclutimage")); } else if (BMInfo.NumPaletteEntries > 0) { // It's a paletted image - export the palette if (!pBitmap->ExportBitmapPalette(this)) { ERROR3("ExportBitmapPalette failed"); return FALSE; } // Use the procedure for rendering paletted images. pDC->OutputToken(_T("doclutimage")); } else { // It's a greyscale image - use the image operator. // (Jason here: I reckon the postscript for doimage doesn't work. This is // probably OK, because camelot can't theoretically have a non-paletted image?) pDC->OutputToken(_T("doimage")); } break; case 24: case 32: // 32bpp is output as 24bpp data pDC->OutputToken(_T("do24image")); // Normal composite colour 24bpp image break; default: // Unknown bitmap depth ERROR3("Unsupported bitmap depth"); return FALSE; } pDC->OutputNewLine(); // Output bitmap (scanline) data if (!pBitmap->ExportBitmapData(this)) { ERROR3("ExportBitmapData failed"); return FALSE; } } // Clean up image stuff pDC->OutputNewLine(); pDC->OutputToken(_T("endimage")); pDC->OutputToken(_T("rs")); pDC->OutputNewLine(); return TRUE; }

void CamelotEPSRenderRegion::DrawPathToOutputDevice (  Path *  DrawPath, PathShape  shapePath = PATHSHAPE_PATH )  [virtual]

Output all the commands required to render this path to the EPS file. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/03/94 Parameters: DrawPath  - the path to render. [INPUTS] See also: RenderRegion::DrawPath; EPSRenderRegion::GetValidPathAttributes EPSRenderRegion::ExportPath Reimplemented from EPSRenderRegion. Definition at line 5634 of file cameleps.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return; // Work out if we need to be renderable. BOOL Renderable = (IS_A(this, CamelotEPSRenderRegion) || IsPrinting()); if (Renderable) { // Check for clipped (non-repeating) bitmaps... // Get the current fill attr ColourFillAttribute* pFillAttr = (ColourFillAttribute*) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; // See if it is a simple non-repeating bitmap fill... if (pFillAttr->IS_KIND_OF(BitmapFillAttribute)) { FillMappingAttribute* pMapAttr = (FillMappingAttribute*) CurrentAttrs[ATTR_FILLMAPPING].pAttr; if (pMapAttr->Repeat == 1) { // Simple non-repeating clipped bitmap - we can do this! DrawClippedBitmap(DrawPath); return; } } } ExportPath(DrawPath, FALSE); // Now do the arrow heads if the render region can't do them directly if (!Caps.ArrowHeads) { // Doesn't support arrow heads directly so we render them as paths. DrawPathArrowHeads(DrawPath->GetCoordArray(), DrawPath->GetVerbArray(), DrawPath->GetNumCoords()); } }

BOOL CamelotEPSRenderRegion::DrawTransformedBitmap (  NodeBitmap *  pNodeBitmap  )  [virtual]

Plot an arbitrarily transformed bitmap using a matrix and an offset. The bitmap is assumed to occupy a rectangle at the origin, which has pixels 1 point across, and the matrix supplied transforms this area to the correct place. The Point parameter supplies an optional offset which can be applied after the transform. If the offset is 0,0, this means there is no offset (surprise, surprise!). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/95 Parameters: pNodeBitmap  - the bitmap node to render! [INPUTS] Returns: TRUE if the bitmap could be rendered as specified; FALSE if it could not be (and hence wasn't). See also: NodeBitmap::Render Reimplemented from RenderRegion. Definition at line 5098 of file cameleps.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return TRUE; if ((!RenderComplexShapes) && (pNodeBitmap->NeedsTransparency())) return TRUE; DocCoord *Coords = pNodeBitmap->InkPath.GetCoordArray(); // Get the 'actual' OIL Bitmap OILBitmap *TheBitmap = pNodeBitmap->GetBitmap()->ActualBitmap; // Is it contoned? DocColour *StartCol = NULL, *EndCol = NULL; if (!RR_STROKECOLOUR().IsTransparent()) { // It has a line colour, so it is contoned! StartCol = &(RR_STROKECOLOUR()); EndCol = &(RR_FILLCOLOUR()); } // Render it return DrawParallelogramBitmap(Coords, TheBitmap, GetFillEffect(), StartCol, EndCol); }

BOOL CamelotEPSRenderRegion::GetCurrFillEffect (  UINT32 &  EffectType  )  [protected]

Return the state of the current fill effect in the EPS attributes stack. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 24/06/96 Parameters: -  [INPUTS] The  current type of fill effect [OUTPUTS] Returns: TRUE if a fill effect exists in the current attrs stack FALSE if not Definition at line 3844 of file cameleps.cpp. { // set default EffectType = FILLEFFECT_FADE; FillEffectAttribute *pFillAttr = (FillEffectAttribute *) CurrentAttrs[ATTR_FILLEFFECT].pAttr; if (pFillAttr==NULL) return FALSE; if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(FillEffectFadeAttribute))) { EffectType = FILLEFFECT_FADE; } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(FillEffectRainbowAttribute))) { EffectType = FILLEFFECT_RAINBOW; } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(FillEffectAltRainbowAttribute))) { EffectType = FILLEFFECT_ALTRAINBOW; } else { ERROR3("Illegal fill effect type!"); } return TRUE; }

void CamelotEPSRenderRegion::GetRenderRegionCaps (  RRCaps *  pCaps  )  [virtual]

This function allows render regions to admit to what they can and can not render. This allows other areas of the program to come in and help render regions out in some situations, if they are unable to render everything. eg. an OSRenderRegion can not render transparancy. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/4/95 Parameters: pCaps  - The details about what types of thing this render region can render [OUTPUTS] Reimplemented from EPSRenderRegion. Reimplemented in NativeRenderRegion. Definition at line 3311 of file cameleps.cpp. { // We can do grad fills, and most kinds of bitmaps. pCaps->CanDoNothing(); pCaps->GradFills = TRUE; pCaps->SimpleBitmaps = TRUE; pCaps->ArbitraryBitmaps = TRUE; pCaps->ClippedSimpleBitmaps = TRUE; pCaps->ClippedArbitraryBitmaps = TRUE; pCaps->ClippedOutput = TRUE; }

void CamelotEPSRenderRegion::GetValidPathAttributes (   )  [virtual]

See EPSRenderRegion::GetValidPathAttributes. This version checks and handles grad fill colours before calling the base class version. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/03/94 See also: EPSRenderRegion::GetValidPathAttributes Reimplemented from ArtWorksEPSRenderRegion. Reimplemented in NativeRenderRegion. Definition at line 3336 of file cameleps.cpp. { KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); FillGeometryAttribute *pFillAttr = (FillGeometryAttribute *) CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(GradFillAttribute)) && SetLastOutputAttribute(ATTR_FILLGEOMETRY)) { // If the fill is square if (!pFillAttr->IsASquareFill() && !pFillAttr->IsAThreeColFill()) { // Get the correct brush - may be a grad fill. if (//pFillAttr->IsKindOf(CC_RUNTIME_CLASS(GradFillAttribute)) && !pFillAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapFillAttribute)) ) { // Output a grad fill command... // Get the start colour and end colour in CMYK, and output them. GradFillAttribute *pGradFillAttr = (GradFillAttribute *) pFillAttr; // Check if the colours are named or not. BOOL UnnamedColours = FALSE; BOOL GreyFill = FALSE; // During a normal CamEPS export we will not be separating, hence // pSeparation will always return NULL here. If however we are // currently printing we need to perform some giggery pokery with // grad fills in order to separate them correctly. // We have two fill operators we can use in Postscript, these // are cax, a colour fill op and cag a grey fill op. // There are three items of interest to us which we need to consider // before choosing to use one of the postscript fill operators, these // are // (1) the end colours of the fill (the model etc) // (2) the fill effect across the grad fill // (3) the output plate we're rendering to. // // We need to work out what happens on both cmyk and spot plates when // using one of these operators. For instance when using a grey fill // operator, the fill effect will not be used. It may go out in the // output stream, but it will be ignored in Postscript (because you // are using a grey fill of course!). // You also need to consider that if you use the colour fill operator // you are in effect restricting output to the process colour plates. // Nothing will appear on spot plates. The colour operator works by // performing a separation itself, using the current fill effect and // wandering about in rgb space. // You also need to know the rules for interaction between mixed colours // during a separation, ie if we have a rgb colour to spot colour fill // with a rainbow fill effect, question which should immediately leap/ // to mind are // (1) do we use the fill effect // (2) what fill is used on the spot plate // (3) what fill is used on the process plates // (4) how will this all look, is it sensible? // We should really define a virtual function for this operation and // override it in PrintPSRenderRegion. ColourContext* pContext; ColourPlate* pSeparation; GetOutputColourPlate(COLOURMODEL_CMYK, &pContext, &pSeparation); if (pSeparation!=NULL) { DocColour *Start, *End; Start = &(pGradFillAttr->Colour); End = &(pGradFillAttr->EndColour); BOOL StartIsSpot = (Start->GetSpotParent() != NULL); BOOL EndIsSpot = (End->GetSpotParent() != NULL); // If we are rendering a spot plate GreyFill = (pSeparation->GetType() == COLOURPLATE_SPOT); // or either end of this fill are spot... use the gray fill operator // This will mean process colour will be separated and provide a linear // fill to white on none spot plates. GreyFill = (GreyFill || StartIsSpot || EndIsSpot); if (!GreyFill) { // ok we're on a process plate, and both ends are not spot // are both ends CMYK colours with a simple fill effect? GreyFill = ( Start->GetColourModel() == COLOURMODEL_CMYK ) && ( End->GetColourModel() == COLOURMODEL_CMYK ); if (GreyFill) { // Is there a crazy fill effect pending? UINT32 filleffect; BOOL exists = GetCurrFillEffect(filleffect); GreyFill = (!exists || filleffect == FILLEFFECT_FADE); } } } // if GreyFill is true we output this fill as a single plate gray fill // otherwise we splunge it across the process plates. if (GreyFill) { UnnamedColours = TRUE; // both of these colours are cmyk so we need to handle the separation // slightly differently. The user will expect these colours to spread // without going through rgb=>devcmyk to do so. PColourCMYK sCMYK, eCMYK; pGradFillAttr->Colour.GetCMYKValue(pContext, &sCMYK); pGradFillAttr->EndColour.GetCMYKValue(pContext, &eCMYK); // Sanity check on this plate ERROR3IF( (sCMYK.Cyan!=0 || sCMYK.Magenta!=0 || sCMYK.Yellow!=0 || eCMYK.Cyan!=0 || eCMYK.Magenta!=0 || eCMYK.Yellow!=0) , "Not a mono plate during export of CMYK gradfills (CAMEPSRndRgn::GetValidPathAttributes())" ); // output a linear key fill. BOOL ok = pDC->OutputColourValue(255 - sCMYK.Key); ok = ok && pDC->OutputColourValue(255 - eCMYK.Key); // This entire function seems to ignore disc failure which is a bit rampant! ERROR3IF(!ok, "Disc buffer failure during gradfill output in GetValidPathAttributes"); } else { // This is a mixture of colour spaces so simply output the // who lot as normal. Postscript will spread the colour UnnamedColours = OutputGradFillColours( &(pGradFillAttr->Colour), &(pGradFillAttr->EndColour) ); } // Output the start and end points of the grad fill pDC->OutputCoord(pGradFillAttr->StartPoint); pDC->OutputCoord(pGradFillAttr->EndPoint); // Output the fill type if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(LinearFillAttribute))) { LinearFillAttribute *pLinearFillAttr = (LinearFillAttribute *) pFillAttr; DocCoord* Start = pFillAttr->GetStartPoint(); DocCoord* End = pFillAttr->GetEndPoint(); DocCoord* End2 = pFillAttr->GetEndPoint2(); if (AreLinesPerpendicular(Start, End, End2)) { TRACEUSER( "Will", _T("Exporting Simple Linear Fill\n")); pDC->OutputValue((INT32) CAMEPS_FILL_LINEAR); } else { TRACEUSER( "Will", _T("Exporting New Style Linear Fill\n")); pDC->OutputCoord(pLinearFillAttr->EndPoint2); pDC->OutputValue((INT32) CAMEPS_FILL_NEWLINEAR); } } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(RadialFillAttribute))) { // Is it circular or elliptical? RadialFillAttribute *pRadialFillAttr = (RadialFillAttribute *) pFillAttr; if (pRadialFillAttr->IsElliptical()) { // Elliptical fill - output the second end point. pDC->OutputCoord(pRadialFillAttr->EndPoint2); pDC->OutputValue((INT32) CAMEPS_FILL_ELLIPTICAL); } else { // Circular fill pDC->OutputValue((INT32) CAMEPS_FILL_CIRCULAR); } } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(ConicalFillAttribute))) { pDC->OutputValue((INT32) CAMEPS_FILL_CONICAL); } else { // Bodge: ought to handle this more gracefully soon... ENSURE(FALSE, "Unsupported grad fill encountered while exporting"); EPSRenderRegion::GetValidPathAttributes(); return; } // Output the grad fill token if (UnnamedColours) { if (GreyFill) pDC->OutputToken(_T("cag")); else pDC->OutputToken(_T("caz")); } else { pDC->OutputToken(_T("cax")); } pDC->OutputNewLine(); } else if ( // Utterly awful code by WillC (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(FractalFillAttribute)) || pFillAttr->IsKindOf(CC_RUNTIME_CLASS(NoiseFillAttribute))) && Caps.BitmapFills ) { // Fractal fill - output fractal fill command... //************************************************************************* // this piece of code is copied from the bitmap export but differs // only very slightly. Is this difference a bug or intended? We will never // know. // first output the base class fill stuff... BitmapFillAttribute *pFill = (BitmapFillAttribute *) pFillAttr; // Get the start colour and end colour in CMYK, and output them. // Check if the colours are named or not. BOOL UnnamedColours = FALSE; ColourContext *cc = NULL; // (ChrisG 8/12/00) All non-grey grad fill colours are now exported by the // OutputGradFillColours function. if ((pFill->Colour.FindParentIndexedColour() == NULL) && (pFill->EndColour.FindParentIndexedColour() == NULL)) { // Neither colour is named...use unnamed colour syntax. cc = ColourManager::GetColourContext(COLOURMODEL_CMYK, GetRenderView()); ERROR3IF(cc == NULL, "No CMYK colour context - somethings' seriously broken"); } else { cc = NULL; } // Output the colours (and names) UnnamedColours = OutputGradFillColours (&(pFill->Colour), &(pFill->EndColour), cc); // Next the coords of the fill pDC->OutputCoord(pFill->StartPoint); pDC->OutputCoord(pFill->EndPoint); pDC->OutputCoord(pFill->EndPoint2); //************************************************************************* // ok NoiseFillAttributes are saved as FractalFillAttributes. Strange you // might say, aha! but NoiseFillAttributes are new objects not supported by // camelot 1.1 so what else should we do? Hmm not sure at this point. // Save the fractal parameters out. pDC->OutputValue(pFill->GetSeed()); pDC->OutputReal(pFill->GetGraininess().MakeDouble()); pDC->OutputReal(pFill->GetGravity().MakeDouble()); pDC->OutputReal(pFill->GetSquash().MakeDouble()); // And now the DPI of the fractal bitmap UINT32 DPI = pFill->GetFractalDPI(); pDC->OutputValue(DPI); // And now the 'tileable' flag pDC->OutputValue((INT32) (pFill->GetTileable())); // Always Fractal type 1 at present pDC->OutputToken(_T("1")); // This is a fractal fill pDC->OutputValue((INT32) CAMEPS_FILL_FRACTAL); if (UnnamedColours) pDC->OutputToken(_T("caz")); else pDC->OutputToken(_T("cax")); pDC->OutputNewLine(); } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapFillAttribute)) && Caps.BitmapFills) { // Bitmap fill - output bitmap fill command... BitmapFillAttribute *pBitmapFill = (BitmapFillAttribute *) pFillAttr; ERROR3IF(pBitmapFill->GetBitmap() == NULL, "Bitmap fill has no bitmap"); if (pBitmapFill->GetBitmap()) { // Get the start colour and end colour in CMYK, and output them. // Check if the colours are named or not. BOOL UnnamedColours = FALSE; BOOL HasColours = ((pBitmapFill->GetStartColour() != NULL) && (pBitmapFill->GetEndColour() != NULL)); if (HasColours) { // (ChrisG 8/12/00) All non-grey grad fill colours are now exported by the // OutputGradFillColours function. ColourContext *cc = NULL; if ((pBitmapFill->Colour.FindParentIndexedColour() == NULL) && (pBitmapFill->EndColour.FindParentIndexedColour() == NULL)) { // Neither colour is named...use unnamed colour syntax. cc = ColourManager::GetColourContext(COLOURMODEL_CMYK, GetRenderView()); ERROR3IF(cc == NULL, "No CMYK colour context - somethings' seriously broken"); } else { // One or two of the colours are named, so use the named colour syntax. cc = NULL; } // Write out the colours themselves. UnnamedColours = OutputGradFillColours (&(pBitmapFill->Colour), &(pBitmapFill->EndColour), cc); } pDC->OutputCoord(pBitmapFill->StartPoint); pDC->OutputCoord(pBitmapFill->EndPoint); pDC->OutputCoord(pBitmapFill->EndPoint2); if (HasColours) pDC->OutputValue((INT32) CAMEPS_FILL_NEWBITMAP); else pDC->OutputValue((INT32) CAMEPS_FILL_BITMAP); if (UnnamedColours) pDC->OutputToken(_T("caz")); else pDC->OutputToken(_T("cax")); pDC->OutputNewLine(); // ...and then the bitmap itself. ExportDC *pExportDC = (ExportDC *) pDC; pExportDC->GetParentFilter()->ExportBitmap(*pBitmapFill->GetBitmap()); } } } } if (SetLastOutputAttribute(ATTR_FILLEFFECT)) { UINT32 EffectType; GetCurrFillEffect(EffectType); // Output fill effect pDC->OutputValue(EffectType); // Output the fill effect token pDC->OutputToken(_T("cxe")); pDC->OutputNewLine(); } if (SetLastOutputAttribute(ATTR_FILLMAPPING)) { // Now do the chromatic fill mapping FillMappingAttribute *pFillAttr = (FillMappingAttribute *) CurrentAttrs[ATTR_FILLMAPPING].pAttr; // Get the correct mapping INT32 MappingType = pFillAttr->Repeat; //Mark Howitt, 9/10/97. If we are exporting, make sure that repeating grad fill is saved as simple. #ifdef _DEBUG if(MappingType == 4) MappingType = 2; #endif ERROR3IF((MappingType < 1) || (MappingType > 3), "Illegal fill mapping value!"); // Output fill mapping pDC->OutputValue((UINT32) MappingType); // Allow for future extension of fill mappings. pDC->OutputToken(_T("0")); // Output the fill mapping token pDC->OutputToken(_T("cxm")); pDC->OutputNewLine(); } if (SetLastOutputAttribute(ATTR_WINDINGRULE)) { WindingRuleAttribute *pWindingRuleAttr = (WindingRuleAttribute *) CurrentAttrs[ATTR_WINDINGRULE].pAttr; switch (pWindingRuleAttr->WindingRule) { case NonZeroWinding: // Change winding rule to 0, which means non-zero in Camelot EPS. pDC->OutputToken(_T("0")); pDC->OutputToken(_T("awr")); pDC->OutputNewLine(); break; case EvenOddWinding: // Change winding rule to 1, which means even-odd in Camelot EPS. pDC->OutputToken(_T("1")); pDC->OutputToken(_T("awr")); pDC->OutputNewLine(); break; case NegativeWinding: case PositiveWinding: // Not supported in Camelot EPS - ignore. break; default: ERROR3("Unknown winding rule encountered while exporting."); break; } } // Leave arrows/dash patterns to the base class. // Handle usual pens/brushes EPSRenderRegion::GetValidPathAttributes(); }

BOOL CamelotEPSRenderRegion::NeedsPrintComponents (  void   )  [virtual]

Lets the print component class know that they are needed in this format's export. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/00 Parameters: -  [INPUTS] Returns: TRUE - the print components are needed. Definition at line 4864 of file cameleps.cpp. { // We want print components! return TRUE; }

void CamelotEPSRenderRegion::OutputFillColour (  void   )  [virtual]

This simply calls EPSRenderRegion::OutputFillColour, otherwise this render region uses the overridden version found in ArtWorksEPSRenderRegion. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 8/12/00 Parameters: -  [INPUTS] Returns: - See also: EPSRenderRegion::OutputStrokeColour Reimplemented from ArtWorksEPSRenderRegion. Reimplemented in NativeRenderRegion. Definition at line 5822 of file cameleps.cpp. { EPSRenderRegion::OutputFillColour (); }

BOOL CamelotEPSRenderRegion::OutputGradFillColours (  DocColour *  StartCol, DocColour *  EndCol, ColourContext *  pContext = NULL )  [protected, virtual]

Reimplemented in NativeRenderRegion. Definition at line 3770 of file cameleps.cpp. { KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); bool outputNames = FALSE; if ((StartCol->FindParentIndexedColour() == NULL) && (EndCol->FindParentIndexedColour() == NULL)) { // Neither colour is named...use unnamed colour syntax. outputNames = FALSE; } else { // One or two of the colours are named, so use the named colour syntax. outputNames = TRUE; } // Start writing stuff to the EPS file. INT32 red = 0; INT32 green = 0; INT32 blue = 0; // Write out the start colour StartCol->GetRGBValue (&red, &green, &blue); pDC->OutputColourValue (red); pDC->OutputColourValue (green); pDC->OutputColourValue (blue); if (outputNames) { // Write out the name pDC->OutputColourName (StartCol); // Write out the tint value. This isn't actually used at the moment, but is left // for possible future expansion pDC->OutputValue ((INT32)0); } // And the End colour. EndCol->GetRGBValue (&red, &green, &blue); pDC->OutputColourValue(red); pDC->OutputColourValue(green); pDC->OutputColourValue(blue); if (outputNames) { // Write out the name pDC->OutputColourName (EndCol); // Write out the tint value. This isn't actually used at the moment, but is left // for possible future expansion pDC->OutputValue ((INT32)0); } // Return TRUE for no names used, FALSE for names used. return (!outputNames); }

void CamelotEPSRenderRegion::OutputStrokeColour (   )  [virtual]

This simply calls EPSRenderRegion::OutputStrokeColour, as otherwise the ArtWorks version is used (which can't cope with the RGB colour tokens). Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 8/12/00 Parameters: -  [INPUTS] Returns: - See also: EPSRenderRegion::OutputStrokeColour Reimplemented from ArtWorksEPSRenderRegion. Reimplemented in NativeRenderRegion. Definition at line 5802 of file cameleps.cpp. { EPSRenderRegion::OutputStrokeColour (); }

BOOL CamelotEPSRenderRegion::RenderChar (  WCHAR  ch, Matrix *  pMatrix )  [virtual]

Render a character, using the specified transform and current attributes in the render region. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/95 Parameters: ch  - unicode value of char [INPUTS] pMatrix - matrix specifying transforms to place char correctly in document Returns: FALSE if fails Reimplemented from EPSRenderRegion. Reimplemented in NativeRenderRegion, and PrintPSRenderRegion. Definition at line 4695 of file cameleps.cpp. { #ifndef STANDALONE // Should we render it as curves? (We do for non-ASCII characters) if ((ch > 255) || EPSFilter::XSEPSExportTextAsCurves) return RenderRegion::RenderChar(ch, pMatrix); // Make sure we have the right attributes for rendering as paths. GetValidPathAttributes(); // get overall matrix - attribute matrix concatenated with given matrix if supplied Matrix matrix; if (GetCharAttributeMatrix(&matrix)==FALSE) return FALSE; if (pMatrix) matrix*=*pMatrix; // Can we do this using a GDI font? // We can if the matrix only specifies scaling and translation, with no aspect ratio. FIXED16 abcd[4]; INT32 ef[2]; matrix.GetComponents(abcd, ef); if ((abcd[1] == FIXED16(0)) && (abcd[2] == FIXED16(0)) && (abcd[0] == abcd[3])) { // Simple transformation - we can do this with an untransformed PostScript font // Work out required height of the font MILLIPOINT ReferenceSize = TextManager::GetDefaultHeight(); MILLIPOINT Height = ReferenceSize * abcd[3]; if (!SelectNewFont(RR_TXTFONTTYPEFACE(), RR_TXTBOLD(), RR_TXTITALIC(), Height)) { // Could not select font return FALSE; } } else { // Transformation is complex - we need to use a matrix when selecting the font. if (!SelectNewFont(RR_TXTFONTTYPEFACE(), RR_TXTBOLD(), RR_TXTITALIC(), abcd)) { // Could not select font return FALSE; } } // Render the character in the specified position... KernelDC *pKernelDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); // Output character // Graham 5/8/96: Changed this to work with MBCS // Set up a string buffer for the output character char cBuffer[3]; //Convert the character over to a MBCS index number UINT32 uiCharNumber = UnicodeManager::UnicodeToMultiByte(ch); //DecomposeMultiBytes takes that index number and creates a //two-byte character from it. We put that two-byte character //in cBuffer. UnicodeManager::DecomposeMultiBytes(uiCharNumber, (BYTE*) &cBuffer[0], (BYTE*) &cBuffer[1]); //And let's null-terminate cBuffer cBuffer[2]=0; //Now, if the character was a standard one-byte ASCII character, the ASCII //value will be in the second byte of cBuffer - cBuffer[1] - and cBuffer[0] //will be zero. //Note that we have set cBuffer[2] to zero. That means that cBuffer is null //terminated whether it contains a one or a two byte character. //So let's check if we've got a one-byte or a two-byte character. We do this //by saying...is cBuffer[0] zero? // First we copy it byte by byte into a TCHAR buffer TCHAR tcBuffer[3]; tcBuffer[0]=cBuffer[0]; tcBuffer[1]=cBuffer[1]; tcBuffer[2]=cBuffer[2]; if (tcBuffer[0]==0) //It's a standard ASCII character, one byte long. //So we only want to pass the second byte of cBuffer - cBuffer[1] - //to OutputString pKernelDC->OutputString(&tcBuffer[1]); else //The character is two bytes long (that is, it's a foreign character). //So we want to pass the whole of cBuffer - starting from cBuffer[0] - //to OutputString pKernelDC->OutputString(&tcBuffer[0]); //And that's the end of Graham's MBCS code. Now back to Tim. // Output position DocCoord DocPos(ef[0], ef[1]); pKernelDC->OutputCoord(DocPos); // Work out how to render the character.. BOOL FlatFill = IS_A(CurrentAttrs[ATTR_FILLGEOMETRY].pAttr, FlatFillAttribute); BOOL Stroked = !RR_STROKECOLOUR().IsTransparent(); // The character is filled if the fill is not a simple flat fill, or if it is, // but the fill colour is not transparent. BOOL Filled = !FlatFill || (!RR_FILLCOLOUR().IsTransparent()); if (FlatFill && Filled && !Stroked) { // Simple flat filled text with no outline, so render normally. pKernelDC->OutputToken(_T("t")); } else { // Need to do something special... if (Stroked) { if (Filled) // Stroke and fill it pKernelDC->OutputToken(_T("tb")); else // Just stroke it pKernelDC->OutputToken(_T("ts")); } else { // Just fill it pKernelDC->OutputToken(_T("tf")); } } #endif return TRUE; }

BOOL CamelotEPSRenderRegion::SelectNewFont (  WORD  Typeface, BOOL  Bold, BOOL  Italic, FIXED16 *  abcd )  [protected]

Definition at line 4979 of file cameleps.cpp. { #ifndef STANDALONE // BODGE: This is mingled with horrible OIL code that should be moved to the OIL RSN... // Check to see if it is cached if ((FontInfo.Valid && FontInfo.Complex) && (FontInfo.Typeface == Typeface) && (FontInfo.Bold == Bold) && (FontInfo.Italic == Italic) && (FontInfo.a == abcd[0]) && (FontInfo.b == abcd[1]) && (FontInfo.c == abcd[2]) && (FontInfo.d == abcd[3])) { // It is the same as the currently selected/cached font TRACEUSER( "Tim", _T("Using the cached font\n")); return TRUE; } // Cache is invalid - map the TrueType name to a PostScript font. // Get the typeface name of the font // ENUMLOGFONT *pEnumLogFont = TextInfoBarOp::GetCachedLogFont(Typeface); // String_64 FontName(pEnumLogFont->elfLogFont.lfFaceName); // Changed by Mike (2/8/95) String_64 FontName; if (!FONTMANAGER->GetFontName(Typeface, FontName)) return FALSE; // Transform to a INI-file friendly format String_64 Encoded; INT32 Styles = 0; if (Bold) Styles += 1; if (Italic) Styles += 2; FONTMANAGER->EncodeFontName(FontName, Encoded, Styles); // Look up font in INI file. String_256 MappedFontName; if (!Camelot.GetPrefDirect(_T("EPSFontMapping"), (TCHAR *) Encoded, &MappedFontName)) { // No preference - map to Times-Roman variant if (Bold) { if (Italic) MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAMEBI2)); else MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAMEB2)); } else { if (Italic) MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAMEI2)); else MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAME2)); } } // Select this font by prefixing with a forward slash to make it into a name. KernelDC *pKernelDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); String_8 Slash(TEXT("/")); MappedFontName.Insert(Slash, 0); pKernelDC->OutputToken((TCHAR *) MappedFontName); // Get the default text height, and work out how to scale to PostScript's default of // 1 user space unit (i.e. 1 pt) double ScaleFactor = TextManager::GetDefaultHeight() / 1000.0; TCHAR MatrixBuf[100]; camSprintf(MatrixBuf, _T("[%.3f %.3f %.3f %.3f 0 0]"), (double) (abcd[0].MakeDouble() * ScaleFactor), (double) (abcd[1].MakeDouble() * ScaleFactor), (double) (abcd[2].MakeDouble() * ScaleFactor), (double) (abcd[3].MakeDouble() * ScaleFactor)); pKernelDC->OutputToken(MatrixBuf); // Select the complex font pKernelDC->OutputToken(_T("sf")); // Font cache is now valid FontInfo.Valid = TRUE; FontInfo.Complex = TRUE; FontInfo.Typeface = Typeface; FontInfo.Bold = Bold; FontInfo.Italic = Italic; FontInfo.a = abcd[0]; FontInfo.b = abcd[1]; FontInfo.c = abcd[2]; FontInfo.d = abcd[3]; #endif // All ok return TRUE; }

BOOL CamelotEPSRenderRegion::SelectNewFont (  WORD  Typeface, BOOL  Bold, BOOL  Italic, MILLIPOINT  Size )  [protected]

Get the font name being used by the Camelot EPS exporter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/95 Parameters: Typeface  - The font's ID. [INPUTS] Bold - Is it bold? Italic - Is it italic? Size - The font size in millipoints. Returns: TRUE - Success. FALSE - Failure / an error occured. Definition at line 4889 of file cameleps.cpp. { #ifndef STANDALONE // BODGE: This is mingled with horrible OIL code that should be moved to the OIL RSN... // Check to see if it is cached if ((FontInfo.Valid && !FontInfo.Complex) && (FontInfo.Typeface == Typeface) && (FontInfo.Bold == Bold) && (FontInfo.Italic == Italic) && (FontInfo.Size == Size)) { // It is the same as the currently selected/cached font TRACEUSER( "Tim", _T("Using the cached font\n")); return TRUE; } // Cache is invalid - map the TrueType name to a PostScript font. // Get the typeface name of the font String_64 FontName; if (!FONTMANAGER->GetFontName(Typeface, FontName)) return FALSE; // Transform to a INI-file friendly format String_64 Encoded; INT32 Styles = 0; if (Bold) Styles += 1; if (Italic) Styles += 2; FONTMANAGER->EncodeFontName(FontName, Encoded, Styles); // Look up font in INI file. String_256 MappedFontName; if (!Camelot.GetPrefDirect(_T("EPSFontMapping"), (TCHAR *) Encoded, &MappedFontName)) { // No preference - map to Times-Roman variant if (Bold) { if (Italic) MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAMEBI)); else MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAMEB)); } else { if (Italic) MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAMEI)); else MappedFontName.Load(_R(IDS_K_CAMEPS_MAPFNAME)); } } // Due to inaccuracies, point sizes like 16pt come out as 15.999pt, so we check // for trailing digit errors and round to nearest integer point size if necessary. // (NB we have to use another variable for this otherwise the cache values don't match) MILLIPOINT CorrectedSize = Size; MILLIPOINT Remainder = Size % 1000; if ((Remainder <= 2) || (Remainder >= 998)) // Lose the inaccuracy. CorrectedSize = ((Size + 500) / 1000) * 1000; // Select this font by prefixing with a forward slash to make it into a name. KernelDC *pKernelDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); String_8 Slash(TEXT("/")); MappedFontName.Insert(Slash, 0); pKernelDC->OutputToken((TCHAR *) MappedFontName); pKernelDC->OutputUserSpaceValue(CorrectedSize); pKernelDC->OutputToken(_T("sf")); // Font cache is now valid FontInfo.Valid = TRUE; FontInfo.Complex = FALSE; FontInfo.Typeface = Typeface; FontInfo.Bold = Bold; FontInfo.Italic = Italic; FontInfo.Size = Size; #endif // All ok return TRUE; }

BOOL CamelotEPSRenderRegion::StartRender (  void   )  [virtual]

Prepare the render region for rendering (exporting). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/03/94 Returns: TRUE if worked, FALSE if failed. See also: EPSRenderRegion::Initialise; EPSRenderRegion::StopRender Reimplemented from ArtWorksEPSRenderRegion. Reimplemented in PrintPSRenderRegion. Definition at line 3239 of file cameleps.cpp. { // (ChrisG 3/1/01) - We no longer write out the restore/save pair, so that multiple objects // (both simple and complex) can be clipped together. This now works the same as the // printing (see PrintPSRenderRegion::StartRender) // This should only be done around areas where there is a possibility of the VM being // modified without our knowledge, e.g. when including EPS files inside this file, using // third-party functions, etc..., and the save should be done immediately before the // suspect block, and the restore immediately after. // Call base class first if (!EPSRenderRegion::StartRender()) return FALSE; InitAttributes (); return TRUE; }

BOOL CamelotEPSRenderRegion::StopRender (  void   )  [virtual]

Deinitialise the render region after rendering (exporting). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/03/94 See also: EPSRenderRegion::Deinitialise; EPSRenderRegion::StartRender Reimplemented from VectorFileRenderRegion. Reimplemented in PrintPSRenderRegion. Definition at line 3270 of file cameleps.cpp. { // (ChrisG 3/1/01) - We no longer write out the restore/save pair, so that multiple objects // (both simple and complex) can be clipped together. This now works the same as the // printing (see CamelotEPSRenderRegion::StartRender for more info) if (!IS_A(this, NativeRenderRegion)) { // Since we're clearing the the current attributes in the postscript file (using // restore), we'd better clear them in the exporter, so that they are re-exported // if needed. NOTE: This only seems to affect font info. FontInfo.Valid = 0; } if (SepTables != NULL) { CCFree(SepTables); SepTables = NULL; } DeInitAttributes (); return TRUE; }

BOOL CamelotEPSRenderRegion::WriteEPSBoundingBox (  void   )  [protected, virtual]

Calls the base EPS bounding box function. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/00 Parameters: -  [INPUTS] Returns: TRUE if ok; FALSE if error (e.g. file/disk error or printer driver error) See also: EPSRenderRegion::WriteEPSBoundingBox Reimplemented from ArtWorksEPSRenderRegion. Definition at line 3887 of file cameleps.cpp. { // Call the base class function. return EPSRenderRegion::WriteEPSBoundingBox (); }

BOOL CamelotEPSRenderRegion::WriteEPSTrailerComments (  void   )  [protected, virtual]

Writes out an EPS trailer by calling the base class function. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/000 Parameters: -  [INPUTS] Returns: TRUE if ok; FALSE if error (e.g. file/disk error or printer driver error) See also: EPSRenderRegion::CloseDown Reimplemented from ArtWorksEPSRenderRegion. Definition at line 4024 of file cameleps.cpp. { // (ChrisG 3/1/01) - Output some code so that we stop using our dictionary, Since // this is no longer controlled by Start- and StopRender, we have restore here. This should // be done to close the 'save-restore' block started in WriteSetup. KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); pDC->OutputToken(_T("end restore")); pDC->OutputNewLine(); // Call the base class to over-ride the native render region version. return EPSRenderRegion::WriteEPSTrailerComments (); }

BOOL CamelotEPSRenderRegion::WriteNewLine (  void   )  [virtual]

Outputs a new line tag to the file. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 15/11/00 Parameters: -  [INPUTS] Returns: TRUE - Success. FALSE - Failure. Reimplemented from EPSRenderRegion. Definition at line 5780 of file cameleps.cpp. { // Since the positions of the characters are explicitly given in the EPS file, newline // (/r) characters are not required. And they return TRUE; }

BOOL CamelotEPSRenderRegion::WriteProlog (  KernelDC *  pDC  )  [protected, virtual]

Output any PostScript prolog for this render region. For EPS and printing, this means output of our PostScript rendering procedures; for Native files we do nothing. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/95 Parameters: pDC  - the device context to output to. [INPUTS] -  [OUTPUTS] Returns: TRUE if ok; FALSE if error (e.g. file/disk error or printer driver error) See also: EPSRenderRegion::WriteSetup Reimplemented from EPSRenderRegion. Reimplemented in NativeRenderRegion, and PrintPSRenderRegion. Definition at line 3910 of file cameleps.cpp. { // Get hold of our PostScript prolog resource... CCResTextFile PrologFile; // Open the file if (!PrologFile.open(_R(IDM_PS_PROLOG), _R(IDT_PS_RES))) { // Failed to open the file... ERROR2(FALSE, "Could not get at PostScript resource!"); } // Put some comments out to mark our procset pDC->OutputNewLine(); pDC->OutputToken(_T("%%BeginResource: procset XaraStudio1Dict")); pDC->OutputNewLine(); pDC->OutputToken(_T("% Copyright (c) 1995,1996 Xara Ltd")); pDC->OutputNewLine(); // Start a new dictionary to avoid clashes... pDC->OutputToken(_T("/XaraStudio1Dict 300 dict def XaraStudio1Dict begin")); pDC->OutputNewLine(); // Read each line from the file and output it to the DC. String_256 LineBuf; TCHAR *pBuf = (TCHAR *) LineBuf; while (!PrologFile.read(&LineBuf).eof()) { // Copy this line to output. pDC->OutputTCHARAsChar(pBuf, LineBuf.Length()); pDC->OutputNewLine(); } // All done PrologFile.close(); // Write out any separation functions in this prolog if we // need to. Note this is a bool function WriteSepFunctions(pDC); // Put some comments/code out to mark our procset end pDC->OutputToken(_T("end")); pDC->OutputNewLine(); pDC->OutputToken(_T("%%EndResource")); pDC->OutputNewLine(); return TRUE; }

BOOL CamelotEPSRenderRegion::WriteSetup (  KernelDC *  pDC  )  [protected, virtual]

Output any PostScript setup for this render region. For EPS and printing, this means output of our PostScript code to initialise the context for rendering; for Native files we do nothing. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/95 Parameters: pDC  - the device context to output to. [INPUTS] -  [OUTPUTS] Returns: TRUE if ok; FALSE if error (e.g. file/disk error or printer driver error) See also: EPSRenderRegion::WriteSetup Reimplemented from EPSRenderRegion. Reimplemented in NativeRenderRegion, and PrintPSRenderRegion. Definition at line 3977 of file cameleps.cpp. { // Get hold of our PostScript setup resource... CCResTextFile SetupFile; // Open the file if (!SetupFile.open(_R(IDM_PS_SETUP), _R(IDT_PS_RES))) { // Failed to open the file... ERROR2(FALSE, "Could not get at PostScript resource!"); } // Output some code so that we use our dictionary pDC->OutputToken(_T("save XaraStudio1Dict begin")); pDC->OutputNewLine(); // Read each line from the file and output it to the DC. String_256 LineBuf; TCHAR *pBuf = (TCHAR *) LineBuf; while (!SetupFile.read(&LineBuf).eof()) { // Copy this line to output. pDC->OutputTCHARAsChar(pBuf, LineBuf.Length()); pDC->OutputNewLine(); } // All done SetupFile.close(); return TRUE; }

---

Member Data Documentation

EPSFontCache CamelotEPSRenderRegion::FontInfo [protected]

Definition at line 433 of file cameleps.h.

BYTE* CamelotEPSRenderRegion::SepTables [protected]

Definition at line 440 of file cameleps.h.

---

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

• Kernel/cameleps.h (r1785/r1398)
• Kernel/cameleps.cpp (r1785/r1431)

---