//--------------------------------------------------------------------//
// M e t h o d //
// g e n e r a t e J o b //
//--------------------------------------------------------------------//
// //
// Generate test data. //
// //
// Some sequences are built up as (Unicode) strings, then converted //
// to byte arrays before writing out - this works OK because all the //
// characters we're using are within the ASCII range (0x00-0x7f) and //
// are hence represented using a single byte in the UTF-8 encoding. //
// //
//--------------------------------------------------------------------//
public static void generateJob(BinaryWriter prnWriter,
Int32 indxPaperSize,
Int32 indxPaperType,
Int32 indxOrientation,
Boolean formAsMacro,
UInt32 codePoint,
Int32 indxFont,
PCLFonts.eVariant fontVar)
{
generateJobHeader(prnWriter);
if (formAsMacro)
{
generateOverlay(prnWriter, true,
indxPaperSize, indxOrientation);
}
generatePage(prnWriter,
indxPaperSize,
indxPaperType,
indxOrientation,
formAsMacro,
codePoint,
indxFont,
fontVar);
generateJobTrailer(prnWriter, formAsMacro);
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e n e r a t e J o b //
//--------------------------------------------------------------------//
// //
// Generate test data. //
// //
// Some sequences are built up as (Unicode) strings, then converted //
// to byte arrays before writing out - this works OK because all the //
// characters we're using are within the ASCII range (0x00-0x7f) and //
// are hence represented using a single byte in the UTF-8 encoding. //
// //
//--------------------------------------------------------------------//
public static void generateJob(BinaryWriter prnWriter,
Int32 indxPaperSize,
Int32 indxPaperType,
Int32 indxOrientation,
Boolean formAsMacro,
UInt32 codePoint,
Int32 indxFont,
PCLFonts.eVariant fontVar)
{
PCLOrientations.eAspect aspect;
UInt16 logXOffset;
//----------------------------------------------------------------//
aspect = PCLOrientations.getAspect(indxOrientation);
logXOffset = PCLPaperSizes.getLogicalOffset(indxPaperSize,
_unitsPerInch, aspect);
_logPageWidth = PCLPaperSizes.getLogPageWidth(indxPaperSize,
_unitsPerInch,
aspect);
_logPageHeight = PCLPaperSizes.getLogPageLength(indxPaperSize,
_unitsPerInch,
aspect);
_paperWidth = PCLPaperSizes.getPaperWidth(indxPaperSize,
_unitsPerInch,
aspect);
_paperHeight = PCLPaperSizes.getPaperLength(indxPaperSize,
_unitsPerInch,
aspect);
//----------------------------------------------------------------//
generateJobHeader(prnWriter,
indxPaperSize,
indxPaperType,
indxOrientation,
formAsMacro,
logXOffset);
generatePage(prnWriter,
indxPaperSize,
indxPaperType,
indxOrientation,
formAsMacro,
logXOffset,
codePoint,
indxFont,
fontVar);
generateJobTrailer(prnWriter, formAsMacro);
}
//--------------------------------------------------------------------//
// M e t h o d //
// r b U n i c o d e F o n t V a r R _ C l i c k //
//--------------------------------------------------------------------//
// //
// Called when the 'Regular' font variant radio button is selected. //
// //
//--------------------------------------------------------------------//
private void rbUnicodeFontVarR_Click(object sender, RoutedEventArgs e)
{
if (_crntPDL == ToolCommonData.ePrintLang.PCL)
{
_unicodeFontVarPCL = PCLFonts.eVariant.Regular;
}
else
{
_unicodeFontVarPCLXL = PCLFonts.eVariant.Regular;
}
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e t P C L X L N a m e //
//--------------------------------------------------------------------//
// //
// Return the PCL XL font name for the selected font. //
// //
//--------------------------------------------------------------------//
public String getPCLXLName(PCLFonts.eVariant variant)
{
if (variant == PCLFonts.eVariant.Italic)
{
return(_nameItalic);
}
else if (variant == PCLFonts.eVariant.Bold)
{
return(_nameBold);
}
else if (variant == PCLFonts.eVariant.BoldItalic)
{
return(_nameBoldItalic);
}
else
{
return(_nameRegular);
}
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e t P C L W e i g h t //
//--------------------------------------------------------------------//
// //
// Return the PCL font weight characteristic value. //
// //
//--------------------------------------------------------------------//
public Int16 getPCLWeight(PCLFonts.eVariant variant)
{
if (variant == PCLFonts.eVariant.Italic)
{
return(_weightItalic);
}
else if (variant == PCLFonts.eVariant.Bold)
{
return(_weightBold);
}
else if (variant == PCLFonts.eVariant.BoldItalic)
{
return(_weightBoldItalic);
}
else
{
return(_weightRegular);
}
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e t P C L S t y l e //
//--------------------------------------------------------------------//
// //
// Return the PCL font style characteristic value. //
// //
//--------------------------------------------------------------------//
public UInt16 getPCLStyle(PCLFonts.eVariant variant)
{
if (variant == PCLFonts.eVariant.Italic)
{
return(_styleItalic);
}
else if (variant == PCLFonts.eVariant.Bold)
{
return(_styleBold);
}
else if (variant == PCLFonts.eVariant.BoldItalic)
{
return(_styleBoldItalic);
}
else
{
return(_styleRegular);
}
}
//--------------------------------------------------------------------//
// M e t h o d //
// v a r i a n t A v a i l a b l e //
//--------------------------------------------------------------------//
// //
// Return indication of whether or not the selected variant exists. //
// //
//--------------------------------------------------------------------//
public Boolean variantAvailable(PCLFonts.eVariant variant)
{
if (variant == PCLFonts.eVariant.Italic)
{
return(_varItalic);
}
else if (variant == PCLFonts.eVariant.Bold)
{
return(_varBold);
}
else if (variant == PCLFonts.eVariant.BoldItalic)
{
return(_varBoldItalic);
}
else
{
return(_varRegular);
}
}
//--------------------------------------------------------------------//
// M e t h o d //
// s e t F o n t O p t i o n s V a r i a n t s //
//--------------------------------------------------------------------//
// //
// Set variant options relevant to selected font. //
// Assume that this is a PresetTypeface or PresetFamilyMember type, //
// because this is all that we've added to the font selection subset. //
// //
//--------------------------------------------------------------------//
private void setFontOptionsVariants(Int32 indxFont,
Boolean samePreset,
ref PCLFonts.eVariant fontVar)
{
Boolean varB,
varBI,
varI,
varR,
varSet;
Int32 fontIndx;
fontIndx = _subsetUnicodeFonts[indxFont];
varSet = false;
//----------------------------------------------------------------//
rbUnicodeFontVarB.Visibility = Visibility.Hidden;
rbUnicodeFontVarBI.Visibility = Visibility.Hidden;
rbUnicodeFontVarI.Visibility = Visibility.Hidden;
rbUnicodeFontVarR.Visibility = Visibility.Hidden;
rbUnicodeFontVarB.IsChecked = false;
rbUnicodeFontVarBI.IsChecked = false;
rbUnicodeFontVarI.IsChecked = false;
rbUnicodeFontVarR.IsChecked = false;
//----------------------------------------------------------------//
varR = PCLFonts.variantExists(fontIndx,
PCLFonts.eVariant.Regular);
varI = PCLFonts.variantExists(fontIndx,
PCLFonts.eVariant.Italic);
varB = PCLFonts.variantExists(fontIndx,
PCLFonts.eVariant.Bold);
varBI = PCLFonts.variantExists(fontIndx,
PCLFonts.eVariant.BoldItalic);
//----------------------------------------------------------------//
if (varR)
{
rbUnicodeFontVarR.Visibility = Visibility.Visible;
}
if (varI)
{
rbUnicodeFontVarI.Visibility = Visibility.Visible;
}
if (varB)
{
rbUnicodeFontVarB.Visibility = Visibility.Visible;
}
if (varBI)
{
rbUnicodeFontVarBI.Visibility = Visibility.Visible;
}
//----------------------------------------------------------------//
if (samePreset)
{
if ((varR) && (fontVar == PCLFonts.eVariant.Regular))
{
rbUnicodeFontVarR.IsChecked = true;
varSet = true;
}
if ((varI) && (fontVar == PCLFonts.eVariant.Italic))
{
rbUnicodeFontVarI.IsChecked = true;
varSet = true;
}
if ((varB) && (fontVar == PCLFonts.eVariant.Bold))
{
rbUnicodeFontVarB.IsChecked = true;
varSet = true;
}
if ((varBI) && (fontVar == PCLFonts.eVariant.BoldItalic))
{
rbUnicodeFontVarBI.IsChecked = true;
varSet = true;
}
}
//----------------------------------------------------------------//
if (!varSet)
{
if (varR)
{
rbUnicodeFontVarR.IsChecked = true;
fontVar = PCLFonts.eVariant.Regular;
}
else if (varI)
{
rbUnicodeFontVarI.IsChecked = true;
fontVar = PCLFonts.eVariant.Italic;
}
else if (varB)
{
rbUnicodeFontVarB.IsChecked = true;
fontVar = PCLFonts.eVariant.Bold;
}
else if (varBI)
{
rbUnicodeFontVarBI.IsChecked = true;
fontVar = PCLFonts.eVariant.BoldItalic;
}
}
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e t P C L F o n t S e l e c t //
//--------------------------------------------------------------------//
// //
// Return the PCL font selection sequence. //
// ... except for the root '<esc>(' prefix. //
// //
//--------------------------------------------------------------------//
public String getPCLFontSelect(PCLFonts.eVariant variant,
Double height,
Double pitch)
{
String seq;
if (_proportional)
{
seq = "s1p";
}
else
{
seq = "s0p";
}
if (_scalable)
{
// Scalable; the size parameter defines the required size.
if (_proportional)
{
// Scalable; proportionally-spaced
seq += height.ToString() + "v";
}
else
{
// Scalable; fixed-pitch
if (pitch != 0.0)
{
seq += pitch.ToString() + "h";
}
else
{
Double calcPitch = (7200 /
(height * _contourRatio));
seq += calcPitch.ToString("F2") + "h";
}
}
}
else
{
// Bitmap; the size is pre-defined.
if (_proportional)
{
// Bitmap; proportionally-spaced
seq += _pointSize.ToString() + "v";
}
else
{
// Bitmap; fixed-pitch
seq += _pointSize.ToString() + "v" +
_pitch.ToString() + "h";
}
}
if (variant == PCLFonts.eVariant.Italic)
{
seq += _styleItalic.ToString() + "s" +
_weightItalic.ToString() + "b";
}
else if (variant == PCLFonts.eVariant.Bold)
{
seq += _styleBold.ToString() + "s" +
_weightBold.ToString() + "b";
}
else if (variant == PCLFonts.eVariant.BoldItalic)
{
seq += _styleBoldItalic.ToString() + "s" +
_weightBoldItalic.ToString() + "b";
}
else
{
seq += _styleRegular.ToString() + "s" +
_weightRegular.ToString() + "b";
}
seq += _typeface + "T";
return(seq);
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e t H P G L 2 F o n t D e f //
//--------------------------------------------------------------------//
// //
// Return the HP-GL/2 font definition command. //
// //
//--------------------------------------------------------------------//
public String getHPGL2FontDef(PCLFonts.eVariant variant,
UInt16 symbolSet,
Double height,
Double pitch)
{
StringBuilder cmd = new StringBuilder(255);
if (_symSetNumber != 0)
{
cmd.Append("1,").Append(_symSetNumber);
}
else
{
cmd.Append("1,").Append(symbolSet);
}
if (_proportional)
{
cmd.Append(",2,1");
}
else
{
cmd.Append(",2,0");
}
if (_scalable)
{
// Scalable; the size parameter defines the required size.
if (_proportional)
{
// Scalable; proportionally-spaced
cmd.Append(",4,").Append(height);
}
else
{
// Scalable; fixed-pitch
cmd.Append(",3,").Append(pitch);
}
}
else
{
// Bitmap; the size is pre-defined.
if (_proportional)
{
// Bitmap; proportionally-spaced
cmd.Append(",4,").Append(_pointSize);
}
else
{
// Bitmap; fixed-pitch
cmd.Append(",3,").Append(_pitch);
}
cmd.Append(",4,").Append(_pointSize);
}
if (variant == PCLFonts.eVariant.Italic)
{
cmd.Append(",5,").Append(_styleItalic);
cmd.Append(",6,").Append(_weightItalic);
}
else if (variant == PCLFonts.eVariant.Bold)
{
cmd.Append(",5,").Append(_styleBold);
cmd.Append(",6,").Append(_weightBold);
}
else if (variant == PCLFonts.eVariant.BoldItalic)
{
cmd.Append(",5,").Append(_styleBoldItalic);
cmd.Append(",6,").Append(_weightBoldItalic);
}
else
{
cmd.Append(",5,").Append(_styleRegular);
cmd.Append(",6,").Append(_weightRegular);
}
cmd.Append(",7,").Append(_typeface);
return(cmd.ToString());
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e n e r a t e P a g e //
//--------------------------------------------------------------------//
// //
// Write individual test data page sequences to output file. //
// //
//--------------------------------------------------------------------//
private static void generatePage(BinaryWriter prnWriter,
Int32 indxPaperSize,
Int32 indxPaperType,
Int32 indxOrientation,
Boolean formAsMacro,
UInt32 codePoint,
Int32 indxFont,
PCLFonts.eVariant fontVar)
{
const Int32 sizeStd = 1024;
Byte[] bufStd = new Byte[sizeStd];
UInt16[] textArray = { 0x00 };
Int16 posX,
posY;
Int32 indStd;
Int16 ptSize;
Byte[] utf8Seq = new Byte[4];
Int32 utf8Len = 0;
String utf8HexVal = "";
//----------------------------------------------------------------//
indStd = 0;
//----------------------------------------------------------------//
if (indxOrientation < PCLOrientations.getCount())
{
PCLXLWriter.addAttrUbyte(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.Orientation,
PCLOrientations.getIdPCLXL(indxOrientation));
}
if (indxPaperSize < PCLPaperSizes.getCount())
{
PCLXLWriter.addAttrUbyte(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.MediaSize,
PCLPaperSizes.getIdPCLXL(indxPaperSize));
}
if ((indxPaperType < PCLPaperTypes.getCount()) &&
(PCLPaperTypes.getType(indxPaperType) !=
PCLPaperTypes.eEntryType.NotSet))
{
PCLXLWriter.addAttrUbyteArray(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.MediaType,
PCLPaperTypes.getName(indxPaperType));
}
PCLXLWriter.addAttrUbyte(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.SimplexPageMode,
(Byte)PCLXLAttrEnums.eVal.eSimplexFrontSide);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.BeginPage);
PCLXLWriter.addAttrUint16XY(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.PageOrigin,
0, 0);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.SetPageOrigin);
PCLXLWriter.addAttrUbyte(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.ColorSpace,
(Byte)PCLXLAttrEnums.eVal.eGray);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.SetColorSpace);
prnWriter.Write(bufStd, 0, indStd);
indStd = 0;
//----------------------------------------------------------------//
if (formAsMacro)
{
PCLXLWriter.addAttrUbyteArray(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.StreamName,
_formName);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.ExecStream);
prnWriter.Write(bufStd, 0, indStd);
indStd = 0;
}
else
{
generateOverlay(prnWriter, false,
indxPaperSize, indxOrientation);
}
prnWriter.Write(bufStd, 0, indStd);
indStd = 0;
//----------------------------------------------------------------//
// //
// Code-point data. //
// //
//----------------------------------------------------------------//
ptSize = 18;
PCLXLWriter.font(prnWriter, false, ptSize,
_symSet_19U, _fontNameArial);
PCLXLWriter.addAttrUbyte(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.GrayLevel,
0);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.SetBrushSource);
PCLXLWriter.addAttrUbyte(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.NullPen,
0);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.SetPenSource);
posX = _posXData;
posY = _posYData;
if (codePoint < 0x010000)
{
PCLXLWriter.text(prnWriter, false, false,
PCLXLWriter.advances_ArialRegular, ptSize,
posX, posY,
"U+" + codePoint.ToString("x4"));
}
else
{
// should not happen 'cos XL only supports 16-bit values !
PCLXLWriter.text(prnWriter, false, false,
PCLXLWriter.advances_ArialRegular, ptSize,
posX, posY,
"U+" + codePoint.ToString("x6"));
}
PrnParseDataUTF8.convertUTF32ToUTF8Bytes(codePoint,
ref utf8Len,
ref utf8Seq);
PrnParseDataUTF8.convertUTF32ToUTF8HexString(codePoint,
true,
ref utf8HexVal);
posY += _lineInc;
PCLXLWriter.text(prnWriter, false, false,
PCLXLWriter.advances_ArialRegular, ptSize,
posX, posY,
utf8HexVal);
//----------------------------------------------------------------//
// //
// Font data. //
// //
//----------------------------------------------------------------//
posY += _lineInc;
PCLXLWriter.text(prnWriter, false, false,
PCLXLWriter.advances_ArialRegular, ptSize,
posX, posY,
PCLFonts.getName(indxFont) +
" " +
Enum.GetName(typeof(PCLFonts.eVariant), fontVar));
posY += _lineInc;
ptSize = 36;
PCLXLWriter.font(prnWriter, false, ptSize,
_symSet_18N,
PCLFonts.getPCLXLName(indxFont,
fontVar));
textArray[0] = (UInt16)codePoint;
PCLXLWriter.textChar(prnWriter, false,
0, // ***** dummy value *****
ptSize,
posX, posY,
(UInt16)codePoint);
//----------------------------------------------------------------//
PCLXLWriter.addAttrUint16(ref bufStd,
ref indStd,
PCLXLAttributes.eTag.PageCopies,
1);
PCLXLWriter.addOperator(ref bufStd,
ref indStd,
PCLXLOperators.eTag.EndPage);
prnWriter.Write(bufStd, 0, indStd);
}
//--------------------------------------------------------------------//
// M e t h o d //
// g e n e r a t e P a g e //
//--------------------------------------------------------------------//
// //
// Write individual test data page sequences to output file. //
// //
//--------------------------------------------------------------------//
private static void generatePage(BinaryWriter prnWriter,
Int32 indxPaperSize,
Int32 indxPaperType,
Int32 indxOrientation,
Boolean formAsMacro,
UInt16 logXOffset,
UInt32 codePoint,
Int32 indxFont,
PCLFonts.eVariant fontVar)
{
Int16 posX,
posY;
Int16 ptSize;
Byte[] utf8Seq = new Byte[4];
Int32 utf8Len = 0;
String utf8HexVal = "";
//----------------------------------------------------------------//
if (formAsMacro)
{
PCLWriter.macroControl(prnWriter, _macroId,
PCLWriter.eMacroControl.Call);
}
else
{
generateOverlay(prnWriter, false, logXOffset,
indxPaperSize, indxOrientation);
}
//----------------------------------------------------------------//
// //
// Code-point data. //
// //
//----------------------------------------------------------------//
ptSize = 18;
PCLWriter.font(prnWriter, true, "19U",
PCLFonts.getPCLFontSelect(_indxFontArial,
PCLFonts.eVariant.Regular,
ptSize, 0));
posX = (Int16)(_posXData - logXOffset);
posY = _posYData;
if (codePoint < 0x010000)
{
PCLWriter.text(prnWriter, posX, posY, 0, "U+" +
codePoint.ToString("x4"));
}
else
{
PCLWriter.text(prnWriter, posX, posY, 0, "U+" +
codePoint.ToString("x6"));
}
PrnParseDataUTF8.convertUTF32ToUTF8Bytes(codePoint,
ref utf8Len,
ref utf8Seq);
PrnParseDataUTF8.convertUTF32ToUTF8HexString(codePoint,
true,
ref utf8HexVal);
posY += _lineInc;
PCLWriter.text(prnWriter, posX, posY, 0, utf8HexVal);
//----------------------------------------------------------------//
// //
// Font data. //
// //
//----------------------------------------------------------------//
posY += _lineInc;
PCLWriter.text(prnWriter, posX, posY, 0,
PCLFonts.getName(indxFont) +
" " +
Enum.GetName(typeof(PCLFonts.eVariant), fontVar));
posY += _lineInc;
ptSize = 36;
PCLWriter.font(prnWriter, true, "18N",
PCLFonts.getPCLFontSelect(indxFont,
fontVar,
ptSize, 0));
PCLWriter.textParsingMethod(
prnWriter,
PCLTextParsingMethods.eIndex.m83_UTF8);
PCLWriter.cursorPosition(prnWriter, posX, posY);
prnWriter.Write(utf8Seq, 0, utf8Len);
PCLWriter.formFeed(prnWriter);
}
