John
5d5f84ce23
Fixed underline logic for instances where the underline ON is the first thing of text. Added better error handling for X/Y Plots which is now display the plot language if the plot cannot be drawn. When a problem occurs printing an image or x/y plot, the error text now prints in red. Better handling of empty RO Database tables. Now will print the message “—No Information Entered –“
1122 lines
32 KiB
C#
1122 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.IO;
|
|
using System.Windows.Forms;
|
|
using iTextSharp.text.pdf;
|
|
using iTextSharp.text;
|
|
using VEPROMS.CSLA.Library;
|
|
using Volian.Base.Library;
|
|
using VlnStatus;
|
|
|
|
|
|
namespace Volian.Print.Library
|
|
{
|
|
class CompleteROReport
|
|
{
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
//Dictionary<string, PdfDestination> _MyErrorBookMarks = new Dictionary<string, PdfDestination>();
|
|
Headers Hdrs; // Header stack object.
|
|
RODataFile RO_df = null;
|
|
int curheaderlen;
|
|
string RODataFileName;
|
|
iTextSharp.text.Document _pdfReportDoc = null;
|
|
PdfPTable datatable = null;
|
|
|
|
private iTextSharp.text.Font _f14; // = pdf.GetFont("Arial Unicode MS", 14, 1, Color.BLACK);
|
|
|
|
public iTextSharp.text.Font F14
|
|
{
|
|
get { return _f14; }
|
|
set { _f14 = value; }
|
|
}
|
|
private iTextSharp.text.Font _f10;
|
|
|
|
public iTextSharp.text.Font F10
|
|
{
|
|
get { return _f10; }
|
|
set { _f10 = value; }
|
|
}
|
|
private iTextSharp.text.Font _f12;
|
|
|
|
public iTextSharp.text.Font F12
|
|
{
|
|
get { return _f12; }
|
|
set { _f12 = value; }
|
|
}
|
|
private iTextSharp.text.Font _f10Bold;
|
|
|
|
public iTextSharp.text.Font F10Bold
|
|
{
|
|
get { return _f10Bold; }
|
|
set { _f10Bold = value; }
|
|
}
|
|
private iTextSharp.text.Font _f12Bold;
|
|
|
|
public iTextSharp.text.Font F12Bold
|
|
{
|
|
get { return _f12Bold; }
|
|
set { _f12Bold = value; }
|
|
}
|
|
|
|
private bool _ConvertCaretToDelta = true;
|
|
|
|
public bool ConvertCaretToDelta
|
|
{
|
|
get { return _ConvertCaretToDelta; }
|
|
set { _ConvertCaretToDelta = value; }
|
|
}
|
|
private bool _IncludeEmptyROFields = false;
|
|
|
|
public bool IncludeEmptyROFields
|
|
{
|
|
get { return _IncludeEmptyROFields; }
|
|
set { _IncludeEmptyROFields = value; }
|
|
}
|
|
private int _ROFstID;
|
|
|
|
public int ROFstID
|
|
{
|
|
get { return _ROFstID; }
|
|
set { _ROFstID = value; }
|
|
}
|
|
private string ReportTitle = "Complete Referenced Objects Report";
|
|
private PdfWriter _MyPDFWriter;
|
|
|
|
public CompleteROReport(PdfWriter mypdfwriter, iTextSharp.text.Document document, string dataFileName, bool convertCaretToDelta, bool includeEmptyROFields)
|
|
{
|
|
Hdrs = new Headers();
|
|
_pdfReportDoc = document;
|
|
RODataFileName = dataFileName;
|
|
_ConvertCaretToDelta = convertCaretToDelta;
|
|
_MyPDFWriter = mypdfwriter;
|
|
_IncludeEmptyROFields = includeEmptyROFields;
|
|
}
|
|
public void StartNewDataTable()
|
|
{
|
|
datatable = new PdfPTable(1);
|
|
datatable.TotalWidth = _pdfReportDoc.PageSize.Width - _pdfReportDoc.LeftMargin - _pdfReportDoc.RightMargin;
|
|
datatable.LockedWidth = true;
|
|
PdfPCell cell = new PdfPCell(new Phrase(ReportTitle, F14));
|
|
cell.HorizontalAlignment = Element.ALIGN_CENTER;
|
|
cell.BackgroundColor = Color.WHITE;
|
|
cell.BorderColor = Color.WHITE;
|
|
datatable.AddCell(cell);
|
|
datatable.HeaderRows = 3;
|
|
datatable.DefaultCell.HorizontalAlignment = Element.ALIGN_LEFT;
|
|
}
|
|
public void Run()
|
|
{
|
|
StartNewDataTable();
|
|
RO_df = new RODataFile(RODataFileName);
|
|
PrintReport();
|
|
RO_df.close();
|
|
}
|
|
private Dictionary<int, DocOutline> _MyDocOutline = new Dictionary<int, DocOutline>();
|
|
|
|
internal Dictionary<int, DocOutline> MyDocOutline
|
|
{
|
|
get { return _MyDocOutline; }
|
|
set { _MyDocOutline = value; }
|
|
}
|
|
public class DocOutline
|
|
{
|
|
private PdfOutline _MyOutline;
|
|
|
|
public PdfOutline MyOutline
|
|
{
|
|
get { return _MyOutline; }
|
|
set { _MyOutline = value; }
|
|
}
|
|
private string _MyHeader;
|
|
|
|
public string MyHeader
|
|
{
|
|
get { return _MyHeader; }
|
|
set { _MyHeader = value; }
|
|
}
|
|
public DocOutline(PdfOutline outline, string header)
|
|
{
|
|
_MyHeader = header;
|
|
_MyOutline = outline;
|
|
}
|
|
}
|
|
private string ReplaceLineDrawCharsWithUnicode(string text)
|
|
{
|
|
text = text.Replace("\xc4", "\x2500"); // Horizontal
|
|
text = text.Replace("\xb3", "\x2502"); // Vertical
|
|
text = text.Replace("\xc0", "\x2514"); // Bottom Left Corner
|
|
text = text.Replace("\xd9", "\x2518"); // Bottom Right Corner
|
|
text = text.Replace("\xc1", "\x2534"); // Bottom Tee
|
|
text = text.Replace("\xda", "\x250c"); // Upper Left Corner
|
|
text = text.Replace("\xc3", "\x251c"); // Left Tee
|
|
text = text.Replace("\xbf", "\x2510"); // Upper Right Corner
|
|
text = text.Replace("\xc2", "\x252c"); // Top Tee
|
|
text = text.Replace("\xb4", "\x2524"); // Right Tee
|
|
text = text.Replace("\xc5", "\x253c"); // Plus
|
|
return text;
|
|
}
|
|
public Phrase ConvertDOSSuperAndSubScripts(string instr, Font fnt)
|
|
{
|
|
int idx = 0;
|
|
Chunk chk;
|
|
Phrase p = new Phrase();
|
|
bool underlineChunk = false;
|
|
instr = instr.Replace("`", "\u00B0"); //degree
|
|
if (ConvertCaretToDelta)
|
|
instr = instr.Replace("^", "\u0394"); // delta
|
|
instr = ReplaceLineDrawCharsWithUnicode(instr);
|
|
// Handle super/sub scripts
|
|
MatchCollection mc = Regex.Matches(instr, "[#~](.*?)[#~]");
|
|
foreach (Match m in mc)
|
|
{
|
|
if (idx < m.Index)
|
|
{
|
|
int strlen = m.Index - idx;
|
|
int uidx = 0;
|
|
string strChk = instr.Substring(idx, strlen);
|
|
MatchCollection mc1 = Regex.Matches(strChk, "[_](.*?)"); // look ofr Underline on/off
|
|
foreach (Match m1 in mc1)
|
|
{
|
|
if (uidx < m1.Index)
|
|
{
|
|
string tstr = (instr.Substring(idx+uidx, m1.Index - uidx));
|
|
if (tstr.EndsWith(" "))
|
|
tstr = tstr.Substring(0, tstr.Length - 1) + "\xA0";
|
|
chk = new Chunk(tstr, fnt);
|
|
if (underlineChunk)
|
|
chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
|
|
chk.SetTextRise(0);
|
|
p.Add(chk);
|
|
uidx += (tstr.Length + 1);
|
|
idx += (tstr.Length + 1);
|
|
strlen -= (tstr.Length + 1);
|
|
underlineChunk = !underlineChunk;
|
|
}
|
|
else if (uidx == m1.Index)
|
|
{
|
|
uidx++;
|
|
underlineChunk = !underlineChunk;
|
|
}
|
|
}
|
|
chk = new Chunk(instr.Substring(idx, strlen), fnt);
|
|
if (underlineChunk)
|
|
chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
|
|
chk.SetTextRise(0);
|
|
p.Add(chk);
|
|
}
|
|
switch (m.Value[0])
|
|
{
|
|
case '#':
|
|
chk = new Chunk(m.Value.Substring(1, m.Length-2), fnt);
|
|
if (underlineChunk)
|
|
chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
|
|
chk.SetTextRise(.25F * chk.Font.Size);
|
|
p.Add(chk);
|
|
idx = m.Index + m.Length;
|
|
break;
|
|
case '~':
|
|
chk = new Chunk(m.Value.Substring(1, m.Length-2), fnt);
|
|
if (underlineChunk)
|
|
chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
|
|
chk.SetTextRise(-.25F * chk.Font.Size);
|
|
p.Add(chk);
|
|
idx = m.Index + m.Length;
|
|
break;
|
|
}
|
|
}
|
|
if (idx < instr.Length - 1)
|
|
{
|
|
int uidx = 0;
|
|
string strChk = (instr.Substring(idx));
|
|
MatchCollection mc1 = Regex.Matches(strChk, "[_](.*?)"); // look for underline on/off
|
|
foreach (Match m1 in mc1)
|
|
{
|
|
if (uidx < m1.Index)
|
|
{
|
|
string tstr = (strChk.Substring(uidx, m1.Index - uidx));
|
|
if (tstr.EndsWith(" "))
|
|
tstr = tstr.Substring(0, tstr.Length - 1) + "\xA0";
|
|
chk = new Chunk(tstr, fnt);
|
|
if (underlineChunk)
|
|
chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
|
|
chk.SetTextRise(0);
|
|
p.Add(chk);
|
|
uidx += (tstr.Length+1);
|
|
underlineChunk = !underlineChunk;
|
|
}
|
|
else if (uidx == m1.Index)
|
|
{
|
|
uidx++;
|
|
underlineChunk = !underlineChunk;
|
|
}
|
|
}
|
|
if (uidx < strChk.Length - 1)
|
|
{
|
|
string tstr = strChk.Substring(uidx);
|
|
if (tstr.EndsWith(" "))
|
|
tstr = tstr.Substring(0, tstr.Length - 1) + "\xA0";
|
|
chk = new Chunk(tstr, fnt);
|
|
if (underlineChunk)
|
|
chk.SetUnderline(Color.BLACK, 0, 0.05F, 0, -.131F, PdfContentByte.LINE_CAP_ROUND);
|
|
chk.SetTextRise(0);
|
|
p.Add(chk);
|
|
}
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
public void AddText(string txt, Font fnt)
|
|
{
|
|
AddText(txt, fnt, Color.BLACK);
|
|
}
|
|
|
|
public void AddText(string txt, Font fnt, Color txtcolor)
|
|
{
|
|
// break the text up on double returns (paragraphs) and put each in their own cell
|
|
// this will allow for page breaks between paragraphs0
|
|
string[] delim = { "\r\n\r\n","\r\n \r\n" };
|
|
string[] strlst = txt.Split(delim,StringSplitOptions.None);
|
|
foreach (string str in strlst)
|
|
{
|
|
Font f = new Font(fnt);
|
|
f.Color = txtcolor;
|
|
PdfPCell cell = new PdfPCell(ConvertDOSSuperAndSubScripts(str, f));
|
|
cell.BorderColor = Color.WHITE;
|
|
if (strlst.Length > 1)
|
|
cell.PaddingBottom = 6;
|
|
datatable.AddCell(cell);
|
|
}
|
|
}
|
|
|
|
public void AddImage(string filename)
|
|
{
|
|
ROImageInfo roImage = ROImageInfo.GetByROFstID_FileName(_ROFstID, filename);
|
|
if (roImage == null) roImage = ROFstInfo.Get(_ROFstID).GetROImageByFilename(filename, null);
|
|
PdfPCell spaceCell = new PdfPCell();
|
|
spaceCell.BorderColor = Color.WHITE;
|
|
datatable.AddCell(spaceCell);
|
|
if (roImage != null)
|
|
{
|
|
ROImageConfig rc = new ROImageConfig(roImage);
|
|
int size = Convert.ToInt32(rc.Image_Size);
|
|
byte[] cnt = roImage.Content;
|
|
byte[] dcnt = ROImageInfo.Decompress(cnt, size);
|
|
iTextSharp.text.Image it_image;
|
|
try
|
|
{
|
|
it_image = iTextSharp.text.Image.GetInstance(dcnt);
|
|
//iTextSharp.text.Image it_image = iTextSharp.text.Image.GetInstance(ROImageInfo.Decompress(roImage.Content, size));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
try
|
|
{
|
|
MemoryStream ms = new MemoryStream(dcnt);
|
|
System.Drawing.Bitmap bm = new System.Drawing.Bitmap(ms);
|
|
using (MemoryStream ms2 = new MemoryStream())
|
|
{
|
|
bm.Save(ms2, System.Drawing.Imaging.ImageFormat.Png);
|
|
ms2.Seek(0, SeekOrigin.Begin);
|
|
byte[] newdcnt = new byte[ms2.Length];
|
|
ms2.Read(newdcnt, 0, (int)ms2.Length);
|
|
it_image = iTextSharp.text.Image.GetInstance(newdcnt);
|
|
}
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
AddText(string.Format("Bad Image File: {0}", filename), F12, Color.RED);
|
|
GenerateErrorMessage(ex2, "Bad Image File. ", string.Format("Image File: {0}", filename));
|
|
roImage.Dispose();
|
|
return;
|
|
}
|
|
}
|
|
it_image.ScaleToFit(_MyPDFWriter.DirectContent.PdfDocument.PageSize.Width - 144, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height - 216);
|
|
PdfPCell cell = new PdfPCell(it_image);
|
|
cell.BorderColor = Color.WHITE;
|
|
datatable.AddCell(cell);
|
|
roImage.Dispose();
|
|
}
|
|
else
|
|
{
|
|
AddText(string.Format("Image File {0} is missing.", filename), F12, Color.RED);
|
|
GenerateErrorMessage(null, "Image File Missing. ", string.Format("Image File: {0}", filename));
|
|
Application.DoEvents();
|
|
}
|
|
}
|
|
|
|
public void AddXYPlot(string plotlang)
|
|
{
|
|
string pngFile = VlnSettings.TemporaryFolder + @"\XYPlot1.png";
|
|
string rawPlotLang = plotlang;
|
|
plotlang = plotlang.Replace("`", "\xB0");
|
|
plotlang = plotlang.Replace("\xF8", "\xB0");
|
|
PdfPCell spaceCell = new PdfPCell();
|
|
spaceCell.BorderColor = Color.WHITE;
|
|
datatable.AddCell(spaceCell);
|
|
try
|
|
{
|
|
System.Drawing.RectangleF plotRect = MSWordToPDF.CreatePlot(pngFile, plotlang, 600F, MSWordToPDF.FormForPlotGraphics);
|
|
iTextSharp.text.Image it_image = iTextSharp.text.Image.GetInstance(pngFile);
|
|
it_image.ScaleToFit(_MyPDFWriter.DirectContent.PdfDocument.PageSize.Width - 144, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height - 216);
|
|
PdfPCell cell = new PdfPCell(it_image);
|
|
cell.BorderColor = Color.WHITE;
|
|
datatable.AddCell(cell);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
AddText("-- Error Processing X/Y Plot Language --",F12,Color.RED);
|
|
datatable.AddCell(spaceCell);
|
|
AddText(rawPlotLang, F10);
|
|
GenerateErrorMessage(null, "Error Processing X/Y Plot Lanuage. ", e.Message);
|
|
}
|
|
}
|
|
|
|
private string processingRO = "";
|
|
|
|
public void PrintReport()
|
|
{
|
|
bool StopPrinting = false;
|
|
bool UserTerminate = false;
|
|
Int16 iRecType = 0;
|
|
VlnStatusBar showStatBar = new VlnStatusBar("Complete RO Report");
|
|
try
|
|
{
|
|
if (RO_df.GetFileLength() > 0)
|
|
{
|
|
showStatBar.BarMax = (int)RO_df.GetFileLength();
|
|
showStatBar.StatMsg = "Creating Report";
|
|
// Loop until either printing is aborted or end of file.
|
|
while (!StopPrinting && (iRecType = RO_df.ReadInteger16()) != -1)
|
|
{
|
|
//Console.WriteLine("Record Type: {0}", iRecType);
|
|
switch (iRecType)
|
|
{
|
|
case 1: // Set Header
|
|
SetHeader();
|
|
break;
|
|
case 2: // Push Header
|
|
PushHeader();
|
|
break;
|
|
case 3: // Pop Header
|
|
PopHeader();
|
|
break;
|
|
case 4: // RRO Begin
|
|
RROBegin();
|
|
break;
|
|
case 5: // RRO End
|
|
RROEnd();
|
|
processingRO = "";
|
|
break;
|
|
case 6: // Msg
|
|
Msg();
|
|
break;
|
|
case 7:
|
|
processingRO = KeyField();
|
|
break;
|
|
case 100: // Text Field - sometimes also XY Plot
|
|
Text();
|
|
Application.DoEvents();
|
|
break;
|
|
case 101: // Plot Field
|
|
XYPlot();
|
|
Application.DoEvents();
|
|
break;
|
|
case 102: // Image Field
|
|
ImageFile();
|
|
Application.DoEvents();
|
|
break;
|
|
case 103: // Multi Begin - Display data for setpoints
|
|
Multiple();
|
|
break;
|
|
case 104: // Multi End
|
|
break;
|
|
case 0: // nothing was entered in that field
|
|
if (_IncludeEmptyROFields)
|
|
NoInformatEntered();
|
|
break;
|
|
case 255:
|
|
_pdfReportDoc.Add(datatable);
|
|
_pdfReportDoc.NewPage();
|
|
StartNewDataTable();
|
|
showStatBar.BarValue = (int)RO_df.GetFilePointerPosition();
|
|
//Console.WriteLine("Record Type: {0} No Operation", iRecType);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
break;
|
|
default: // Problem
|
|
//Console.WriteLine("Record Type: {0} Unrecognized record type", iRecType);
|
|
StopPrinting = true;
|
|
UserTerminate = true;
|
|
MessageBox.Show(string.Format("Unrecognized record type [{0}]", iRecType), "Error Creating Complete RO Report", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
break;
|
|
};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
StartNewDataTable();
|
|
datatable.HeaderRows = 1;
|
|
AddText("Selected Referenced Object has no data.", F12);
|
|
}
|
|
//Console.WriteLine("Record Type: {0}\n** Done **", iRecType);
|
|
_pdfReportDoc.Add(datatable);
|
|
showStatBar.Dispose();
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("Exception : {0}", e.Message);
|
|
RO_df.close();
|
|
_pdfReportDoc.Add(datatable);
|
|
showStatBar.Dispose();
|
|
GenerateErrorMessage(e, "Error Processing Complete RO Report. ", null);
|
|
}
|
|
AddErrorBookmarks();
|
|
return;
|
|
}
|
|
|
|
private void GenerateErrorMessage( Exception e, string erMsg, string erMsg2)
|
|
{
|
|
// if there is lenght then we are in the mist of processing an RO
|
|
string headers = erMsg;
|
|
for (int iLoop = 0; iLoop < Hdrs.HdrCnt; iLoop++)
|
|
headers += Hdrs.strHdrs[iLoop] + "\n ";
|
|
if (processingRO.Length > 0)
|
|
headers += processingRO;
|
|
if (erMsg2 != null && erMsg2.Length > 0)
|
|
headers += "\n" + erMsg2;
|
|
//MessageBox.Show(headers, erMsg, MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
if (e != null)
|
|
_MyLog.Error(headers, e);
|
|
else
|
|
_MyLog.Error(headers);
|
|
PdfOutline outl = new PdfOutline(MyErrorOutline, MyPdfDestPage, processingRO.Length > 0 ? processingRO : "Problem Reading Header");
|
|
//DestSample(outl);
|
|
}
|
|
|
|
//private void DestSample(PdfOutline outl)
|
|
//{
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.FIT), "FIT");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.FITV, 700), "FITV,700");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.FITH, 700), "FITH,700");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.XYZ, 72, 720, 5), "XYZ,72,720,5");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.FITR, 72, 650, 144, 722), "FITR,72, 650, 144, 722");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.XYZ, 72, 720, 10), "XYZ,72,720,10");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.FITR, 0, 500, _pdfReportDoc.PageSize.Width, 720), "FITR,0, 500,_pdfReportDoc.PageSize.Width , 720");
|
|
// new PdfOutline(outl, new PdfDestination(PdfDestination.XYZ, 0, 792, 1), "XYZ,72,720,10");
|
|
//}
|
|
|
|
public void AddErrorBookmarks()
|
|
{
|
|
if (_MyErrorOutline == null) return;
|
|
//if (_MyErrorBookMarks.Count == 0) return;
|
|
//PdfOutline outline = null;
|
|
//foreach (string key in _MyErrorBookMarks.Keys)
|
|
//{
|
|
// if (outline == null) outline = new PdfOutline(_MyPDFWriter.DirectContent.RootOutline, _MyErrorBookMarks[key], "Errors");
|
|
// new PdfOutline(outline, _MyErrorBookMarks[key], key);
|
|
//}
|
|
string emsg = "A Bookmark grouping named \"Errors\" was added to the PDF.\n\n Click on the RO in this grouping to jump to the report page which will contain an error message.\n\nThe error were also recorded in the PROMS error log.";
|
|
MessageBox.Show(emsg, "Errors Found Creating Report", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
|
|
}
|
|
public void Multiple()
|
|
{
|
|
Int16 typ, i, j, nw = 0;
|
|
string str, sep;
|
|
string buff = "";
|
|
int[] width;
|
|
LastHeader();
|
|
sep = "";
|
|
// nw - number of fields
|
|
nw = RO_df.ReadInteger16();
|
|
// allocate space for widths
|
|
width = new int[nw];
|
|
// loop through and load field widths and names
|
|
for (i = 0; i < nw; i++)
|
|
{
|
|
// load width
|
|
width[i] = RO_df.ReadInteger16();
|
|
// load name
|
|
str = RO_df.ReadText();
|
|
// how wide is the header
|
|
int wtxt = str.Length;
|
|
buff += sep;
|
|
buff += str;
|
|
// if the width is wider than the header output spaces to pad
|
|
// to specified width
|
|
if (width[i] > wtxt)
|
|
{
|
|
int extra = width[i] - wtxt;
|
|
while (extra > 0)
|
|
{
|
|
buff += " ";
|
|
extra--;
|
|
}
|
|
// otherwise set the width to the width of the header
|
|
}
|
|
else
|
|
{
|
|
width[i] = wtxt;
|
|
}
|
|
// place a vertical bar between fields
|
|
sep = "|";
|
|
}
|
|
sep = "\n";
|
|
buff += "\n";
|
|
// place horizonal bars between the header and the values
|
|
for (i = 0; i < nw; i++)
|
|
{
|
|
for (j = 0; j < width[i]; j++)
|
|
{
|
|
buff += "-";
|
|
}
|
|
if (i < nw - 1)
|
|
buff += "|";
|
|
}
|
|
i = 0;
|
|
// While not the end of multi
|
|
while ((typ = RO_df.ReadInteger16()) != 104)
|
|
{
|
|
if (typ == 0)
|
|
{// Next row
|
|
sep = "\n"; // set the separator (between rows) to a newline
|
|
i = 0;
|
|
}
|
|
else
|
|
{// more for this row
|
|
// get the data
|
|
str = RO_df.ReadText();
|
|
// if first time output a newline otherwise output a vertical
|
|
// bar between values
|
|
buff += sep;
|
|
// output value
|
|
if (str != null)
|
|
buff += str;
|
|
// set the separator to a vertical bar
|
|
sep = "|";
|
|
if (width[i] > 0)
|
|
{
|
|
int jj;
|
|
jj = width[i] - str.Length;
|
|
// pad the value to the specified width
|
|
while (jj > 0)
|
|
{
|
|
buff += " ";
|
|
jj--;
|
|
}
|
|
}
|
|
i++;
|
|
|
|
}
|
|
}
|
|
// output the table
|
|
PutHeaderAndText(buff);
|
|
//Console.WriteLine("Multiple: {0} ", buff);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
public void SetHeader()
|
|
{
|
|
string pTmp;
|
|
|
|
//Console.WriteLine("Set Header");
|
|
|
|
// Get the number of header records
|
|
Int16 iNewCnt = RO_df.ReadInteger16();
|
|
|
|
//Console.WriteLine("Num Header Records: {0}", iNewCnt);
|
|
|
|
// Clear the existing headers
|
|
Hdrs.strHdrs.Clear();
|
|
// Loop through the headers
|
|
int iLoop = 0;
|
|
for (; iLoop < iNewCnt; iLoop++)
|
|
{
|
|
int hdrRptCnt = (int)RO_df.ReadInteger16();
|
|
if (Hdrs.repeatCount.Count - 1 < iLoop)
|
|
Hdrs.repeatCount.Add((int)hdrRptCnt);
|
|
else
|
|
Hdrs.repeatCount[iLoop] =hdrRptCnt;
|
|
pTmp = RO_df.ReadText();
|
|
if (Hdrs.strHdrs.Count-1 < iLoop)
|
|
Hdrs.strHdrs.Add(pTmp);
|
|
else
|
|
Hdrs.strHdrs[iLoop] = pTmp;
|
|
//Console.WriteLine("Value: {0}", Hdrs.repeatCount[iLoop]);
|
|
//Console.WriteLine("Value Text: {0}", Hdrs.strHdrs[iLoop]);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
// Set the new header count
|
|
Hdrs.HdrCnt = iNewCnt;
|
|
}
|
|
public void PushHeader()
|
|
{
|
|
//if (m_pPrinterOut->Row() > 55)
|
|
//// m_pPrinterOut->newpage();
|
|
//pdfReportDoc.NewPage();
|
|
string pTmp = RO_df.ReadText();
|
|
curheaderlen = pTmp.Length;
|
|
//Hdrs.strHdrs[Hdrs.HdrCnt] = pTmp;
|
|
Hdrs.strHdrs.Add(pTmp);
|
|
//Hdrs.repeatCount[Hdrs.HdrCnt] = 2;
|
|
Hdrs.repeatCount.Add(2);
|
|
Hdrs.HdrCnt++;
|
|
Hdrs.printedLastHeader = false;
|
|
|
|
//m_pPrinterOut->PushedHeader(Hdrs.strHdrs[Hdrs.HdrCnt-1]);
|
|
|
|
//Console.WriteLine("Push Header");
|
|
//Console.WriteLine("Header Text: {0}", pTmp);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
public void PopHeader()
|
|
{
|
|
if (Hdrs.repeatCount[Hdrs.HdrCnt-1] == 2)
|
|
{
|
|
// if the last header was pushed on header list
|
|
// print eject the page if the page ran out, and
|
|
// print the header with "none".
|
|
//if (m_pPrinterOut->Row() > 55)
|
|
// m_pPrinterOut->NewPage();
|
|
LastHeader();
|
|
//m_pPrinterOut->PutLine(0, "none");
|
|
//m_pPrinterOut->NewLine(1);
|
|
}
|
|
// Remove the header
|
|
Hdrs.HdrCnt--;
|
|
//Hdrs.strHdrs[Hdrs.HdrCnt] = null;
|
|
Hdrs.strHdrs.RemoveAt(Hdrs.HdrCnt);
|
|
Hdrs.repeatCount.RemoveAt(Hdrs.HdrCnt);
|
|
|
|
//Console.WriteLine("Pop Header");
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
public void RROBegin()
|
|
{
|
|
//m_pPrinterOut->NewPage();
|
|
//Console.WriteLine("RRO Begin");
|
|
//Console.WriteLine("----------------------------------------------");
|
|
// Start of a new RO, print out the headers
|
|
for (int iLoop = 0; iLoop < Hdrs.HdrCnt; iLoop++)
|
|
{
|
|
if (!MyDocOutline.ContainsKey(iLoop) || MyDocOutline[iLoop].MyHeader != Hdrs.strHdrs[iLoop])
|
|
{
|
|
PdfOutline parentOutline = null;
|
|
if (iLoop == 0)
|
|
parentOutline = MyRootOutline;//_MyPDFWriter.DirectContent.RootOutline;
|
|
else
|
|
parentOutline = MyDocOutline[iLoop - 1].MyOutline;
|
|
//pdfDest = new PdfDestination(PdfDestination.FITH, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height);
|
|
AddOutlineLevel(parentOutline, iLoop, Hdrs.strHdrs[iLoop], MyPdfDestPage);
|
|
}
|
|
AddText(Hdrs.strHdrs[iLoop], F12Bold); // should be bold and first header is centered
|
|
}
|
|
}
|
|
static float _Top = 792;
|
|
public PdfDestination MyPdfDestTop
|
|
{
|
|
get
|
|
{
|
|
// FITH was acting strange and shifting towards bottom of the page as the number of pages increased
|
|
//Console.WriteLine("Top = {0}, {1}", _Top, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height);
|
|
//return new PdfDestination(PdfDestination.FITH, _Top);//_MyPDFWriter.DirectContent.PdfDocument.PageSize.Height);
|
|
return new PdfDestination(PdfDestination.XYZ, 0, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height, 1.5f);
|
|
}
|
|
}
|
|
|
|
public PdfDestination MyPdfDestPage
|
|
{
|
|
get
|
|
{
|
|
return new PdfDestination(PdfDestination.FITV,0);
|
|
}
|
|
}
|
|
|
|
private PdfOutline _MyErrorOutline = null;
|
|
|
|
public PdfOutline MyErrorOutline
|
|
{
|
|
get
|
|
{
|
|
if (_MyErrorOutline == null)
|
|
{
|
|
_MyErrorOutline = new PdfOutline(_MyPDFWriter.DirectContent.RootOutline, MyPdfDestPage, "Errors");
|
|
}
|
|
return _MyErrorOutline;
|
|
}
|
|
}
|
|
private PdfOutline _MyRootOutline = null;
|
|
|
|
public PdfOutline MyRootOutline
|
|
{
|
|
get
|
|
{
|
|
if (_MyRootOutline == null)
|
|
{
|
|
_MyRootOutline = new PdfOutline(_MyPDFWriter.DirectContent.RootOutline, MyPdfDestTop, "Referenced Objects");
|
|
}
|
|
return _MyRootOutline;
|
|
}
|
|
}
|
|
private PdfDestination pdfDest = null;
|
|
private void AddOutlineLevel(PdfOutline parentOutline, int iLoop, string hdr, PdfDestination pdfDest)
|
|
{
|
|
if (MyDocOutline.ContainsKey(iLoop))
|
|
MyDocOutline[iLoop] = new DocOutline(new PdfOutline(parentOutline, pdfDest, hdr), hdr);
|
|
else
|
|
MyDocOutline.Add(iLoop,new DocOutline(new PdfOutline(parentOutline, pdfDest, hdr), hdr));
|
|
}
|
|
|
|
public void RROEnd()
|
|
{
|
|
//m_pPrinterOut->PageEnd();
|
|
// Remove any headers that are left over
|
|
//Console.WriteLine("{0} headers cleaned up.", Hdrs.HdrCnt);
|
|
//Console.WriteLine("RRO End");
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
public void Msg()
|
|
{
|
|
|
|
// Set a message to the printer on its own
|
|
string szStr = RO_df.ReadText();
|
|
PutHeaderAndText(szStr);
|
|
//m_pPrinterOut->NewLine(1);
|
|
//m_pPrinterOut->PutChr(szStr);
|
|
//m_pPrinterOut->NewLine(1);
|
|
|
|
//Console.WriteLine("Message");
|
|
//Console.WriteLine("Message Text: {0}", szStr);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
public void NoInformatEntered()
|
|
{
|
|
PutHeaderAndText("-- No information entered --");
|
|
}
|
|
|
|
public void PutHeaderAndText(string txt)
|
|
{
|
|
if (!Hdrs.printedLastHeader)
|
|
{
|
|
Chunk chk = LastHeader();
|
|
Phrase p = new Phrase();
|
|
PdfPCell cell = new PdfPCell();
|
|
p.Add(chk); // add the header chunk
|
|
cell.BackgroundColor = Color.WHITE;
|
|
cell.BorderColor = Color.WHITE;
|
|
cell.AddElement(p);
|
|
datatable.AddCell(cell);
|
|
}
|
|
PutText(txt);
|
|
}
|
|
public void Text()
|
|
{
|
|
// Get the lenght of the text string and read it in
|
|
Int16 iValue = RO_df.ReadInteger16();
|
|
string szStr = RO_df.ReadText(iValue);
|
|
string temp = szStr;
|
|
Chunk chk = LastHeader();
|
|
Phrase p = new Phrase();
|
|
PdfPCell cell = new PdfPCell();
|
|
p.Add(chk); // add the header chunk
|
|
cell.BackgroundColor = Color.WHITE;
|
|
cell.BorderColor = Color.WHITE;
|
|
|
|
bool isXYPlot = szStr.StartsWith("<<G");
|
|
|
|
if (isXYPlot || (iValue + curheaderlen) > 72 || (szStr.IndexOf('\r') != -1))
|
|
{
|
|
// If the lenght of the string plus the field title is greater
|
|
// than 72 characters or has a carriage return character in it
|
|
// then output the text on multiple lines
|
|
//if (m_pPrinterOut->Row() > 55)
|
|
// m_pPrinterOut->newpage();
|
|
|
|
// the header goes on its own line
|
|
cell.AddElement(p);
|
|
datatable.AddCell(cell);
|
|
// text goes below the header
|
|
|
|
if (isXYPlot)
|
|
AddXYPlot(szStr); // xy plot - sometimes plots were put in text fields
|
|
else
|
|
PutText(temp); // it's just text
|
|
}
|
|
else
|
|
{
|
|
// Otherwise output the header and text on a single line
|
|
p.Add(ConvertDOSSuperAndSubScripts(szStr,F10));
|
|
cell.AddElement(p);
|
|
datatable.AddCell(cell);
|
|
//m_pPrinterOut->SetNumberOfNewLines(0);
|
|
//m_pPrinterOut->putline(0, temp);
|
|
//if (m_pPrinterOut->Row() + 1 > 55)
|
|
// Hdrs.repeatCount[Hdrs.HdrCnt] = 1;
|
|
//else
|
|
// m_pPrinterOut->newline(1);
|
|
}
|
|
//Console.WriteLine("Text");
|
|
//Console.WriteLine("Value: {0}", iValue);
|
|
//Console.WriteLine("Text: {0}", szStr);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
public string KeyField()
|
|
{
|
|
// use the key field as the PDF bookbark
|
|
string szStr = RO_df.ReadText();
|
|
//PdfDestination pdfDest = new PdfDestination(PdfDestination.FITH, _MyPDFWriter.DirectContent.PdfDocument.PageSize.Height);
|
|
PdfOutline outl = new PdfOutline(MyDocOutline[Hdrs.HdrCnt - 1].MyOutline, MyPdfDestTop, szStr);
|
|
//DestSample(outl);
|
|
return szStr;
|
|
//Console.WriteLine("Key Field");
|
|
//Console.WriteLine("Key Text: {0}", szStr);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
// Read in the image filename, height, and width
|
|
public void ImageFile()
|
|
{
|
|
string fn = RO_df.ReadText();
|
|
Int16 ht = RO_df.ReadInteger16();
|
|
Int16 wd = RO_df.ReadInteger16();
|
|
//m_pPrinterOut->PrintImage(fn, wd, ht);
|
|
|
|
//Console.WriteLine("ImageFile");
|
|
//Console.WriteLine("Name: {0}", fn);
|
|
//Console.WriteLine("Height: {0}", ht);
|
|
//Console.WriteLine("Width: {0}", wd);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
AddImage(fn);
|
|
}
|
|
// Read in the X/Y plot info.
|
|
public void XYPlot()
|
|
{
|
|
// Get the lenght of the text string and read it in
|
|
Int16 iValue = RO_df.ReadInteger16();
|
|
string szStr = RO_df.ReadText(iValue);
|
|
string temp = szStr;
|
|
Chunk chk = LastHeader(); // = new Chunk(m.Value, fnt);
|
|
Phrase p = new Phrase();
|
|
PdfPCell cell = new PdfPCell();
|
|
p.Add(chk); // add the header chunk
|
|
cell.BackgroundColor = Color.WHITE;
|
|
cell.BorderColor = Color.WHITE;
|
|
|
|
// the header goes on its own line
|
|
cell.AddElement(p);
|
|
datatable.AddCell(cell);
|
|
AddXYPlot(szStr);
|
|
|
|
//Console.WriteLine("XY Plot");
|
|
//Console.WriteLine("Value: {0}", iValue);
|
|
//Console.WriteLine("Text: {0}", szStr);
|
|
//Console.WriteLine("----------------------------------------------");
|
|
}
|
|
|
|
// Output the string. If it is a graph, print the graph.
|
|
// ParseForGraph contains the code to print the text.
|
|
public void PutText(string szStr)
|
|
{
|
|
if (szStr == null || szStr.Equals("NONE"))
|
|
{
|
|
//m_pPrinterOut->putchr("NONE");
|
|
//m_pPrinterOut->newline(2);
|
|
AddText("NONE", F10);
|
|
return;
|
|
}
|
|
//m_pPrinterOut->SetNumberOfNewLines(0);
|
|
AddText(szStr,F10);
|
|
//m_pPrinterOut->newline(2);
|
|
// Include margin so the Display Data can print with a margin of zero
|
|
//m_pPrinterOut->ParseForGraph(temp, margin);
|
|
}
|
|
|
|
// Output the last header that was push onto the header stack
|
|
// Printer::LastHeader contains the code to do this.
|
|
public Chunk LastHeader()
|
|
{
|
|
Chunk chk;// = new Chunk(m.Value, fnt);
|
|
string hdrtxt = "";
|
|
if (Hdrs.HdrCnt > 0)
|
|
hdrtxt = Hdrs.strHdrs[Hdrs.HdrCnt - 1];
|
|
hdrtxt += ": ";
|
|
chk = new Chunk(hdrtxt, F10Bold);
|
|
Hdrs.printedLastHeader = true;
|
|
return chk;
|
|
//m_pPrinterOut->LastHeader();
|
|
}
|
|
|
|
}// end CompSumROReport
|
|
|
|
|
|
public class Headers
|
|
{
|
|
//public string[] strHdrs;
|
|
public List<string> strHdrs;
|
|
// public int[] repeatCount;
|
|
public int HdrCnt;
|
|
public List<int> repeatCount;
|
|
public bool printedLastHeader;
|
|
public Headers()
|
|
{
|
|
HdrCnt = 0;
|
|
strHdrs = new List<string>();
|
|
repeatCount = new List<int>();
|
|
printedLastHeader = false;
|
|
}
|
|
}
|
|
|
|
public class RODataFile
|
|
{
|
|
FileStream fs = null;
|
|
BinaryReader br = null;
|
|
public RODataFile(string fname)
|
|
{
|
|
fs = new FileStream(fname,FileMode.Open);
|
|
br = new BinaryReader(fs);
|
|
}
|
|
public void close()
|
|
{
|
|
br.Close();
|
|
fs.Close();
|
|
}
|
|
public long GetFileLength()
|
|
{
|
|
return fs.Length;
|
|
}
|
|
public long GetFilePointerPosition()
|
|
{
|
|
return fs.Position;
|
|
}
|
|
// Read an integer value from the data file
|
|
public Int16 ReadInteger16()
|
|
{
|
|
try
|
|
{
|
|
return (Int16)br.ReadUInt16();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("Exception : {0}", e.Message);
|
|
return -1;
|
|
}
|
|
}
|
|
// Read a text string from the data file and returns it.
|
|
// The calling program is responsible for free it
|
|
// with the "delete" operator.
|
|
|
|
public string ReadText()
|
|
{
|
|
return ReadText(-1);
|
|
}
|
|
|
|
public string ReadText(Int16 i16CharCount)
|
|
{
|
|
Int16 i16DataSize;
|
|
if (i16CharCount == -1)
|
|
i16DataSize = ReadInteger16();
|
|
else
|
|
i16DataSize = i16CharCount;
|
|
|
|
if (i16DataSize <= 0)
|
|
return null;
|
|
else
|
|
{
|
|
byte[] charbuff = new byte[i16DataSize + 1];
|
|
charbuff = br.ReadBytes(i16DataSize);
|
|
string str = "";
|
|
for (int i = 0; i < i16DataSize; i++)
|
|
str += Convert.ToChar(charbuff[i]).ToString();
|
|
return (str);
|
|
//return (Encoding.ASCII.GetString(charbuff, 0, i16DataSize)); // this didn't handle line draw chars
|
|
}
|
|
}
|
|
|
|
// Search through the file to find the next record
|
|
public long NextRecord()
|
|
{
|
|
Int16 iType;
|
|
Int16 RECORD_START = 255;
|
|
// While not the next record and not end of file get the next meta item
|
|
while ((iType = ReadInteger16()) != RECORD_START && iType != -1)
|
|
{
|
|
NextItem();
|
|
}
|
|
return fs.Seek(0, SeekOrigin.Current);
|
|
}
|
|
// Get the next meta item and discard the data
|
|
public long NextItem()
|
|
{
|
|
string pTmp;
|
|
Int16 iRecType = ReadInteger16();
|
|
Int16 iNewCnt;
|
|
int iLoop;
|
|
switch (iRecType)
|
|
{
|
|
case 1: // Set Header
|
|
iNewCnt = ReadInteger16();
|
|
for (iLoop = 0; iLoop < iNewCnt; iLoop++)
|
|
{
|
|
ReadInteger16();
|
|
pTmp = ReadText();
|
|
//delete pTmp;
|
|
}
|
|
break;
|
|
case 2: // Push Header
|
|
case 6: // Msg
|
|
case 7: // Key Field
|
|
case 100: // Text Field
|
|
case 101: // Plot Field
|
|
pTmp = ReadText();
|
|
//delete pTmp;
|
|
break;
|
|
case 3: // Pop Header
|
|
case 4: // RRO Begin
|
|
case 5: // RRO End
|
|
case 103: // Multi Begin
|
|
case 104: // Multi End
|
|
case 0: // Do Nothing
|
|
// Do nothing
|
|
break;
|
|
case 102: // Image Field
|
|
pTmp = ReadText();
|
|
//delete pTmp;
|
|
ReadInteger16();
|
|
ReadInteger16();
|
|
break;
|
|
}
|
|
return fs.Seek(0, SeekOrigin.Current);
|
|
}
|
|
// Get the block of data that is the record
|
|
public byte[] GetRecord(ref int size)
|
|
{
|
|
byte[] data;
|
|
// Get the current position
|
|
long lCurPos = fs.Seek(0, SeekOrigin.Current);
|
|
|
|
// Go to the end of the record and get the file position
|
|
ReadInteger16();
|
|
NextRecord();
|
|
long lEndRecord = fs.Seek(0, SeekOrigin.Current);
|
|
|
|
// Get the size of the record
|
|
size = (int)(lEndRecord - lCurPos);
|
|
|
|
// Retrieve the record from the file
|
|
data = new byte[size +1];
|
|
data = br.ReadBytes(size);
|
|
|
|
return data;
|
|
}
|
|
}
|
|
}
|
|
|