KernelDC Class Reference

Provide a base device context for rendering to something other than the screen. This includes printers, files, and PostScript devices. More...

#include <kerneldc.h>

Inheritance diagram for KernelDC:

List of all members.

Public Member Functions
	KernelDC (RenderType Type)
	Initialise a kernel DC. This initialises the user space origin to (0,0) by default (only relevant for DCs that use the PostScript stream functions).
	KernelDC (CNativeDC *pDC, RenderType Type)
	Initialise a kernel DC. This initialises the user space origin to (0,0) by default (only relevant for DCs that use the PostScript stream functions).
virtual BOOL	OutputNewLine ()
	Causes a new line to be started in the EPS/PS output. This is used to give a pleasant appearance to the file - most EPS/PS commands (as opposed to operands) are followed by a new line.
virtual BOOL	OutputToken (TCHAR *)
	Outputs a string token to the EPS/PS stream. This is the central routine through which the other high-level routines eventually come. The other routines convert their output to a string, which they then pass on to this routine. A record is kept of the current line width - if it is over 70 characters wide before the token is output, then a new line is output to keep the lines in the EPS file reasonably short. For this reason, it is important not to output strings that contain newline characters, because this routine will not notice, and hence the LineWidth count will be wrong. This routine also ensures that tokens are separated by either a space or a newline, so it is not necessary to output spaces directly to keep the tokens separate - it happens automatically.
virtual BOOL	OutputDirect (BYTE *, INT32)
	Send bytes directly to the PostScript stream with no alteration or padding. Used for sending binary/hex data to stream.
virtual BOOL	OutputTCHARAsChar (TCHAR *Buf, INT32 nBytes)
	Send bytes directly to the PostScript stream with no alteration or padding. Used for sending binary/hex data to stream. We send the BYTE equal to the TCHAR with no conversion.
void	SetOrigin (DocCoord &)
	Set the user space origin to the specified position in spread coordinates.
DocCoord	GetOrigin ()
virtual BOOL	OutputCoord (DocCoord &, EPSAccuracy Accuracy=ACCURACY_NORMAL)
	Write out a coordinate x,y pair to the export file, automatically converting from spread coordinates to the EPS user space coordinate system, including adjusting the origin.
virtual BOOL	OutputUserSpaceValue (MILLIPOINT, EPSAccuracy Accuracy=ACCURACY_NORMAL)
	Output a 'user space' value to the export file. User space is the coordinate system used for EPS files (and more generally, PostScript programs). For Illustrator-based EPS, the user space is expressed in units of points, and usually has the origin at (0.0). By default, we follow the Illustrator convention of truncating values to 2dp (so we can generate files compatible with Illustrator etc), but Camelot EPS uses the full 3dp accuracy (we don't store more any accuracy than this internally). The accuracy can be changed by calling KernelDC::SetFullAccuracy Note that this routine does not do origin translation, because it may be used for dimensions such as line widths, which have no earthly use for origins (and anyway, it's a bit tricky to do origin translation with only one dimension!).
BOOL	OutputColour (PColourCMYK *)
	Output a colour, as expressed by the Camelot 'Colour' class. This function takes the CMYK variation, is this is most appropriate to EPS files. Camelot colour values are converted from the 0-255 range to the 0.0-1.0 range before being output.
BOOL	OutputNamedColour (DocColour *, ColourContext *pContext=NULL)
	Similar to OutputColour(), except it outputs the colour name and tint of the colour as well. If pCol does not reference an indexed colour, then the name "NoName" is used.
BOOL	OutputColourValue (UINT32 n)
	Output a colour value to the export file. A 'colour value' is a value as used in the Camelot 'Colour' class, i.e. in the range 0 to 255. This range is converted to the range 0.0 to 1.0, and output to the file.
BOOL	OutputString (TCHAR *)
	Output a string in PostScript format, i.e. delimited by '(' and ')', and escaping any parentheses so the string is syntactically correct. e.g. "String" is output as "(String)", and "Hello (there)" is output as "(Hello \(there\))" and so on.
BOOL	OutputValue (INT32)
	Output a signed integer to the EPS stream.
BOOL	OutputValue (UINT32)
	Output an unsigned integer to the EPS stream.
BOOL	OutputReal (double)
	Output a real (floating point) number to the EPS stream.
BOOL	OutputFloat (const double Value, const UINT32 DecPl)
	Output a real (floating point) number to the EPS stream.
BOOL	OutputMatrix (Matrix *M)
	Output a Matrix to the EPS stream.
BOOL	OutputArray (INT32 *, INT32)
	Output an Array to the EPS stream.
BOOL	OutputColourName (DocColour *pCol)
	Outputs a named colour's name as a string. If pCol does not reference an indexed colour, then the name "NoName" is used. This was seperated from OutputNamedColour so that the DeviceContext will not need to worry about which ColourModel to use (CMYK, RGB, etc...), as this will be determined by the RenderRegion.
virtual INT32	OutputRawBinary (BYTE *Data, UINT32 Length, UINT32 Alignment=1)
	Outputs a sequence of bytes as raw hex data, as used by PostScript operators such as readhexstring.
BOOL	StartASCII85Output (BOOL RunLengthEncode=FALSE)
INT32	OutputASCII85 (BYTE *Data, UINT32 Length)
	Outputs a sequence of bytes as ASCII85 hex data, as used by PostScript Level 2. (This encoding should not be used when generating PostScript that must be compatible with Level 1 interpreters).
INT32	EndASCII85Output ()
void	SetFullAccuracy (BOOL)
	Change the accuracy used when saving out user space values to the EPS file. This defaults to 2dp, but can be enabled to full accuracy (3dp) by passing in TRUE. We still do 2dp because that is what Illustrator and most of the other mediocre programs use and we don't want to generate files that might upset them. Camelot EPS uses the full 3dp accuracy though.
virtual Filter *	GetParentFilter ()
Protected Member Functions
void	ConvertToHex (BYTE *Data, UINT32 Length, TCHAR *Buf)
	Convert a block of bytes to a hexadecimal ASCII stroing representation of the data.
