//--------------------------------------------------------------------//
// M e t h o d //
// c h e c k S y m S e t F i l e //
//--------------------------------------------------------------------//
// //
// Check symbol set file to see if it starts with a 'symbol set //
// identifier' sequence; if so, return the identifier and first and //
// last code-point values. //
// The symbol set map id stored in the special 'user-defined' symbol //
// set instance. //
// //
// TODO perhaps we ought to check that symbol set control (make //
// permanent) is also present? //
// //
//--------------------------------------------------------------------//
public static Boolean checkSymSetFile(
String filename,
ref UInt16 symSetNo,
ref UInt16 firstCode,
ref UInt16 lastCode,
ref PCLSymSetTypes.eIndex symSetType)
{
Boolean flagOK = true;
Boolean fileOpen = false;
Int64 fileSize = 0,
offset = 0;
//----------------------------------------------------------------//
// //
// Read file to obtain characteristics. //
// //
//----------------------------------------------------------------//
fileOpen = symSetFileOpen(filename, ref fileSize);
if (!fileOpen)
{
flagOK = false;
MessageBox.Show("Unable to open symbol set definition" +
" file '" + filename + "'",
"Symbol Set file invalid",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
else
{
firstCode = 0;
lastCode = 0;
flagOK = readSymSetId(fileSize,
ref offset,
ref symSetNo);
if (!flagOK)
{
MessageBox.Show("Symbol set definition" +
" file '" + filename + "':\r\n\r\n" +
"File does not start with" +
" 'symbol set Id' escape sequence",
"Symbol Set file invalid",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
else
{
Byte symSetFormat = 0;
Byte symSetTypeId = 0;
flagOK = readSymSetHddr(filename,
fileSize,
symSetNo,
ref symSetFormat,
ref symSetTypeId,
ref offset,
ref firstCode,
ref lastCode);
if (!flagOK)
{
MessageBox.Show("Symbol set definition" +
" file '" + filename + "':\r\n\r\n" +
"Header is invalid",
"Symbol Set file invalid",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
else
{
flagOK = readAndStoreSymSetMap(offset,
symSetNo,
firstCode,
lastCode);
if (!flagOK)
{
MessageBox.Show("Symbol set definition" +
" file '" + filename + "':\r\n\r\n" +
"Mapping data is invalid",
"Symbol Set file invalid",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
else
{
symSetType = PCLSymSetTypes.getIndexForIdPCL(symSetTypeId);
}
}
}
symSetFileClose();
}
return(flagOK);
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e n e r a t e S y m S e t //
//--------------------------------------------------------------------//
// //
// Generate symbol set definition. //
// //
//--------------------------------------------------------------------//
public Boolean generateSymSet(ref String symSetFilename,
Boolean flagIgnoreC0,
Boolean flagIgnoreC1,
UInt16 symSetNo,
UInt16 codeMin,
UInt16 codeMax,
UInt64 charCollReq,
UInt16 [] symSetMap,
PCLSymSetTypes.eIndex symSetType)
{
Boolean flagOK = true;
//----------------------------------------------------------------//
// //
// Open print file and stream. //
// //
//----------------------------------------------------------------//
try
{
streamOpen(ref symSetFilename,
ref _binWriter,
ref _opStream);
}
catch (Exception exc)
{
flagOK = false;
MessageBox.Show(exc.ToString(),
"Failure to open symbol set file",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
if (flagOK)
{
//------------------------------------------------------------//
// //
// Generate symbol set file contents. //
// //
//------------------------------------------------------------//
try
{
//--------------------------------------------------------//
// //
// Write symbol set identifier sequence. //
// //
//--------------------------------------------------------//
PCLWriter.symSetDownloadCode(_binWriter,
(UInt16)symSetNo);
//--------------------------------------------------------//
// //
// Write symbol set descriptor header. //
// //
//--------------------------------------------------------//
writeHddr(symSetNo, codeMin, codeMax, charCollReq,
PCLSymSetTypes.getIdPCL((Int32)symSetType));
//--------------------------------------------------------//
// //
// Write symbol set map data. //
// //
//--------------------------------------------------------//
writeMapData(flagIgnoreC1, codeMin, codeMax, symSetMap);
//--------------------------------------------------------//
// //
// Write symbol set save sequence. //
// //
//--------------------------------------------------------//
PCLWriter.symSetDownloadSave(_binWriter, true);
//--------------------------------------------------------//
// //
// Close streams and files. //
// //
//--------------------------------------------------------//
_binWriter.Close();
_opStream.Close();
}
catch (Exception exc)
{
flagOK = false;
MessageBox.Show(exc.ToString(),
"Failure to write symbol set file",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
return(flagOK);
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e t F o n t S e l e c t i o n D a t a //
//--------------------------------------------------------------------//
// //
// Read font selection characteristics from PCL soft font descriptor. //
// //
//--------------------------------------------------------------------//
private static Boolean getFontSelectionData(
Int32 hddrOffset,
Int32 hddrLen,
ref Boolean proportional,
ref Boolean scalable,
ref Boolean bound,
ref Double pitch,
ref Double height,
ref UInt16 style,
ref Int16 weight,
ref UInt16 typeface,
ref UInt16 symSetNo,
ref PCLSymSetTypes.eIndex symSetType)
{
Boolean OK = true;
UInt16 hddrDescLen;
Byte[] hddr;
Boolean bitmapFont = false;
UInt16 dotResX,
dotResY;
Byte[] buf = new Byte[2];
_ipStream.Seek(hddrOffset, SeekOrigin.Begin);
_binReader.Read(buf, 0, 2);
hddrDescLen = (UInt16)((buf[0] << 8) + buf[1]);
hddr = new Byte[hddrDescLen]; // if universal bitmap, want whole header read, inclduing segments
_ipStream.Seek(hddrOffset, SeekOrigin.Begin);
_binReader.Read(hddr, 0, hddrDescLen);
//----------------------------------------------------------------//
ePCLFontFormat hddrFormat;
hddrFormat = (ePCLFontFormat)hddr[2];
switch (hddrFormat)
{
case ePCLFontFormat.Bitmap:
bitmapFont = true;
break;
case ePCLFontFormat.BitmapResSpec:
bitmapFont = true;
break;
case ePCLFontFormat.IntellifontBound:
// intelliFont = true;
break;
case ePCLFontFormat.IntellifontUnbound:
// intelliFont = true;
break;
case ePCLFontFormat.TrueType:
// truetypeFont = true;
break;
case ePCLFontFormat.Universal:
// universalFont = true;
if (hddr[70] == 254) // scaling technology
{
bitmapFont = true;
}
break;
}
//----------------------------------------------------------------//
if (bitmapFont)
{
scalable = false;
}
else
{
scalable = true;
}
//----------------------------------------------------------------//
dotResX = _defaultPCLDotRes;
dotResY = _defaultPCLDotRes;
if (hddrFormat == ePCLFontFormat.Universal)
{
if (bitmapFont) // scaling technology = 254
{
// need to read BR segment to get resolutions
Boolean endSegs = false;
Byte[] segData;
Int32 segDataLen;
Int32 segSize;
Int32 segType;
Int32 offset;
segDataLen = hddrLen - hddrDescLen;
segData = new Byte[segDataLen];
// _ipStream.Seek (hddrOffset, SeekOrigin.Begin); // already at correct position ?
_binReader.Read(segData, 0, segDataLen);
offset = 0;
while (!endSegs)
{
//----------------------------------------------------//
// //
// Segment Type and Length data is in buffer. //
// //
//----------------------------------------------------//
segType = (segData[offset] << 8) +
segData[offset + 1];
segSize = (segData[offset + 2] << 24) +
(segData[offset + 3] << 16) +
(segData[offset + 4] << 8) +
segData[offset + 5];
if ((segType == 0x4252) &&
((offset + 6 + segSize) < hddrLen))
{
// BR
dotResX = (UInt16)((segData[offset + 6] << 8) +
segData[offset + 7]);
dotResY = (UInt16)((segData[offset + 8] << 8) +
segData[offset + 9]);
}
else if (segType == 0xffff)
{
// null
endSegs = true;
}
offset += (6 + segSize);
if ((offset + 6) > hddrLen)
{
endSegs = true;
}
}
}
}
else if (hddrFormat == ePCLFontFormat.BitmapResSpec)
{
dotResX = (UInt16)((hddr[64] << 8) + hddr[65]);
dotResY = (UInt16)((hddr[66] << 8) + hddr[67]);
}
else //if (hddrFormat == PCLSoftFonts.eIdHddrFormat.BitmapResSpec)
{
dotResX = _defaultPCLDotRes;
dotResY = _defaultPCLDotRes;
}
//----------------------------------------------------------------//
symSetType = PCLSymSetTypes.getIndexForIdPCL(hddr[3]);
bound = PCLSymSetTypes.isBound((Int32)symSetType);
//----------------------------------------------------------------//
if (hddr[13] == 0)
{
proportional = false;
}
else
{
proportional = true;
}
//----------------------------------------------------------------//
symSetNo = (UInt16)((hddr[14] << 8) + hddr[15]);
//----------------------------------------------------------------//
if (bitmapFont)
{
UInt16 dotsQtr = 0;
UInt16 dotsExt = 0;
Double dotsK = 0.0;
dotsQtr = (UInt16)((hddr[16] << 8) + hddr[17]);
dotsExt = (UInt16)(hddr[40]);
dotsK = (dotsQtr << 8) + dotsExt;
if ((dotsQtr == 0) && (dotsExt == 0))
{
pitch = 0.0;
}
else
{
dotsK = (dotsQtr << 8) + dotsExt;
pitch = (dotResX << 10) / dotsK;
}
dotsQtr = (UInt16)((hddr[18] << 8) + hddr[19]);
dotsExt = (UInt16)(hddr[41]);
if ((dotsQtr == 0) && (dotsExt == 0))
{
height = 0.0;
}
else
{
dotsK = (dotsQtr << 8) + dotsExt;
height = (dotsK * 72) / (dotResY << 10);
}
}
else
{
pitch = 0.0;
height = 0.0;
}
//----------------------------------------------------------------//
style = (UInt16)((hddr[4] << 8) + hddr[23]);
weight = (Int16)hddr[24];
typeface = (UInt16)((hddr[26] << 8) + hddr[25]);
//----------------------------------------------------------------//
return(OK);
}
