NativeRenderRegion Class Reference

The render region class for the native file save. More...

#include <nativeps.h>

Inheritance diagram for NativeRenderRegion:

List of all members.

Public Member Functions
	NativeRenderRegion (DocRect ClipRect, Matrix ConvertMatrix, FIXED16 ViewScale)
	Constructor for the Native Save/Load filter render region.
virtual void	ConditionalSuicide (void)
	Causes the object to commit suicide. This is to get around using a few if IS_A calls elsewhere in Camelot.
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.
void	GetValidPathAttributes ()
	See CamelotEPSRenderRegion::GetValidPathAttributes. This version checks and handles special native features.
void	GetValidTransparencyAttributes ()
virtual void	GetValidTextAttributes ()
	Output Native file compatible text attribute tokens.
virtual BOOL	RenderChar (WCHAR ch, Matrix *pMatrix)
virtual BOOL	WantsGrids ()
	This function is designed to help with the rendering of grids, as they are not always wanted (eg xara eps). If your class of render region does not want grids to appear, then overide this function and get it to return FALSE. The default behaviour is to return TRUE, which will allow grids to render if they want to.
virtual void	OutputFillColour ()
	Used to output fill colours (in any colour model). Since the CorelXara pre-1.5 format can only cope with CMYK colours (not RGB ones), we export the colour as CMYK, regardless of the colour model used.
virtual void	OutputStrokeColour ()
	Used to output stroke colours (in any colour model). Since the CorelXara pre-1.5 format can only cope with CMYK colours (not RGB ones), we export the colour in CMYK format, regardless of the colour model used..
virtual BOOL	OutputGradFillColours (DocColour *StartCol, DocColour *EndCol, ColourContext *pContext)
	Used to output gradient fill colours, using the CMYK clour model. This is necessary, as the standard EPS export uses RGB colours for gradient fills, which pre-1.5 CorelXara doesn't understand.
Protected Member Functions
virtual BOOL	WriteProlog (KernelDC *)
	Over-ride the routines defined by CamelotEPSRenderRegion - we don't need any PostScript prolog in ART files.
virtual BOOL	WriteSetup (KernelDC *)
	Over-ride the routines defined by CamelotEPSRenderRegion - we don't need any PostScript setup in ART files.
virtual BOOL	WriteFileVersion (KernelDC *)
	This allows the filter to save out a comment line giving file version information. In this Native format version we actually write out the current file version information.
virtual BOOL	WriteCompressionState (KernelDC *)
	In this native file saving class version we save out the compression status of this file with other useful compression type information. We also start compressing the data from this point onwards.
virtual BOOL	WriteEndCompressionState (KernelDC *)
	This is called once everything has been output and before we fix the EPS header. In this baseclass version we do nothing as compression would be a very bad thing.
Protected Attributes
BOOL	CompressionInitedOk

---

Detailed Description

The render region class for the native file save.

Author:

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

Date:

15/12/94

Definition at line 217 of file nativeps.h.

---

Constructor & Destructor Documentation

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