BYTE *	RunLengthEncode (BYTE *Data, INT32 *Length)
BYTE *	RunLengthDecode (BYTE *Data, INT32 *Length)
BOOL	QueueASCII85Data (BYTE *Data, UINT32 Length)
INT32	FlushASCII85Buffer ()
INT32	ConvertToASCII85 (BYTE *Src, UINT32 Length, BYTE *Dest)
INT32	ConvertFromASCII85 (BYTE *Src, UINT32 Length, BYTE *Dest)
void	ConvertToPoints (MILLIPOINT, TCHAR *)
Protected Attributes
UINT32	LineWidth
DocCoord	Origin
BOOL	FullAccuracy
LPBYTE	RawBuf
LPBYTE	A85Buf
UINT32	RawBufSize
BOOL	RLEtheASCII85Data

---

Detailed Description

Provide a base device context for rendering to something other than the screen. This includes printers, files, and PostScript devices.

Author:

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

Date:

23/04/95

The main purpose of this class is to provide a repository for our bespoke PostScript procedures. This base class cannot use them as the centralised output routines are unimplemented and will error if called. Derived classes such as EPSExportDC and PrintPSDC will override these output functions, so the PostScript output routines can be used. This class provides basic primitives for writing out EPS/PS tokens such as commands, colours, and user space values (line-widths, co-ordinates etc). The DC takes care of handling formatting such as separating tokens with a space or newline, and limits line widths to a reasonable size.

See also:

EPSExportDC; ExportDC; PrintPSDC

Definition at line 143 of file kerneldc.h.

---

Constructor & Destructor Documentation

KernelDC::KernelDC (  RenderType  rType  )

