private static string TranslateMacroReferences(string input, MacroValues macros)
{
if (input == null)
{
return(null);
}
string result = input;
for (int startingOffset = 0; ;)
{
int openBraceOffset = result.IndexOf('{', startingOffset);
if (openBraceOffset < 0)
{
break;
}
int closeBraceOffset = result.IndexOf('}', openBraceOffset + 1);
if (closeBraceOffset > 0)
{
string macroName = result.Substring(openBraceOffset + 1, closeBraceOffset - openBraceOffset - 1);
string macroValue;
if (!macros.TryGetValue(macroName, out macroValue))
{
macroValue = "";
}
result = result.Substring(0, openBraceOffset) + macroValue + result.Substring(closeBraceOffset + 1);
startingOffset = openBraceOffset;
}
else
{
startingOffset++;
}
}
return(result);
}
public void Print(PrintPageEventArgs e)
{
string dataPath = _DataPaths[_SignIndex];
_SignIndex++;
try
{
string dataFile = Path.GetFileName(dataPath);
string dataFolder = Path.GetDirectoryName(dataPath);
MacroValues macros = new MacroValues();
SingleSign.AddStandardMacroValues(macros);
AddUserMacros(macros);
XmlDocument dataDoc = SingleSign.CreateEmptySignDataDoc();
dataDoc.Load(Path.Combine(dataFolder, dataFile));
SingleSign.AddDataFileMacros(macros, dataFolder, dataDoc);
string templateFile = Path.GetFileName(_TemplatePath);
string templateFolder = Path.GetDirectoryName(_TemplatePath);
SingleSign singleSign = new SingleSign();
singleSign.Print(templateFile, templateFolder, macros, dataFolder, e);
}
catch (Exception ex)
{
throw new Exception("Error in sign data file " + dataPath, ex);
}
e.HasMorePages = (_SignIndex < _SignCount);
}
private void docSign_PrintPage(object sender, PrintPageEventArgs e)
{
try
{
string dataFolder = _PlantFolder;
string templateFile = Path.GetFileName(_TemplatePath);
string templateFolder = Path.GetDirectoryName(_TemplatePath);
MacroDefinitions macroDefs = new MacroDefinitions();
SingleSign.LoadMacroDefinitions(templateFile, templateFolder, macroDefs);
MacroValues macros = new MacroValues();
SingleSign.AddStandardMacroValues(macros);
foreach (MacroDefinition macroDef in macroDefs)
{
macros[macroDef.Name] = macroDef.Value;
}
XmlDocument dataDoc = SingleSign.CreateEmptySignDataDoc();
dataDoc.LoadXml(txtPlantFileContents.Text);
SingleSign.AddDataFileMacros(macros, dataFolder, dataDoc);
SingleSign singleSign = new SingleSign();
singleSign.Print(templateFile, templateFolder, macros, dataFolder, e);
e.HasMorePages = false;
}
catch (Exception ex)
{
SingleSign.ShowException(ex);
}
}
public static void AddStandardMacroValues(MacroValues macros)
{
macros["inch"] = "\"";
macros["cent"] = "\xA2";
macros["squarebullet"] = "\x25A0";
macros["largesquarebullet"] = "\x25A0";
macros["smallsquarebullet"] = "\x25AA";
macros["roundbullet"] = "\x25CF";
}
private static bool TryGetAttrib(XmlElement cmdElm, string attrName, MacroValues macros, out string value)
{
string rawValue = cmdElm.GetAttribute(attrName);
if (string.IsNullOrEmpty(rawValue))
{
value = rawValue;
return(false);
}
value = TranslateMacroReferences(rawValue, macros);
return(true);
}
private void SetTextPos(XmlElement cmdElm, MacroValues macros)
{
PointF textPos;
if (TryGetPosition(cmdElm, macros, out textPos))
{
SetTextPos(textPos);
}
else
{
throw CreateTemplateException(cmdElm, "Position attributes are required");
}
}
private static bool TryGetAttrib(XmlElement cmdElm, string attrName, MacroValues macros, out float floatValue)
{
string stringValue;
if (!TryGetAttrib(cmdElm, attrName, macros, out stringValue))
{
floatValue = 0.0f;
return(false);
}
if (!float.TryParse(stringValue, out floatValue))
{
throw CreateTemplateAttributeException(cmdElm, attrName, "Not a valid decimal number");
}
return(true);
}
private void PrintText(XmlElement cmdElm, MacroValues macros)
{
PointF textPos;
if (TryGetPosition(cmdElm, macros, out textPos))
{
SetTextPos(textPos);
}
string toPrint = GetRequiredStringAttrib(cmdElm, "value", macros);
toPrint = TranslateMacroReferences(toPrint, macros);
toPrint = NormalizeText(toPrint);
if (!string.IsNullOrEmpty(toPrint))
{
string prefix;
if (TryGetAttrib(cmdElm, "prefix", macros, out prefix))
{
prefix = TranslateMacroReferences(prefix, macros);
}
else
{
prefix = null;
}
float spaceAfter;
if (!TryGetAttrib(cmdElm, "spaceafter", macros, out spaceAfter))
{
spaceAfter = _SpaceAfter;
}
float width;
if (!TryGetAttrib(cmdElm, "width", macros, out width))
{
width = _ColumnWidth;
}
if (width > 0.0f)
{
string discard;
bool center = TryGetAttrib(cmdElm, "center", macros, out discard);
PrintString(toPrint, prefix, width, center, spaceAfter);
}
else
{
PrintString(toPrint, prefix, spaceAfter);
}
}
}
private void PrintLine(XmlElement cmdElm, MacroValues macros)
{
PointF pos1;
PointF pos2;
if (!TryGetPosition(cmdElm, "x1", "y1", macros, out pos1))
{
throw CreateTemplateException(cmdElm, "Missing (x1,y1) line endpoint");
}
if (!TryGetPosition(cmdElm, "x2", "y2", macros, out pos2))
{
throw CreateTemplateException(cmdElm, "Missing (x2,y2) line endpoint");
}
float width = GetRequiredFloatAttrib(cmdElm, "width", macros);
Pen pen = new Pen(_Brush, width);
_Graphics.DrawLine(pen, pos1, pos2);
}
public static void AddDataFileMacros(MacroValues macros, string dataFolder, XmlDocument dataDoc)
{
foreach (XmlNode incNode in dataDoc.DocumentElement.SelectNodes("include"))
{
XmlElement incElm = (XmlElement)incNode;
string includeFileName = incElm.InnerText;
XmlDocument includeDoc = SingleSign.CreateEmptySignDataDoc();
includeDoc.Load(Path.Combine(dataFolder, includeFileName));
AddDataFileMacros(macros, dataFolder, includeDoc);
}
foreach (XmlNode dataNode in dataDoc.DocumentElement.SelectNodes("data"))
{
XmlElement dataElm = (XmlElement)dataNode;
string id = dataElm.GetAttribute("id");
if (id == null)
{
throw new MissingFieldException("Missing [id] in data file");
}
macros[id] = dataElm.InnerText;
}
}
private void PrintImage(XmlElement cmdElm, MacroValues macros, string dataFolder)
{
PointF imagePos;
RectangleF imageRect;
float imageWidth;
float imageHeight;
if (!TryGetPosition(cmdElm, macros, out imagePos))
{
throw CreateTemplateException(cmdElm, "Image position is required");
}
if (!TryGetAttrib(cmdElm, "width", macros, out imageWidth))
{
throw CreateTemplateException(cmdElm, "Image width is required");
}
if (!TryGetAttrib(cmdElm, "height", macros, out imageHeight))
{
imageHeight = 0.0f;
}
string fileName = GetRequiredStringAttrib(cmdElm, "file", macros);
fileName = TranslateMacroReferences(fileName, macros);
string imagePath = Path.Combine(dataFolder, fileName);
using (Image image = Image.FromFile(imagePath))
{
float aspectRatio = (float)image.Height / (float)image.Width;
if (imageHeight > 0.0f)
{
float scaledWidth = imageHeight / aspectRatio;
imageRect = new RectangleF(imagePos.X + (imageWidth - scaledWidth) / 2.0f, imagePos.Y, scaledWidth, imageHeight);
}
else
{
imageRect = new RectangleF(imagePos, new SizeF(imageWidth, imageWidth * aspectRatio));
}
_Graphics.DrawImage(image, imageRect);
}
}
private void PrintOneTemplate(string templateFile, string templateFolder, MacroValues macros, string dataFolder)
{
string templatePath = Path.Combine(templateFolder, templateFile);
XmlDocument templateDoc = new XmlDocument();
templateDoc.Load(templatePath);
foreach (XmlNode templateNode in templateDoc.DocumentElement.ChildNodes)
{
XmlElement cmdElm = templateNode as XmlElement;
if (cmdElm != null)
{
string cmdName = cmdElm.Name.ToLowerInvariant();
switch (cmdName)
{
case "font":
_FontSize = GetRequiredFloatAttrib(cmdElm, "size", macros);
_FontName = GetRequiredStringAttrib(cmdElm, "name", macros);
CreateFont();
break;
case "text":
PrintText(cmdElm, macros);
break;
case "image":
PrintImage(cmdElm, macros, dataFolder);
break;
case "line":
PrintLine(cmdElm, macros);
break;
case "style":
string styleName = GetRequiredStringAttrib(cmdElm, "name", macros);
CreateFontStyle(cmdElm, styleName);
CreateFont();
break;
case "color":
string color = GetRequiredStringAttrib(cmdElm, "name", macros);
CreateBrush(cmdElm, color);
CreateFont();
break;
case "columnwidth":
ColumnWidth(cmdElm, macros);
break;
case "spaceafter":
SpaceAfter(cmdElm, macros);
break;
case "movedown":
MoveDown(cmdElm, macros);
break;
case "moveright":
MoveRight(cmdElm, macros);
break;
case "textpos":
SetTextPos(cmdElm, macros);
break;
case "macrodef":
// Handled by LoadMacroDefinitions().
break;
case "include":
string includePath = TranslateMacroReferences(cmdElm.InnerText, macros);
if (string.IsNullOrEmpty(includePath))
{
throw CreateTemplateException(cmdElm, "Missing include file name");
}
PrintOneTemplate(Path.GetFileName(includePath), templateFolder, macros, dataFolder);
break;
default:
throw new ArgumentException("Unrecognized command in sign template: <" + cmdName + ">");
}
}
}
}
private static bool TryGetPosition(XmlElement cmdElm, string xAttr, string yAttr, MacroValues macros, out PointF position)
{
float x;
float y;
bool hasX;
bool hasY;
hasX = TryGetAttrib(cmdElm, xAttr, macros, out x);
hasY = TryGetAttrib(cmdElm, yAttr, macros, out y);
if (hasX != hasY)
{
throw CreateTemplateException(cmdElm, "\"" + xAttr + "\" and \"" + yAttr +
"\" attributes must either both must be specified or neither");
}
if (hasX & hasY)
{
position = new PointF(x, y);
return(true);
}
else
{
position = new PointF();
return(false);
}
}
private static bool TryGetPosition(XmlElement cmdElm, MacroValues macros, out PointF position)
{
return(TryGetPosition(cmdElm, "x", "y", macros, out position));
}
private static string GetRequiredStringAttrib(XmlElement cmdElm, string attrName, MacroValues macros)
{
string result;
if (!TryGetAttrib(cmdElm, attrName, macros, out result))
{
throw CreateTemplateAttributeException(cmdElm, attrName, "Missing attribute");
}
return(TranslateMacroReferences(result, macros));
}
private static float GetRequiredFloatAttrib(XmlElement cmdElm, string attrName, MacroValues macros)
{
float result;
if (!TryGetAttrib(cmdElm, attrName, macros, out result))
{
throw CreateTemplateAttributeException(cmdElm, attrName, "Missing attribute");
}
return(result);
}
public void Print(string templateFile, string templateFolder, MacroValues macros, string dataFolder, PrintPageEventArgs e)
{
Init(e);
PrintOneTemplate(templateFile, templateFolder, macros, dataFolder);
}
private void MoveRight(XmlElement cmdElm, MacroValues macros)
{
_TextPos.X += GetRequiredFloatAttrib(cmdElm, "size", macros);
}
private void SpaceAfter(XmlElement cmdElm, MacroValues macros)
{
_SpaceAfter = GetRequiredFloatAttrib(cmdElm, "size", macros);
}
private void ColumnWidth(XmlElement cmdElm, MacroValues macros)
{
_ColumnWidth = GetRequiredFloatAttrib(cmdElm, "size", macros);
}