Constructor for the Native Save/Load filter render region. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/12/94 Parameters: ClipRect  - The rectangle to use as the clip rect for the rendering [INPUTS] ConvertMatrix - the rendering matrix ViewScale - the scale to render at Definition at line 1704 of file nativeps.cpp. : CamelotEPSRenderRegion(ClipRect, ConvertMatrix, ViewScale) { CreatorString = _T("Xara Studio (Native) ") CAMELOT_VERSION_STRING; // Flag that we have not started up the compressor ok by default. CompressionInitedOk = FALSE; }

---

Member Function Documentation

void NativeRenderRegion::ConditionalSuicide (  void   )  [virtual]

Causes the object to commit suicide. 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 CamelotEPSRenderRegion. Definition at line 1726 of file nativeps.cpp. { // Delete the object. delete this; }

void NativeRenderRegion::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 CamelotEPSRenderRegion. Definition at line 1746 of file nativeps.cpp. { // We can do everything mate cos we're fabby. pCaps->CanDoAll(); }

void NativeRenderRegion::GetValidPathAttributes (   )  [virtual]

See CamelotEPSRenderRegion::GetValidPathAttributes. This version checks and handles special native features. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/95 See also: EPSRenderRegion::GetValidPathAttributes Reimplemented from CamelotEPSRenderRegion. Definition at line 1810 of file nativeps.cpp. { KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); // Find out what this render region can do. RRCaps Caps; GetRenderRegionCaps(&Caps); if (SetLastOutputAttribute(ATTR_STARTARROW)) { // Start arrow head StartArrowAttribute *pArrow = (StartArrowAttribute *) CurrentAttrs[ATTR_STARTARROW].pAttr; TRACEUSER( "Will", _T("Outputing Start Arrow, ID=%d\n"),pArrow->StartArrow.GetArrowID()); if (pArrow->StartArrow.GetArrowID() >= 0) { pDC->OutputValue((INT32)pArrow->StartArrow.GetArrowID()); pDC->OutputReal((pArrow->StartArrow.GetArrowWidth()).MakeDouble()); pDC->OutputReal((pArrow->StartArrow.GetArrowHeight()).MakeDouble()); pDC->OutputToken(_T("csah")); pDC->OutputNewLine(); } } if (SetLastOutputAttribute(ATTR_ENDARROW)) { // End arrow head EndArrowAttribute *pArrow = (EndArrowAttribute *) CurrentAttrs[ATTR_ENDARROW].pAttr; TRACEUSER( "Will", _T("Outputing End Arrow, ID=%d\n"),pArrow->EndArrow.GetArrowID()); if (pArrow->EndArrow.GetArrowID() >= 0) { pDC->OutputValue((INT32)pArrow->EndArrow.GetArrowID()); pDC->OutputReal((pArrow->EndArrow.GetArrowWidth()).MakeDouble()); pDC->OutputReal((pArrow->EndArrow.GetArrowHeight()).MakeDouble()); pDC->OutputToken(_T("ceah")); pDC->OutputNewLine(); } } if (SetLastOutputAttribute(ATTR_DASHPATTERN)) { // Get dash pattern DashPatternAttribute *pDash = (DashPatternAttribute *) CurrentAttrs[ATTR_DASHPATTERN].pAttr; TRACEUSER( "Will", _T("Outputing Dash Pattern, ID=%d\n"),pDash->DashPattern.GetDashID()); pDC->OutputValue((INT32)pDash->DashPattern.GetDashID()); pDC->OutputToken(_T("cdp")); pDC->OutputNewLine(); } // Now do transparency fills GetValidTransparencyAttributes(); // Handle usual pens/brushes CamelotEPSRenderRegion::GetValidPathAttributes(); }

void NativeRenderRegion::GetValidTextAttributes (   )  [virtual]

Output Native file compatible text attribute tokens. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 18/05/95 Reimplemented from EPSRenderRegion. Definition at line 2148 of file nativeps.cpp. { KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); /* In native format documents we output fontname = <fontname> ctf fontsize = <mp size> ctp bold = <0|1> ctb italic = <0|1> cti sub/superscript = <abs mp rise> <abs mp pointsize> cts linespacing = <absolute linespace> <0> ctls <proportional linespace> <1> ctls all other styles are output by the baseclass */ if (SetLastOutputAttribute(ATTR_TXTFONTTYPEFACE)) { TxtFontTypefaceAttribute* pFontAttr = (TxtFontTypefaceAttribute*)CurrentAttrs[ATTR_TXTFONTTYPEFACE].pAttr; if (pFontAttr) { String_64 OutputFont; FontClass Class; CachedFontItem* pItem = FONTMANAGER->GetCachedFont(pFontAttr->HTypeface); ERROR3IF(pItem==NULL,"Cannot find the cached font in GetValidTextAttributes"); OutputFont = *(pItem->GetFontName()); Class = pItem->GetFontClass(); // If we are not outputting true type fonts we need to output an // extension token to say, the next ctf on the input stream should be // treated as a FontClass type of font. This allows us to load back // ATM fonts which have the same name as true type fonts. if (Class!=FC_TRUETYPE) { pDC->OutputValue((INT32)EOTAG_FONTTYPE); pDC->OutputToken(_T("cso")); pDC->OutputValue((INT32)Class); pDC->OutputToken(_T("cftf")); pDC->OutputToken(_T("ceo")); pDC->OutputNewLine(); } /*BOOL ok =*/ FONTMANAGER->GetFontName(pFontAttr->HTypeface, OutputFont); OutputFont.SwapChar(' ','-'); pDC->OutputToken((TCHAR *)OutputFont); pDC->OutputToken(_T("ctf")); pDC->OutputNewLine(); if ((pFontAttr->IsBold) || (pFontAttr->IsItalic)) { // font flags a bold or italic substyle. pDC->OutputValue((INT32)EOTAG_FONTFLAGS); pDC->OutputToken(_T("cso")); pDC->OutputNewLine(); pDC->OutputToken(_T("cfft")); pDC->OutputNewLine(); pDC->OutputToken(_T("ceo")); pDC->OutputNewLine(); pDC->OutputValue((INT32) pFontAttr->IsBold); pDC->OutputToken(_T("ctb")); pDC->OutputNewLine(); pDC->OutputValue((INT32) pFontAttr->IsItalic); pDC->OutputToken(_T("cti")); pDC->OutputNewLine(); } } } if (SetLastOutputAttribute(ATTR_TXTFONTSIZE)) { // Output the fontsize next pDC->OutputValue(RR_TXTFONTSIZE()); pDC->OutputToken(_T("ctp")); pDC->OutputNewLine(); } if (SetLastOutputAttribute(ATTR_TXTBOLD)) { // read the bold attribute value explicitly (dont use RR_TXTBOLD) BOOL Bold = ( (TxtBoldAttribute*)(CurrentAttrs[ATTR_TXTBOLD].pAttr) )->BoldOn; pDC->OutputValue((INT32)Bold); pDC->OutputToken(_T("ctb")); pDC->OutputNewLine(); } if (SetLastOutputAttribute(ATTR_TXTITALIC)) { // read the italic attribute value explicitly (dont use RR_TXTITALIC) BOOL Italic = ( (TxtItalicAttribute*)(CurrentAttrs[ATTR_TXTITALIC].pAttr) )->ItalicOn; pDC->OutputValue((INT32)Italic); pDC->OutputToken(_T("cti")); pDC->OutputNewLine(); } if (SetLastOutputAttribute(ATTR_TXTSCRIPT)) { TxtScriptAttribute* pScript = RR_TXTSCRIPT(); double FontSize = (double)RR_TXTFONTSIZE(); // in millipoints double offset = (pScript->Offset).MakeDouble(); double size = (pScript->Size).MakeDouble(); MILLIPOINT rise = (MILLIPOINT)(FontSize*offset); // rise in millipoints MILLIPOINT ptsize = (MILLIPOINT)(FontSize*size); // pointsize in millipoints pDC->OutputValue(rise); pDC->OutputValue(ptsize); pDC->OutputToken(_T("cts")); pDC->OutputNewLine(); } // output proportional or none proportional line spacing if (SetLastOutputAttribute(ATTR_TXTLINESPACE)) { TxtLineSpaceAttribute* pLineSpace = (TxtLineSpaceAttribute*)(CurrentAttrs[ATTR_TXTLINESPACE].pAttr); // There are some rules for reading the linespacing value which I shall divulge // If IsARatio is true then use the proportinal linespacing value. // else use the absolute linespacing // However if the absolute linespacing is zero, then we MUST use the proportional // linespacing. Eeek! // ie it is an error if (absolute==0 && !IsARatio()) which we will check for here if (!pLineSpace->IsARatio()) { INT32 LineSpace = pLineSpace->Value; ERROR3IF(LineSpace==0, "Absolute line spacing is zero yet IsARatio() is FALSE, in GetValidTextAttributes()"); pDC->OutputValue(LineSpace); pDC->OutputValue((INT32)0); } else { double Ratio = (pLineSpace->Ratio).MakeDouble(); pDC->OutputFloat(Ratio,4); pDC->OutputValue((INT32)1); } pDC->OutputToken(_T("ctls")); pDC->OutputNewLine(); } // Handle all other types EPSRenderRegion::GetValidTextAttributes(); }

void NativeRenderRegion::GetValidTransparencyAttributes (   )

Definition at line 1877 of file nativeps.cpp. { // Find out what this render region can do. RRCaps Caps; GetRenderRegionCaps(&Caps); // Can we do transparency? if (!Caps.Transparency) // No - so don't do anything return; KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); if (SetLastOutputAttribute(ATTR_STROKETRANSP)) { // Now do the line transparency StrokeTranspAttribute *pAttr = (StrokeTranspAttribute *) CurrentAttrs[ATTR_STROKETRANSP].pAttr; UINT32 Transp = *pAttr->GetStartTransp(); UINT32 TranspType = pAttr->GetTranspType(); TRACEUSER( "Will", _T("Outputing Line transp, Val=%d, Type=%d\n"),Transp, TranspType); // Output transparency level pDC->OutputValue((UINT32) Transp); // Output transparency type... pDC->OutputValue((UINT32) TranspType); pDC->OutputToken(_T("cst")); pDC->OutputNewLine(); } if (SetLastOutputAttribute(ATTR_TRANSPFILLGEOMETRY)) { // Now do the transparent fill geometry TranspFillAttribute *pFillAttr = (TranspFillAttribute *) CurrentAttrs[ATTR_TRANSPFILLGEOMETRY].pAttr; // Get the transparency information UINT32 *StartTransp, *EndTransp, TranspType, FillType = TRANSPFILL_NONE; TranspType = pFillAttr->GetTranspType(); //pPaintMode->m_PaintingMode; ENSURE((TranspType >= 1) && (TranspType <= 3), "Bad transparency type!"); // Deliberately restrictive? StartTransp = pFillAttr->GetStartTransp(); ENSURE((StartTransp == NULL) || ((*StartTransp >= 0) && (*StartTransp <= 255)), "Bad start transparency level!"); // Get the correct brush - may be a grad fill. if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(FlatTranspFillAttribute))) { // Check special case for 'no transparency' (0% transparent and type 1) if (((*StartTransp) != 0) || (TranspType != TT_Mix)) FillType = TRANSPFILL_FLAT; } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(GradTranspFillAttribute)) && !pFillAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapTranspFillAttribute)) ) { // Output the start and end points of the grad fill DocCoord *Point; Point = pFillAttr->GetStartPoint(); pDC->OutputCoord(*Point); Point = pFillAttr->GetEndPoint(); pDC->OutputCoord(*Point); // Output the fill type if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(LinearTranspFillAttribute))) { DocCoord* Start = pFillAttr->GetStartPoint(); DocCoord* End = pFillAttr->GetEndPoint(); DocCoord* End2 = pFillAttr->GetEndPoint2(); if (AreLinesPerpendicular(Start, End, End2)) { TRACEUSER( "Will", _T("Exporting Simple Transp Linear Fill\n")); FillType = TRANSPFILL_LINEAR; } else { TRACEUSER( "Will", _T("Exporting New Style Transp Linear Fill\n")); pDC->OutputCoord(*pFillAttr->GetEndPoint2()); FillType = TRANSPFILL_NEWLINEAR; } } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(RadialTranspFillAttribute))) { // Is it circular or elliptical? RadialTranspFillAttribute *pRadialFillAttr = (RadialTranspFillAttribute *) pFillAttr; if (pRadialFillAttr->IsElliptical()) { // Elliptical fill - output the second end point. Point = pRadialFillAttr->GetEndPoint2(); pDC->OutputCoord(*Point); FillType = TRANSPFILL_ELLIPTICAL; } else { // Circular fill FillType = TRANSPFILL_CIRCULAR; } } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(ConicalTranspFillAttribute))) { FillType = TRANSPFILL_CONICAL; } else { // Unknown fill type - fall back to basic attributes. ERROR3("Unsupported grad fill encountered while exporting"); EPSRenderRegion::GetValidPathAttributes(); return; } } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(FractalTranspFillAttribute)) && Caps.BitmapFills) { // Fractal fill - output fractal fill command... FractalTranspFillAttribute *pFractalFill = (FractalTranspFillAttribute *) pFillAttr; // Save the coords of the fill mesh pDC->OutputCoord(pFractalFill->StartPoint); pDC->OutputCoord(pFractalFill->EndPoint); pDC->OutputCoord(pFractalFill->EndPoint2); // Save the fractal parameters out. pDC->OutputValue(pFractalFill->Seed); pDC->OutputReal(pFractalFill->Graininess.MakeDouble()); pDC->OutputReal(pFractalFill->Gravity.MakeDouble()); pDC->OutputReal(pFractalFill->Squash.MakeDouble()); // And now the DPI of the fractal bitmap UINT32 DPI = pFractalFill->GetFractalDPI(); pDC->OutputValue(DPI); // And now the 'tileable' flag pDC->OutputValue((INT32) (pFractalFill->GetTileable())); // Always Fractal type 1 at present pDC->OutputToken(_T("1")); TRACEUSER( "Will", _T("Exporting new fractal transp\n")); // This is a fractal fill FillType = TRANSPFILL_NEWFRACTAL; } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(NoiseTranspFillAttribute))) { FillType = TRANSPFILL_NONE; } else if (pFillAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapTranspFillAttribute)) && Caps.BitmapFills) { // Texture fill - output texture fill command: // BitmapFillAttribute *pBitmapFill = (BitmapFillAttribute *) pFillAttr; // Output the 3 fill points... DocCoord *Point; Point = pFillAttr->GetStartPoint(); pDC->OutputCoord(*Point); Point = pFillAttr->GetEndPoint(); pDC->OutputCoord(*Point); Point = pFillAttr->GetEndPoint2(); pDC->OutputCoord(*Point); TRACEUSER( "Will", _T("Exporting new bitmap transp\n")); // This is a texture fill FillType = TRANSPFILL_NEWTEXTURE; } else { ERROR3("Illegal transparency fill type!"); } // Output transparency levels... if (FillType != TRANSPFILL_NONE) { if ((FillType != TRANSPFILL_TEXTURE) && (FillType != TRANSPFILL_FRACTAL)) { // Output first transparency level pDC->OutputValue((UINT32) (*StartTransp)); // Output second transparency level if there is one. switch (FillType) { case TRANSPFILL_LINEAR: case TRANSPFILL_ELLIPTICAL: case TRANSPFILL_CIRCULAR: case TRANSPFILL_CONICAL: case TRANSPFILL_NEWLINEAR: case TRANSPFILL_NEWTEXTURE: case TRANSPFILL_NEWFRACTAL: EndTransp = pFillAttr->GetEndTransp(); ENSURE((*EndTransp >= 0) && (*EndTransp <= 255), "Bad end transparency level!"); pDC->OutputValue((UINT32) (*EndTransp)); break; default: // This is a valid situation - no second transparency level. break; } } // Output transparency type... pDC->OutputValue((UINT32) TranspType); } // Output transparency fill type pDC->OutputValue((UINT32) FillType); // Output the transparent fill token pDC->OutputToken(_T("cxt")); pDC->OutputNewLine(); // If this is a bitmap-based transprency fill, output the bitmap if ((FillType == TRANSPFILL_TEXTURE || FillType == TRANSPFILL_NEWTEXTURE) && Caps.BitmapFills) { BitmapTranspFillAttribute *pBitmapFill = (BitmapTranspFillAttribute *) pFillAttr; ExportDC *pExportDC = (ExportDC *) pDC; if (pBitmapFill->GetBitmap()) pExportDC->GetParentFilter()->ExportBitmap(*pBitmapFill->GetBitmap()); } } if (SetLastOutputAttribute(ATTR_TRANSPFILLMAPPING)) { // Now do the chromatic fill mapping TranspFillMappingAttribute *pFillAttr = (TranspFillMappingAttribute *) CurrentAttrs[ATTR_TRANSPFILLMAPPING].pAttr; // Get the correct mapping INT32 MappingType = pFillAttr->Repeat; 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("cxmt")); pDC->OutputNewLine(); } }

void NativeRenderRegion::OutputFillColour (  void   )  [virtual]

Used to output fill colours (in any colour model). Since the CorelXara pre-1.5 format can only cope with CMYK colours (not RGB ones), we export the colour as CMYK, regardless of the colour model used. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 30/01/01 Reimplemented from CamelotEPSRenderRegion. Definition at line 2539 of file nativeps.cpp. { OutputFillCMYKColour (); }

BOOL NativeRenderRegion::OutputGradFillColours (  DocColour *  StartCol, DocColour *  EndCol, ColourContext *  pContext )  [virtual]

Used to output gradient fill colours, using the CMYK clour model. This is necessary, as the standard EPS export uses RGB colours for gradient fills, which pre-1.5 CorelXara doesn't understand. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 30/01/01 Parameters: See  CamelotEPSRenderRegion (they're identical) [INPUTS] Reimplemented from CamelotEPSRenderRegion. Definition at line 2576 of file nativeps.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. PColourCMYK CMYK; // Write out the start colour StartCol->GetCMYKValue (pContext, &CMYK); pDC->OutputColour (&CMYK); 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->GetCMYKValue (pContext, &CMYK); pDC->OutputColour (&CMYK); 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 NativeRenderRegion::OutputStrokeColour (   )  [virtual]

Used to output stroke colours (in any colour model). Since the CorelXara pre-1.5 format can only cope with CMYK colours (not RGB ones), we export the colour in CMYK format, regardless of the colour model used.. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 30/01/01 Reimplemented from CamelotEPSRenderRegion. Definition at line 2557 of file nativeps.cpp. { OutputStrokeCMYKColour (); }

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

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/95 Parameters: ch  - unicode value of TCHAR [INPUTS] pMatrix - matrix specifying transforms to place TCHAR correctly in document Returns: FALSE if fails Reimplemented from CamelotEPSRenderRegion. Definition at line 2312 of file nativeps.cpp. { // If we are not drawing complex shapes and this shape is, then return if ((!RenderComplexShapes) && (TestForComplexShape(&Caps))) return TRUE; ERROR2IF( this==NULL,FALSE,"RenderRegion::RenderChar() - this==NULL"); ERROR2IF(pMatrix==NULL,FALSE,"RenderRegion::RenderChar() - pMatrix==NULL"); #if EXPORT_TEXT // Check for changed attributes GetValidPathAttributes(); GetValidTextAttributes(); KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC); INT32 CharOut = (INT32)ch; INT32 NumCodes = 1; pDC->OutputValue(CharOut); pDC->OutputValue(NumCodes); pDC->OutputToken(_T("ctx")); pDC->OutputNewLine(); #else // just do what RenderRegion::RenderChar() would do! // create the TCHAR's path Path* pCharPath=CreateCharPath(ch,pMatrix); if (pCharPath==NULL) return FALSE; // draw path using current attibutes in render region if (pCharPath->GetNumCoords()!=0) DrawPath(pCharPath); // clean up delete pCharPath; #endif return TRUE; }

BOOL NativeRenderRegion::WantsGrids (   )  [virtual]

This function is designed to help with the rendering of grids, as they are not always wanted (eg xara eps). If your class of render region does not want grids to appear, then overide this function and get it to return FALSE. The default behaviour is to return TRUE, which will allow grids to render if they want to. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/95 Returns: TRUE Reimplemented from EPSRenderRegion. Definition at line 2521 of file nativeps.cpp. { return TRUE; }

BOOL NativeRenderRegion::WriteCompressionState (  KernelDC *  pDC  )  [protected, virtual]

In this native file saving class version we save out the compression status of this file with other useful compression type information. We also start compressing the data from this point onwards. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 19/05/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. Definition at line 2401 of file nativeps.cpp. { TRACEUSER( "Neville", _T("WriteCompressionState\n")); // If the preference is set then compress the file, otherwise do nothing if (CamelotNativeEPSFilter::GetNativeCompression()) { // Get a pointer to the CCDiskFile object EPSExportDC *pEPSDC = (EPSExportDC *) pDC; if (pEPSDC == NULL || ExportFile == NULL) return FALSE; // First, see if we have enough memory to start up the compression system BOOL Ok = pEPSDC->ExportFile->InitCompression(); // If this fails then don't try anything if (!Ok) { // Flag that we have not started up the compressor ok. // Do not try and save out the end compression tokens. CompressionInitedOk = FALSE; return FALSE; } // Flag that we have started up the compressor ok. // We can write out the end compression bits CompressionInitedOk = TRUE; // Could require some compression here... pDC->OutputToken(_T("%%Compression: ")); // The compression type that we are using. pDC->OutputToken(_T("0 ")); pDC->OutputNewLine(); // Output an extra line to sync to pDC->OutputToken(_T("%%Compression info:")); // Write a very simple .gz header: // Just output the two magic numbers plus a status word plus a flags word // We must output text rather than numbers and must never output LF or CR in the // middle as this will screw the lexer double StreamVersion = GZipFile::GetStreamVersionNo(); TCHAR buf[300]; camSprintf(buf, _T(" %.2fD"), StreamVersion); // version in form 0.92 followed by D for deflated pDC->OutputToken(buf); TRACEUSER( "Neville", _T("WriteCompressionState wrote version %.2f\n"),StreamVersion); pDC->OutputNewLine(); // Now that we have written out compression token to say that this is a compressed file, // start up the file compression. // This will write out some useful data such as compressed file version pEPSDC->ExportFile->SetCompression(TRUE); } return TRUE; }

BOOL NativeRenderRegion::WriteEndCompressionState (  KernelDC *  pDC  )  [protected, virtual]

This is called once everything has been output and before we fix the EPS header. In this baseclass version we do nothing as compression would be a very bad thing. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 22/05/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. Definition at line 2475 of file nativeps.cpp. { TRACEUSER( "Neville", _T("WriteEndCompressionState\n")); // If the preference is set then compress the file, otherwise do nothing // Check though that the compressor started up ok. if (CamelotNativeEPSFilter::GetNativeCompression() && CompressionInitedOk) { // Could require some compression ending here... pDC->OutputToken(_T("%%EndCompression: ")); pDC->OutputNewLine(); // Output an extra line to sync to pDC->OutputToken(_T("%%EndCompressionInfo: ")); pDC->OutputNewLine(); // Now that we have written out compression token to say that this is a compressed file, // start up the file compression. // This will output some useful data such as a crc check and amoutn written // Get a pointer to the CCDiskFile object EPSExportDC *pEPSDC = (EPSExportDC *) pDC; if (pEPSDC && ExportFile) pEPSDC->ExportFile->SetCompression(FALSE); } return TRUE; }

BOOL NativeRenderRegion::WriteFileVersion (  KernelDC *  pDC  )  [protected, virtual]

This allows the filter to save out a comment line giving file version information. In this Native format version we actually write out the current file version information. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/05/95 Parameters: pDC  - the device context to output to. [INPUTS] -  [OUTPUTS] Returns: TRUE if ok; FALSE if error (e.g. file/disk error) See also: EPSRenderRegion::WriteSetup Reimplemented from EPSRenderRegion. Definition at line 2371 of file nativeps.cpp. { // Buffer used to build up the file version comment. TCHAR buf[50]; // Output the current file version in the format 1.00 for NativeFileVersion 100 camSprintf(buf, _T("%%%%File version: %.2f"), WriteNativeVersion); pDC->OutputToken(buf); pDC->OutputNewLine(); return TRUE; }

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

Over-ride the routines defined by CamelotEPSRenderRegion - we don't need any PostScript prolog in ART files. 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 CamelotEPSRenderRegion. Definition at line 1769 of file nativeps.cpp. { // No PostScript procedure defns here... return TRUE; }

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

Over-ride the routines defined by CamelotEPSRenderRegion - we don't need any PostScript setup in ART files. 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: NativeRenderRegion::WriteSetup Reimplemented from CamelotEPSRenderRegion. Definition at line 1791 of file nativeps.cpp. { // No PostScript setup code here... return TRUE; }

---

Member Data Documentation

BOOL NativeRenderRegion::CompressionInitedOk [protected]

Definition at line 240 of file nativeps.h.

---

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

• Kernel/nativeps.h (r1785/r751)
• Kernel/nativeps.cpp (r1785/r1668)

---