Initialise a kernel DC. This initialises the user space origin to (0,0) by default (only relevant for DCs that use the PostScript stream functions). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/04/95 Parameters: The  type of DC being made. [INPUTS] See also: KernelDC::SetOrigin; KernelDC::OutputUserSpaceValue; KernelDC::OutputCoord Definition at line 132 of file kerneldc.cpp. : CCDummyDC(rType) { // Initialise other fields. LineWidth = 0; Origin.x = 0; Origin.y = 0; // Default to 2dp accuracy for user space values. FullAccuracy = FALSE; // No ASCII85 conversion by default. RawBuf = NULL; A85Buf = NULL; RawBufSize = 0; RLEtheASCII85Data = FALSE; }

KernelDC::KernelDC (  CNativeDC *  pDC, RenderType  rType )

Initialise a kernel DC. This initialises the user space origin to (0,0) by default (only relevant for DCs that use the PostScript stream functions). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/04/95 Parameters: The  OIL DC pointer, and the type of DC being made. [INPUTS] See also: KernelDC::SetOrigin; KernelDC::OutputUserSpaceValue; KernelDC::OutputCoord Definition at line 164 of file kerneldc.cpp. : CCDummyDC(pDC, rType) { // Initialise other fields. LineWidth = 0; Origin.x = 0; Origin.y = 0; // Default to 2dp accuracy for user space values. FullAccuracy = FALSE; // No ASCII85 conversion by default. RawBuf = NULL; A85Buf = NULL; RawBufSize = 0; RLEtheASCII85Data = FALSE; }

---

Member Function Documentation

INT32 KernelDC::ConvertFromASCII85 (  BYTE *  Src, UINT32  Length, BYTE *  Dest )  [protected]

Definition at line 1230 of file kerneldc.cpp. { // Precompute the powers of 85 to use when encoding. static const INT32 Power85[5] = { 1, 85, 85 * 85, 85 * 85 * 85, 85 * 85 * 85 * 85 }; // Start at the beginning of the buffer // INT32 SrcOfs = 0; INT32 DstOfs = 0; BOOL FoundEOD = FALSE; while ((Length > 0) && (!FoundEOD)) { // Decode five characters into four bytes. UINT32 n = 0; UINT32 TupleLength = (Length >= 5) ? 5 : Length; // Look for the EOD marker for (UINT32 i = 0; i < 5; i++) { if ((Src[i] == '~') && ((i + 1) < Length) && (Src[i + 1] == '>')) { // Found the EOD marker in the data FoundEOD = TRUE; // Shorten the tuple TupleLength = i; } } if (Src[0] == 'z') { // Skip the 'z' character TupleLength = 1; } else { // Decode base-85 numbers. for (UINT32 i = 0; i < 5; i++) { if (i < TupleLength) n += ((Src[i] - '!') * Power85[4 - i]); else if (i == TupleLength) // Round up fractional part n += 0x80 << ((4 - i) * 8); // 'z' is not allowed within a tuple ERROR2IF(Src[i] == 'z', -1, "Illegal 'z' in ASCII85 stream"); } } // Find out how many bytes we just decoded. UINT32 nBytesDecoded = TupleLength - 1; // Copy the decoded data into the buffer. UINT32 Shift = 24; while (nBytesDecoded > 0) { Dest[DstOfs++] = (BYTE) ((n >> Shift) & 0xFF); nBytesDecoded--; Shift -= 8; } // Move on to the next tuple. Src += TupleLength; Length -= TupleLength; } // Check the lengths match ERROR2IF(Length != 0, -1, "Incorrect length while decoding ASCII85 data"); //ERROR2IF(!FoundEOD, -1, "No EOD found while decoding ASCII85 data"); // Finished encoding - terminate the string (not strictly necessary but what the hell). Dest[DstOfs] = 0; // Return how many bytes this decoded ASCII85 data takes up return DstOfs; }

INT32 KernelDC::ConvertToASCII85 (  BYTE *  Src, UINT32  Length, BYTE *  Dest )  [protected]

Definition at line 1122 of file kerneldc.cpp. { // Precompute the powers of 85 to use when encoding. /* static const INT32 Power85[5] = { 1, 85, 85 * 85, 85 * 85 * 85, 85 * 85 * 85 * 85 }; */ // Start at the beginning of the buffer // INT32 SrcOfs = 0; INT32 DstOfs = 0; while (Length > 0) { // Encode four bytes as five characters. UINT32 n=0; if (Length >= 4) { // Normal 4 bytes of data n = Src[0]; n = (n << 8) | Src[1]; n = (n << 8) | Src[2]; n = (n << 8) | Src[3]; } else { // Pad with zeros... switch (Length) { case 3: n = Src[0]; n = (n << 8) | Src[1]; n = (n << 8) | Src[2]; n <<= 8; break; case 2: n = Src[0]; n = (n << 8) | Src[1]; n <<= 16; break; case 1: n = Src[0]; n <<= 24; break; } } if ((n == 0) && (Length >= 4)) { // Special case - use "z" instead of "!!!!!" Dest[DstOfs++] = 'z'; } else { #if 1 register UINT32 q = n/7225; register unsigned r = (unsigned)n-7225*(unsigned)q; register unsigned t; Dest[DstOfs+3] = (t = r/85) + '!'; Dest[DstOfs+4] = r - 85*t + '!'; Dest[DstOfs+0] = (t = q/7225) + '!'; r = (unsigned)q - 7225*t; Dest[DstOfs+1] = (t = r/85) + '!'; Dest[DstOfs+2] = r - 85*t + '!'; if (Length >= 4) DstOfs += 5; else // Special case for last 5-tuple - see Red Book, bottom of p129 DstOfs += (Length + 1); #else /* for (INT32 i = 4; i >= 0; i--) { // Reduce the number to a 5 digit base-85 number. UINT32 m = n / Power85[i]; n -= m * Power85[i]; Dest[DstOfs++] = (TCHAR) (m + 33); } */ #endif } // Move on to the next four bytes Src += 4; if (Length < 4) Length = 0; else Length -= 4; } // Finished encoding - terminate the string (not strictly necessary but what the hell). // (Jason here... What do you mean "What the hell?" - you've just written one byte off the // end of the buffer, and corrupted the heap! I've now added 4 bytes padding // on our buffers (in StartASCII85Output) to make sure this is safe) Dest[DstOfs] = 0; // Return how many bytes this ASCII85 data takes up return DstOfs; }

void KernelDC::ConvertToHex (  BYTE *  Data, UINT32  Length, TCHAR *  Buf )  [protected]

Convert a block of bytes to a hexadecimal ASCII stroing representation of the data. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: Data  - pointer to the data to convert [INPUTS] Length - the number of bytes to convert. Buf  - the buffer to place the hex string into. [OUTPUTS] NB. must be big enough to hold the 0-terminator! See also: KernelDC::OutputRawBinary Definition at line 887 of file kerneldc.cpp. { UINT32 DataOfs = 0, DestOfs = 0; while (DataOfs < Length) { // Extract each 4-bit set and encode as hex INT32 Nybble = (Data[DataOfs] & 0xF0) >> 4; ENSURE(Nybble < 16, "Bad hex digit in KernelDC::ConvertToHex"); TCHAR Ch; if (Nybble < 10) Ch = '0' + (TCHAR) Nybble; else Ch = 'A' + (TCHAR) (Nybble - 10); Buf[DestOfs++] = Ch; Nybble = Data[DataOfs] & 0xF; ENSURE(Nybble < 16, "Bad hex digit in KernelDC::ConvertToHex"); if (Nybble < 10) Ch = '0' + (TCHAR) Nybble; else Ch = 'A' + (TCHAR) (Nybble - 10); Buf[DestOfs++] = Ch; // Do the next byte... DataOfs++; } // Terminate the string Buf[DestOfs] = 0; }

void KernelDC::ConvertToPoints (  MILLIPOINT  , TCHAR *  )  [protected]

INT32 KernelDC::EndASCII85Output (   )

Definition at line 958 of file kerneldc.cpp. { // Are we useing RLE compression? if (RLEtheASCII85Data) { // Ok - end of data, so we add the RLE EOD marker to the buffer (byte value 128) BYTE EOD[2]; EOD[0] = (BYTE) 128; if (!QueueASCII85Data(EOD, 1)) // An error occured return -1; } // Flush out the buffer, padding with zeroes if necessary. INT32 nBytes = FlushASCII85Buffer(); // End of ASCII85 data, so output the ASCII85 EOD marker. TCHAR EOD[] = _T("~>"); OutputTCHARAsChar(EOD, 2); OutputNewLine(); // Free up the buffers CCFree(RawBuf); CCFree(A85Buf); RawBuf = NULL; A85Buf = NULL; RawBufSize = 0; RLEtheASCII85Data = FALSE; // Tell caller how many byts we saved return nBytes; }

INT32 KernelDC::FlushASCII85Buffer (   )  [protected]

Definition at line 1312 of file kerneldc.cpp. { INT32 ConvertedLength = ConvertToASCII85(RawBuf, RawBufSize, A85Buf); #ifdef _DEBUG // Let's just check that it was encoded corrrectly. // (NOTE: I allocate 4 bytes more than necessary because ConvertFromASCII85 may // write an extra terminator byte past the end of the buffer memory) BYTE *Dest = (BYTE *) CCMalloc(RawBufSize + 4); if (Dest == NULL) // Error - no more memory return -1; INT32 nBytes = KernelDC::ConvertFromASCII85(A85Buf, ConvertedLength, Dest); ERROR2IF(nBytes < 0, -1, "Error in decoding ASCII85 data"); // Length check if (nBytes != (INT32) RawBufSize) ERROR3("Length of decoded ASCII85 data does not match original! Output may be corrupt"); // Binary comparison if (memcmp(RawBuf, Dest, RawBufSize) != 0) ERROR3("Decoded ASCII85 data does not match original! Output may be corrupt"); // Clean up. CCFree(Dest); #endif RawBufSize = 0; if (!OutputDirect(A85Buf, ConvertedLength)) { // Error return -1; } // All ok return ConvertedLength; }

DocCoord KernelDC::GetOrigin (   )  [inline]

Definition at line 162 of file kerneldc.h. { return Origin; }

virtual Filter* KernelDC::GetParentFilter (   )  [inline, virtual]

Reimplemented in ExportDC. Definition at line 187 of file kerneldc.h. { return NULL; }

BOOL KernelDC::OutputArray (  INT32 *  Array, INT32  ArraySize )

Output an Array to the EPS stream. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/95 Parameters: Array,pointer  to the array data. [INPUTS] ArraySize, the number of elements in the array. Returns: TRUE if the data was written ok; FALSE if not => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 762 of file kerneldc.cpp. { // Output the 'ArrayStart' if (!OutputToken(_T("["))) return FALSE; // Output the actual array elements for (INT32 el = 0; el < ArraySize; el++) { if(!OutputUserSpaceValue(Array[el])) return FALSE; } // Output the 'ArrayEnd' if (!OutputToken(_T("]"))) return FALSE; return TRUE; }

INT32 KernelDC::OutputASCII85 (  BYTE *  Data, UINT32  Length )

Outputs a sequence of bytes as ASCII85 hex data, as used by PostScript Level 2. (This encoding should not be used when generating PostScript that must be compatible with Level 1 interpreters). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/95 Parameters: Data  - pointer to the data to output. [INPUTS] Length - the number of bytes to output. RunLengthEncode - if TRUE then run length encode the data before encoding it to ASCII85 format (see Red Book for RLE spec). Returns: The number of bytes output to the file, in terms of the source data, not in terms of the number of ASCII characters used to represent them. -1 => error occured while writing => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 1011 of file kerneldc.cpp. { // Sanity check ERROR2IF(RawBuf == NULL, FALSE, "ASCII85 output not initialised correctly!"); // Run length encode the data first if required by the caller. BYTE *pRLLBuf = NULL; if (RLEtheASCII85Data) { // Encode this data using run length encoding. INT32 NewLength = Length; pRLLBuf = KernelDC::RunLengthEncode(Data, &NewLength); if (pRLLBuf == NULL) // Error encoding data return -1; #ifdef _DEBUG // Debug check - let's just decompress that data to make sure it was encoded ok! INT32 DecodedLength = NewLength; BYTE *Decoded = RunLengthDecode(pRLLBuf, &DecodedLength); // Check for data equality BOOL ValidEncoding = (DecodedLength == (INT32) Length); if (ValidEncoding) // Perform byte-wise comparison of data ValidEncoding = (memcmp(Data, Decoded, Length) == 0); // De-allocate the decoding buffer CCFree(Decoded); ERROR2IF(!ValidEncoding, -1, "Error in RunLengthEncoding integrity check!"); #endif // Point ASCII85 routine to the RLL encoded data Data = pRLLBuf; Length = NewLength; } INT32 nBytes = -1; // Start this chunk on a new line. if (LineWidth > 0) { if (!OutputNewLine()) { // Error encountered if (RLEtheASCII85Data) CCFree(pRLLBuf); return -1; } } // Queue up the data (which may or may not be RLL encoded). if (QueueASCII85Data(Data, Length)) // Data queued successfully. nBytes = Length; // Free up the buffer used for run length encoding. if (RLEtheASCII85Data) CCFree(pRLLBuf); // All done return nBytes; }

BOOL KernelDC::OutputColour (  PColourCMYK *  pCol  )

Output a colour, as expressed by the Camelot 'Colour' class. This function takes the CMYK variation, is this is most appropriate to EPS files. Camelot colour values are converted from the 0-255 range to the 0.0-1.0 range before being output. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: Col  - the CMYK colour values to be output. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 e.g. MonoOn PColourCMYK Col = { 255, 255, 128, 0 }; pDC->OutputColour(&Col); MonoOff will give the following output: MonoOn 1.0 1.0 0.5 0.0 MonoOff See also: KernelDC::OutputColourValue Returns: Errors: Disk/file error => ERROR1 Definition at line 395 of file kerneldc.cpp. { // Output each of the colour values. BOOL Ok = (OutputColourValue(pCol->Cyan) && OutputColourValue(pCol->Magenta) && OutputColourValue(pCol->Yellow) && OutputColourValue(pCol->Key)); // Return success or failure. return Ok; }

BOOL KernelDC::OutputColourName (  DocColour *  pCol  )

Outputs a named colour's name as a string. If pCol does not reference an indexed colour, then the name "NoName" is used. This was seperated from OutputNamedColour so that the DeviceContext will not need to worry about which ColourModel to use (CMYK, RGB, etc...), as this will be determined by the RenderRegion. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/00 Parameters: pCol  - the colour to output. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 See also: KernelDC::OutputNamedColour Returns: Errors: Disk/file error => ERROR1 Definition at line 491 of file kerneldc.cpp. { // Success / Failure flag for the export of this colour's name. BOOL ok = TRUE; // Get the indexed colour from the DocColour. IndexedColour *pIndCol = pCol->FindParentIndexedColour(); if (pIndCol == NULL) { if (pCol->IsTransparent()) { // This is a 'no colour' type colour, so output a zero-length colour name, // as this is the only way we can handle this at the moment. ok = OutputString(_T("")); } else { // Otherwise make up a colour name (see epsfiltr.h). ok = OutputString(ImmediateColourFudgeyBodgeName); } } else { // Got an indexed colour - output its name // (Pass in TRUE to get a unique-identifier for local colours rather than "Local colour") String_64 *ColName = pIndCol->GetName(TRUE); ok = OutputString((TCHAR *) (*ColName)); } return ok; }

BOOL KernelDC::OutputColourValue (  UINT32  n  )

Output a colour value to the export file. A 'colour value' is a value as used in the Camelot 'Colour' class, i.e. in the range 0 to 255. This range is converted to the range 0.0 to 1.0, and output to the file. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: n  - the colour value (range 0-255) to write to the EPS file. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 See also: KernelDC::OutputColour Returns: Errors: Disk/file error => ERROR1 Definition at line 354 of file kerneldc.cpp. { // Convert to points, getting integer and fractional parts INT32 Integer = n / 255; INT32 Fraction = ((n % 255) * 100) / 255; // Output to string TCHAR Buf[20]; // Ensure we always get at least 2 decimal figures with %.2d camSprintf(Buf, _T("%d.%.2d"), Integer, Abs(Fraction)); return OutputToken(Buf); }

BOOL KernelDC::OutputCoord (  DocCoord &  Coord, EPSAccuracy  Accuracy = ACCURACY_NORMAL )  [virtual]

Write out a coordinate x,y pair to the export file, automatically converting from spread coordinates to the EPS user space coordinate system, including adjusting the origin. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: Coord  - the coordinate to write out to the file. [INPUTS] Accuracy - optional parameter - specifies how numbers should be output: ACCURACY_NORMAL: 2dp ACCURACY_ROUNDUP: 0dp, rounded up ACCURACY_ROUNDDOWN: 0dp, rounded down. Returns: TRUE if the data was written ok; FALSE if not => ERROR1 See also: KernelDC::OutputUserSpaceValue Returns: Errors: File/disk error => ERROR1 Reimplemented in PSPrintDC. Definition at line 219 of file kerneldc.cpp. { BOOL Ok = (OutputUserSpaceValue(Coord.x - Origin.x, Accuracy) && OutputUserSpaceValue(Coord.y - Origin.y, Accuracy)); return Ok; }

BOOL KernelDC::OutputDirect (  BYTE *  , INT32  )  [virtual]

Send bytes directly to the PostScript stream with no alteration or padding. Used for sending binary/hex data to stream. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/23/95 Parameters: Buf  - the bytes to send to the stream. [INPUTS] nBytes - the number of bytes to send to the stream. Returns: FALSE (see Purpose) NB. This base class version will always raise an ERROR2 and return FALSE because this function must be over-ridden in order to use the output functions. See also: KernelDC::OutputNewLine; KernelDC::OutputToken Returns: Errors: Always => ERROR2 Reimplemented in EPSExportDC, and PSPrintDC. Definition at line 1662 of file kerneldc.cpp. { ERROR2(FALSE, "OutputDirect() called for base class KernelDC"); }

BOOL KernelDC::OutputFloat (  const double  Value, const UINT32  DecPl )

Output a real (floating point) number to the EPS stream. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/04/95 Parameters: Value  - the number to write to the EPS stream. [INPUTS] DecPl - the number of decimal places to output. (1..8) Returns: TRUE if the data was written ok; FALSE if not => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 700 of file kerneldc.cpp. { TCHAR buf[100]; TCHAR *pch=buf; INT32 len=0, dp=-1; switch (DecPl) { case 1: camSprintf(buf,_T("%.1f"),Value); break; case 2: camSprintf(buf,_T("%.2f"),Value); break; case 4: camSprintf(buf,_T("%.4f"),Value); break; case 5: camSprintf(buf,_T("%.5f"),Value); break; case 6: camSprintf(buf,_T("%.6f"),Value); break; case 7: camSprintf(buf,_T("%.7f"),Value); break; case 8: camSprintf(buf,_T("%.8f"),Value); break; default:camSprintf(buf,_T("%.3f"),Value); break; } // supress a few trailing zero's while (*pch != '\0') { if (*pch=='.') dp=len; len++; pch++; } // check no decimal place if (dp==-1) return OutputToken(buf); pch--; while ((len>0) && (*pch=='0')) { pch--; len--; } if ((len==0) || (*pch=='.')) pch++; pch++; *pch='\0'; return OutputToken(buf); }

BOOL KernelDC::OutputMatrix (  Matrix *  M  )

Output a Matrix to the EPS stream. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: M-  pointer to the matrix to output to the EPS stream. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 591 of file kerneldc.cpp. { FIXED16 abcd[4]; INT32 ef[2]; M->GetComponents(abcd, ef); if(!OutputReal(abcd[0].MakeDouble())) return FALSE; if(!OutputReal(abcd[1].MakeDouble())) return FALSE; if(!OutputReal(abcd[2].MakeDouble())) return FALSE; if(!OutputReal(abcd[3].MakeDouble())) return FALSE; if(!OutputUserSpaceValue(ef[0])) return FALSE; if(!OutputUserSpaceValue(ef[1])) return FALSE; return TRUE; }

BOOL KernelDC::OutputNamedColour (  DocColour *  pCol, ColourContext *  pContext = NULL )

Similar to OutputColour(), except it outputs the colour name and tint of the colour as well. If pCol does not reference an indexed colour, then the name "NoName" is used. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 09/08/94 Parameters: pCol  - the colour to output. [INPUTS] pContext - the context to use to convert the colour before output. if this is NULL the default CMYK context will be used. Returns: TRUE if the data was written ok; FALSE if not => ERROR1 See also: KernelDC::OutputColour Returns: Errors: Disk/file error => ERROR1 Definition at line 426 of file kerneldc.cpp. { // Get CMYK version of this colour. PColourCMYK CMYK; pCol->GetCMYKValue(pContext, &CMYK); // Output CMYK version if (!OutputColour(&CMYK)) return FALSE; // Get the indexed colour from the DocColour. IndexedColour *pIndCol = pCol->FindParentIndexedColour(); // Cope with the unexpected! // ENSURE(pIndCol != NULL, "Named colour has no index colour!"); if (pIndCol == NULL) { if (pCol->IsTransparent()) { // This is a 'no colour' type colour, so output a zero-length colour name, // as this is the only way we can handle this at the moment. if (!OutputString(_T(""))) return FALSE; } else { // Otherwise make up a colour name (see epsfiltr.h). if (!OutputString(ImmediateColourFudgeyBodgeName)) return FALSE; } } else { // Got an indexed colour - output its name // (Pass in TRUE to get a unique-identifier for local colours rather than "Local colour") String_64 *ColName = pIndCol->GetName(TRUE); if (!OutputString((TCHAR *) (*ColName))) return FALSE; } // Always tint 0 return OutputToken(_T("0")); }

BOOL KernelDC::OutputNewLine (   )  [virtual]

Causes a new line to be started in the EPS/PS output. This is used to give a pleasant appearance to the file - most EPS/PS commands (as opposed to operands) are followed by a new line. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Returns: FALSE (see Purpose) NB. This base class version will always raise an ERROR2 and return FALSE because this function must be over-ridden in order to use the output functions. See also: KernelDC; KernelDC::OutputToken Returns: Errors: Always => ERROR2 Reimplemented in EPSExportDC, and PSPrintDC. Definition at line 1599 of file kerneldc.cpp. { ERROR2(FALSE, "OutputNewLine() called for base class KernelDC"); }

INT32 KernelDC::OutputRawBinary (  BYTE *  Data, UINT32  Length, UINT32  Alignment = 1 )  [virtual]

Outputs a sequence of bytes as raw hex data, as used by PostScript operators such as readhexstring. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: Data  - pointer to the data to output. [INPUTS] Length - the number of bytes to output. Alignment - the byte alignment to use - it will pad the end of the data with 0 bytes if Length is not divisible by this parameter. Hence use 1 for no padding. Returns: The number of bytes output to the file, in terms of the source data, not in terms of the number of ASCII characters used to represent them. -1 => error occured while writing => ERROR1 Errors: Disk/file error => ERROR1 Reimplemented in NativeExportDC. Definition at line 802 of file kerneldc.cpp. { INT32 nBytes = 0; // Do 30 bytes at a time so we get lines with 60 characters on each. if (LineWidth > 0) { if (!OutputNewLine()) // Error encountered return -1; } // Work out the padding needed ENSURE(Alignment != 0, "Bad alignment in OutputRawBinary!"); UINT32 Padding = Alignment - (Length % Alignment); if (Padding == Alignment) Padding = 0; while (Length > 0) { // Work out how much data to output UINT32 ChunkLength = 32; if (Length < ChunkLength) ChunkLength = Length; // Convert the next chunk to hex and write it out TCHAR HexBuf[80]; ConvertToHex(Data, ChunkLength, HexBuf); if (!OutputTCHARAsChar(HexBuf, ChunkLength * 2)) { // Error return -1; } nBytes += ChunkLength; // Adjust length and check for padding requirements Length -= ChunkLength; Data += ChunkLength; if ((Length == 0) && (Padding > 0)) { // Put the string "00" into HexBuf HexBuf[0] = '0'; HexBuf[1] = '0'; HexBuf[2] = 0; // Output it however many times we need to while (Padding > 0) { if (!OutputTCHARAsChar(HexBuf, 2)) // Error return -1; nBytes++; Padding--; } } if (!OutputNewLine()) // Error encountered return -1; } // All done return nBytes; }

BOOL KernelDC::OutputReal (  double  Value  )

Output a real (floating point) number to the EPS stream. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/11/94 Parameters: Value  - the number to write to the EPS stream. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 672 of file kerneldc.cpp. { TCHAR buf[100]; // 100 should be enough for a floating point number! // Save floating point in scientific notation (because otherwise the number output // could be very long, e.g. 6.2e66 or similar would be very long if we didn't use // the exponent syntax). camSprintf(buf, _T("%g"), Value); return OutputToken(buf); }

BOOL KernelDC::OutputString (  TCHAR *  pString  )

Output a string in PostScript format, i.e. delimited by '(' and ')', and escaping any parentheses so the string is syntactically correct. e.g. "String" is output as "(String)", and "Hello (there)" is output as "(Hello \(there\))" and so on. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/94 Parameters: pString  - the string token to output. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 See also: KernelDC Returns: Errors: Disk/file error => ERROR1 Definition at line 544 of file kerneldc.cpp. { TCHAR Buf[128]; // Open string delimiter Buf[0] = '('; // Copy the string, looking for embedded delimiters. INT32 src = 0, dst = 1; while ( (pString[src]) && (dst < 120 ) ) //while ((pString[src] != 0) && (dst < 120))-adapted for DBCS { if( (pString[src]== _T('(')) || (pString[src]==_T(')')) || (pString[src]== _T('\\')) ) //if( (pString[src] == '(') || (pString[src] == ')') || (pString[src] == '\\') )-adapted for DBCS { // escape this delimiter Buf[dst++] = '\\'; } // Copy this character Buf[dst++] = pString[src++]; } ERROR3IF(dst > 120, "String too long in KernelDC::OutputString"); // Terminate the string token Buf[dst++] = ')'; Buf[dst] = 0; // Output it return OutputToken(Buf); }

BOOL KernelDC::OutputTCHARAsChar (  TCHAR *  Buf, INT32  nBytes )  [virtual]

Send bytes directly to the PostScript stream with no alteration or padding. Used for sending binary/hex data to stream. We send the BYTE equal to the TCHAR with no conversion. Author: Alex Bligh Date: 13/06/2006 Parameters: Buf  - the bytes to send to the stream. [INPUTS] nBytes - the number of bytes to send to the stream (i.e the number of TCHARs to read) Returns: TRUE if all the bytes were sent ok; FALSE if not. See also: KernelDC::OutputNewLine; KernelDC::OutputToken Definition at line 1687 of file kerneldc.cpp. { if (sizeof(TCHAR) == sizeof(char)) return OutputDirect((BYTE *)Buf, nBytes); BYTE * pByte=new BYTE[nBytes]; if (!pByte) return FALSE; INT32 i; for (i=0; i<nBytes; i++) pByte[i]=Buf[i]; // 1:1 copy BOOL ok=OutputDirect(pByte, nBytes); delete (pByte); return ok; }

BOOL KernelDC::OutputToken (  TCHAR *  Str  )  [virtual]

Outputs a string token to the EPS/PS stream. This is the central routine through which the other high-level routines eventually come. The other routines convert their output to a string, which they then pass on to this routine. A record is kept of the current line width - if it is over 70 characters wide before the token is output, then a new line is output to keep the lines in the EPS file reasonably short. For this reason, it is important not to output strings that contain newline characters, because this routine will not notice, and hence the LineWidth count will be wrong. This routine also ensures that tokens are separated by either a space or a newline, so it is not necessary to output spaces directly to keep the tokens separate - it happens automatically. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: Str  - the character string to write to the stream. [INPUTS] Returns: FALSE (see Purpose) NB. This base class version will always raise an ERROR2 and return FALSE because this function must be over-ridden in order to use the output functions. See also: KernelDC; KernelDC::OutputNewLine; KernelDC::OutputDirect Returns: Errors: Always => ERROR2 Reimplemented in EPSExportDC, and PSPrintDC. Definition at line 1635 of file kerneldc.cpp. { ERROR2(FALSE, "OutputToken() called for base class KernelDC"); }

BOOL KernelDC::OutputUserSpaceValue (  MILLIPOINT  n, EPSAccuracy  Accuracy = ACCURACY_NORMAL )  [virtual]

Output a 'user space' value to the export file. User space is the coordinate system used for EPS files (and more generally, PostScript programs). For Illustrator-based EPS, the user space is expressed in units of points, and usually has the origin at (0.0). By default, we follow the Illustrator convention of truncating values to 2dp (so we can generate files compatible with Illustrator etc), but Camelot EPS uses the full 3dp accuracy (we don't store more any accuracy than this internally). The accuracy can be changed by calling KernelDC::SetFullAccuracy Note that this routine does not do origin translation, because it may be used for dimensions such as line widths, which have no earthly use for origins (and anyway, it's a bit tricky to do origin translation with only one dimension!). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: n  - the value (in millipoints) to output. [INPUTS] Accuracy - optional parameter - specifies how numbers should be output: ACCURACY_NORMAL: 2dp, or 3dp (see KernelDC::SetFullAccuracy) ACCURACY_ROUNDUP: 0dp, rounded up ACCURACY_ROUNDDOWN: 0dp, rounded down. Returns: TRUE if the data was written ok; FALSE if not => ERROR1 e.g. OutputUserSpaceValue(31465) will output "3.147" to the export file. See also: KernelDC::OutputCoord; KernelDC::OutputToken; KernelDC::SetFullAccuracy Returns: Errors: Disk/file error => ERROR1 Reimplemented in PSPrintDC. Definition at line 265 of file kerneldc.cpp. { TCHAR Buf[20]; INT32 Integer; INT32 Fraction; const TCHAR * negative=_T("-"); const TCHAR * positive=_T(""); const TCHAR * sign = positive; // Convert millipoint to EPS user space value in desired format. switch (Accuracy) { case ACCURACY_NORMAL: // Convert to points, getting integer and fractional parts // invert the sign if necessary if (n<0) { sign=negative; n=-n; } // as n is positive (or zero), this works in the way expected. Both // Integer and fraction are >=0 too. Integer = n / 1000; Fraction = n % 1000; // Output to string (accurate to 2/3dp) // If fraction is 0, just output integer value. if (Fraction == 0) { camSprintf(Buf, _T("%d"), Integer); } else if (FullAccuracy) { camSprintf(Buf, _T("%s%d.%.3d"), sign, Integer, Fraction); } else { // Normal 2dp accuracy Fraction=(Fraction+5)/10; camSprintf(Buf, _T("%s%d.%.2d"), sign, Integer, Fraction); } break; case ACCURACY_ROUNDDOWN: // Convert to points, getting integer part. if (n < 0) Integer = (n - 999)/ 1000; else Integer = (n) / 1000; // Output to string (accurate to 0dp) camSprintf(Buf, _T("%d"), Integer); break; case ACCURACY_ROUNDUP: // Convert to points, getting integer part. if (n < 0) Integer = (n) / 1000; else Integer = (n + 999) / 1000; // Output to string (accurate to 0dp) camSprintf(Buf, _T("%d"), Integer); break; } return OutputToken(Buf); }

BOOL KernelDC::OutputValue (  UINT32  Value  )

Output an unsigned integer to the EPS stream. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: Value  - the number to write to the EPS stream. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 650 of file kerneldc.cpp. { TCHAR buf[30]; camSprintf(buf, _T("%u"), Value); return OutputToken(buf); }

BOOL KernelDC::OutputValue (  INT32  Value  )

Output a signed integer to the EPS stream. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: Value  - the number to write to the EPS stream. [INPUTS] Returns: TRUE if the data was written ok; FALSE if not => ERROR1 Errors: Disk/file error => ERROR1 Definition at line 629 of file kerneldc.cpp. { TCHAR buf[30]; camSprintf(buf, _T("%d"), Value); return OutputToken(buf); }

BOOL KernelDC::QueueASCII85Data (  BYTE *  Data, UINT32  Length )  [protected]

Definition at line 1082 of file kerneldc.cpp. { INT32 MaxData = A85DataSize * 4; // Keep filling and flushing the buffer until we are out of data to send. INT32 nBytes = Length; while (nBytes > 0) { ERROR2IF((INT32) RawBufSize > MaxData, FALSE, "ASCII85 buffer overflow!"); if ((INT32) RawBufSize == MaxData) { // Buffer is full - encode it and write it to disk. if (FlushASCII85Buffer() == -1) return FALSE; } // Put as much data into the buffer as possible INT32 SpaceLeft = MaxData - RawBufSize; if (nBytes > SpaceLeft) { // Not enough room to put it all in, so fill up the buffer memcpy(RawBuf + RawBufSize, Data, SpaceLeft); RawBufSize += SpaceLeft; Data += SpaceLeft; nBytes -= SpaceLeft; } else { // Enough room in buffer to put all the data in, so do it. memcpy(RawBuf + RawBufSize, Data, nBytes); RawBufSize += nBytes; nBytes = 0; } } // All ok return TRUE; }

BYTE * KernelDC::RunLengthDecode (  BYTE *  Data, INT32 *  Length )  [protected]

Definition at line 1459 of file kerneldc.cpp. { // Ok, scan the data to see how large it will expand to. INT32 i = 0; INT32 Length = *pLength; INT32 Size = 0; BOOL FoundEOD = FALSE; while (i < Length) { if (Data[i] <= 127) { // Straight copying of data Size += (Data[i] + 1); // Skip past the data i += (Data[i] + 2); } else if (Data[i] > 128) { // Repeated data Size += (257 - Data[i]); // Skip past repeat count and byte to repeat. i += 2; } else { // 128 == End of stream FoundEOD = TRUE; break; } } // Got the size of data stream - allocate a buffer. if (Size == 0) { // Something not right here - cope with it gracefully *pLength = 0; return NULL; } // Allocate a buffer. Allocate 4 bytes extra just in case of slight buffer overruns BYTE *pRLLBuf = (BYTE *) CCMalloc(Size + 1 + 4); if (pRLLBuf == NULL) { // Error - no memory *pLength = 0; return NULL; } // Ok, actually decode it now. INT32 j = 0; i = 0; FoundEOD = FALSE; while (i < Length) { if (Data[i] <= 127) { // Straight copying of data memcpy(pRLLBuf + j, Data + i + 1, Data[i] + 1); // Skip past the data j += (Data[i] + 1); i += (Data[i] + 2); } else if (Data[i] > 128) { // Repeated data memset(pRLLBuf + j, Data[i + 1], 257 - Data[i]); // Skip past repeat count and byte to repeat. j += (257 - Data[i]); i += 2; } else { // 128 == End of stream FoundEOD = TRUE; break; } } // Sanity checks if (j!=Size) { *pLength=0; ERROR2(NULL, "Incorrect decoding of Run length data"); } // Ok, we've decoded it. *pLength = j; return pRLLBuf; }

BYTE * KernelDC::RunLengthEncode (  BYTE *  Data, INT32 *  Length )  [protected]

Definition at line 1354 of file kerneldc.cpp. { // Run length encode the data first if required by the caller. BYTE *pRLLBuf = NULL; // Work out how much space we will need (i.e. work out the worst case overhead for // run length encoding). // This is based on no repetition at all, i.e. no opportunity for compression. // This results in a one byte overhead per 128 bytes. INT32 Length = *pLength; INT32 Overhead = (Length / 128) + 10; // Add 10 for good measure! No GPFs here... // Get a buffer to convert the data in. Allocate 4 byes extra just to be safe INT32 RLLSize = Length + Overhead; pRLLBuf = (LPBYTE) CCMalloc(RLLSize + 4); if (pRLLBuf == NULL) // Error; return NULL; // Ok - we've got the buffer, so encode the data. // We don't bother to RLL unless we get a gain, i.e. 3 or more repeating characters. // (2 repeating bytes gives the same space usage, and can interrupt the stream so // actually uses more space). INT32 SeqLength = 0; INT32 DestOfs = 0; INT32 SrcOfs = 0; INT32 Ofs = 0; INT32 Len = Length; while (Len > 0) { // Check for limit on sequence length. ERROR2IF(SeqLength > 128, NULL, "Sequence too long in RLE encoding!"); if (SeqLength == 128) { // Got a full sequence - copy it to the destination buffer. ERROR2IF(DestOfs + SeqLength >= RLLSize, NULL, "RLE buffer over-run!"); pRLLBuf[DestOfs++] = SeqLength - 1; memcpy(pRLLBuf + DestOfs, Data + SrcOfs, SeqLength); DestOfs += SeqLength; SrcOfs += SeqLength; SeqLength = 0; } // Look for repeating characters if ((Len > 2) && (Data[Ofs] == Data[Ofs + 1]) && (Data[Ofs] == Data[Ofs + 2])) { // Ooh - found 3 repeating characters - see if there are any more. // First flush out any previous bytes. if (SeqLength > 0) { ERROR2IF(DestOfs + SeqLength >= RLLSize, NULL, "RLE buffer over-run!"); pRLLBuf[DestOfs++] = SeqLength - 1; memcpy(pRLLBuf + DestOfs, Data + SrcOfs, SeqLength); DestOfs += SeqLength; } // Sequence starts at this character. SrcOfs = Ofs; SeqLength = 0; while ((Len > 0) && (SeqLength < 128) && (Data[Ofs] == Data[SrcOfs])) { // Try next character Len--; Ofs++; SeqLength++; } // End of sequence of repeating characters - place it into buffer. ERROR2IF(DestOfs + 2 > RLLSize, NULL, "RLE buffer over-run!"); pRLLBuf[DestOfs++] = 257 - SeqLength; pRLLBuf[DestOfs++] = Data[SrcOfs]; // Move to next character //Ofs++; SeqLength = 0; SrcOfs = Ofs; } else { // Add this character to the current sequence. Len--; Ofs++; SeqLength++; } } // Flush remaining sequence, if there is one. if (SeqLength > 0) { ERROR2IF(DestOfs + SeqLength >= RLLSize, NULL, "RLE buffer over-run!"); pRLLBuf[DestOfs++] = SeqLength - 1; memcpy(pRLLBuf + DestOfs, Data + SrcOfs, SeqLength); DestOfs += SeqLength; } // Return the pointer to the RLL encoded data, and tell caller how long the data is. *pLength = DestOfs; return pRLLBuf; }

void KernelDC::SetFullAccuracy (  BOOL  Full  )

Change the accuracy used when saving out user space values to the EPS file. This defaults to 2dp, but can be enabled to full accuracy (3dp) by passing in TRUE. We still do 2dp because that is what Illustrator and most of the other mediocre programs use and we don't want to generate files that might upset them. Camelot EPS uses the full 3dp accuracy though. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: Full,:  TRUE => Use 3dp when saving user space values [INPUTS] FALSE => Use 2dp when saving user space values Definition at line 1573 of file kerneldc.cpp. { FullAccuracy = Full; }

void KernelDC::SetOrigin (  DocCoord &  NewOrigin  )

Set the user space origin to the specified position in spread coordinates. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/03/94 Parameters: NewOrigin  - the desired origin (in spread coords) [INPUTS] See also: KernelDC::OutputUserSpaceValue; KernelDC::OutputCoord Definition at line 193 of file kerneldc.cpp. { Origin = NewOrigin; }

BOOL KernelDC::StartASCII85Output (  BOOL  RunLengthEncode = FALSE  )

Definition at line 928 of file kerneldc.cpp. { // Sanity check ERROR2IF(A85Buf != NULL, FALSE, "Unfinished ASCII85 output!"); // Remember whether or not we need to RLE the data. RLEtheASCII85Data = RunLengthEncode; // Allocate buffers // (Jason here - NOTE that I add a 4 byte padding to the end of both buffers in case // of small overflow. Otherwise, the ConvertToASCII85 routine fills the buffer to the // brim and then slaps a 0 terminator on the end, corrupting the heap) RawBuf = (LPBYTE) CCMalloc((A85DataSize * 4) + 4); if (RawBuf == NULL) return(FALSE); A85Buf = (LPBYTE) CCMalloc((A85DataSize * 5) + 4); if (A85Buf == NULL) { CCFree(RawBuf); return(FALSE); } // No characters in buffer yet. RawBufSize = 0; // Ok return TRUE; }

---

Member Data Documentation

LPBYTE KernelDC::A85Buf [protected]

Definition at line 214 of file kerneldc.h.

BOOL KernelDC::FullAccuracy [protected]

Definition at line 208 of file kerneldc.h.

UINT32 KernelDC::LineWidth [protected]

Definition at line 202 of file kerneldc.h.

DocCoord KernelDC::Origin [protected]

Definition at line 205 of file kerneldc.h.

LPBYTE KernelDC::RawBuf [protected]

Definition at line 214 of file kerneldc.h.

UINT32 KernelDC::RawBufSize [protected]

Definition at line 215 of file kerneldc.h.

BOOL KernelDC::RLEtheASCII85Data [protected]

Definition at line 216 of file kerneldc.h.

---

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

• Kernel/kerneldc.h (r1785/r1354)
• Kernel/kerneldc.cpp (r1785/r1432)

---