2232 lines
87 KiB
C#
2232 lines
87 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using iTextSharp.text;
|
|
using iTextSharp.text.pdf;
|
|
using iTextSharp.text.factories;
|
|
using Volian.Svg.Library;
|
|
using System.Text.RegularExpressions;
|
|
using System.Xml;
|
|
using VEPROMS.CSLA.Library;
|
|
|
|
namespace Volian.Print.Library
|
|
{
|
|
public partial class VlnSvgPageHelper:SvgPageHelper
|
|
{
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
private pkParagraphs _MyPlacekeepers = new pkParagraphs();
|
|
public pkParagraphs MyPlacekeepers
|
|
{
|
|
get { return _MyPlacekeepers; }
|
|
}
|
|
private PageBookmarks _PageBookmarks = new PageBookmarks();
|
|
public PageBookmarks PageBookmarks
|
|
{
|
|
get { return _PageBookmarks; }
|
|
set { _PageBookmarks = value; }
|
|
}
|
|
private PdfOutline _MyPdfOutline = null;
|
|
public PdfOutline MyPdfOutline
|
|
{
|
|
get { return _MyPdfOutline; }
|
|
set { _MyPdfOutline = value; }
|
|
}
|
|
private ChkListBoxesHelper _CheckListBoxes = null;
|
|
private ChkListBoxesHelper CheckListBoxes
|
|
{
|
|
get { return _CheckListBoxes; }
|
|
set { _CheckListBoxes = value; }
|
|
}
|
|
private vlnText _TopMessage;
|
|
public vlnText TopMessage
|
|
{
|
|
get { return _TopMessage; }
|
|
set { _TopMessage = value; }
|
|
}
|
|
private List<vlnText> _TopMessageRs=new List<vlnText>(); // Added if there are 2 messages, in AER AND RNO (for BGE)
|
|
public List<vlnText> TopMessageRs
|
|
{
|
|
get { return _TopMessageRs; }
|
|
set { _TopMessageRs = value; }
|
|
}
|
|
private List<vlnText> _TopMessageSub1s=new List<vlnText>(); // BGE Alarms: in CONDITION/RESPONSE if break within substep
|
|
public List<vlnText> TopMessageSub1s
|
|
{
|
|
get { return _TopMessageSub1s; }
|
|
set { _TopMessageSub1s = value; }
|
|
}
|
|
private List<vlnText> _TopMessageSub2s=new List<vlnText>(); // BGE Alarms: in CONDITION/RESPONSE if break within substep
|
|
public List<vlnText> TopMessageSub2s
|
|
{
|
|
get { return _TopMessageSub2s; }
|
|
set { _TopMessageSub2s = value; }
|
|
}
|
|
private vlnText _BottomMessage;
|
|
public vlnText BottomMessage
|
|
{
|
|
get { return _BottomMessage; }
|
|
set { _BottomMessage = value; }
|
|
}
|
|
private vlnText _BottomMessageR; // Added if there are 2 messages, in AER AND RNO (for BGE)
|
|
public vlnText BottomMessageR
|
|
{
|
|
get { return _BottomMessageR; }
|
|
set { _BottomMessageR = value; }
|
|
}
|
|
private vlnText _BottomMessageA; // Added if there are 3 messages, at bottom AND in AER AND RNO (for BGEALARMS)
|
|
public vlnText BottomMessageA
|
|
{
|
|
get { return _BottomMessageA; }
|
|
set { _BottomMessageA = value; }
|
|
}
|
|
Dictionary<int, vlnParagraph> _MyParagraphs = new Dictionary<int, vlnParagraph>();
|
|
public Dictionary<int, vlnParagraph> MyParagraphs
|
|
{
|
|
get { return _MyParagraphs; }
|
|
set { _MyParagraphs = value; }
|
|
}
|
|
float _YMultiplier = 1;
|
|
public float YMultiplier
|
|
{
|
|
get { return _YMultiplier; }
|
|
set { _YMultiplier = value; }
|
|
}
|
|
float _PhoneListHeight = 0;
|
|
public float PhoneListHeight
|
|
{
|
|
get { return _PhoneListHeight; }
|
|
set { _PhoneListHeight = value; }
|
|
}
|
|
private float _AlarmYoffStart = 0;
|
|
public float AlarmYoffStart
|
|
{
|
|
get { return _AlarmYoffStart; }
|
|
set { _AlarmYoffStart = value; }
|
|
}
|
|
private float _AlarmYoffEnd = 0;
|
|
public float AlarmYoffEnd
|
|
{
|
|
get { return _AlarmYoffEnd; }
|
|
set { _AlarmYoffEnd = value; }
|
|
}
|
|
private PdfWriter _MyPdfWriter;
|
|
public PdfWriter MyPdfWriter
|
|
{
|
|
get { return _MyPdfWriter; }
|
|
set
|
|
{
|
|
MyPageCounts = new PageCounts();
|
|
MyTOCPageCounts = new PageCounts();
|
|
MyTOCPageNums = new Dictionary<string, int>();
|
|
_MyPdfWriter = value;
|
|
}
|
|
}
|
|
private PdfContentByte _MyPdfContentByte;
|
|
public PdfContentByte MyPdfContentByte
|
|
{
|
|
get { return _MyPdfContentByte; }
|
|
set { _MyPdfContentByte = value; }
|
|
}
|
|
private int _FinalMessageSectionID;
|
|
public int FinalMessageSectionID
|
|
{
|
|
get { return _FinalMessageSectionID; }
|
|
set { _FinalMessageSectionID = value; }
|
|
}
|
|
private bool _DidFirstPageDocStyle = false;
|
|
public bool DidFirstPageDocStyle
|
|
{
|
|
get { return _DidFirstPageDocStyle; }
|
|
set { _DidFirstPageDocStyle = value; }
|
|
}
|
|
public override void OnCloseDocument(PdfWriter writer, iTextSharp.text.Document document)
|
|
{
|
|
AddBookmarks(writer);
|
|
MyPageCounts.DrawTemplates();
|
|
}
|
|
private bool _OnBlankPage = false;
|
|
public bool OnBlankPage // used while inserting a blank page when printing a procedure with duplex foldouts
|
|
{
|
|
get { return _OnBlankPage; }
|
|
set { _OnBlankPage = value; }
|
|
}
|
|
// when false, no page has been printed yet (for determining whether a blank page before print
|
|
// needs done if first section has foldouts)
|
|
private bool _PrintedAPage = false;
|
|
public bool PrintedAPage
|
|
{
|
|
get { return _PrintedAPage; }
|
|
set { _PrintedAPage = value; }
|
|
}
|
|
|
|
// the following two variables are used to handle the 'PSOnlyFirst' page list Justify flag.
|
|
// PSOnlyFirst signals that the pagelist token should only be processed for the first page of
|
|
// the section. It gets set when this token is processed, so that any remaining pages will
|
|
// not get the token. It's value is derived by taking the different the location of this token
|
|
// & the location of the previous token, so that this amount can be used to move the text up
|
|
// on the 'not first' pages of the section. It's used as an adjustment on the topmargin.
|
|
// This is used in FNP formats.
|
|
private int _sectLevelNumTtlDiff = 0;
|
|
private int _PrintedSectionPage = 0;
|
|
public int PrintedSectionPage
|
|
{
|
|
get { return _PrintedSectionPage; }
|
|
set { _PrintedSectionPage = value; }
|
|
}
|
|
|
|
//private bool _AddBlankPagesForDuplexPrinting = false;
|
|
//public bool AddBlankPagesForDuplexPrinting // Tells us if a the option to add a blank page is turn on (for procedures with duplex foldouts)
|
|
//{
|
|
// get { return _AddBlankPagesForDuplexPrinting; }
|
|
// set { _AddBlankPagesForDuplexPrinting = value; }
|
|
//}
|
|
public override void OnEndPage(PdfWriter writer, iTextSharp.text.Document document)
|
|
{
|
|
bool onBlankPage = OnBlankPage;
|
|
if (OnBlankPage)
|
|
{
|
|
OnBlankPage = false;
|
|
}
|
|
else if (!OnFoldoutPage)
|
|
{
|
|
if (DidFirstPageDocStyle) SetDocStyleAndValues();
|
|
AddBookmarks(writer);
|
|
MyPageCounts.CanIncrement = true;
|
|
base.OnEndPage(writer, document);
|
|
DrawChangeBars(writer.DirectContent);
|
|
DrawMessages(writer.DirectContent);
|
|
if (!CreatingFoldoutPage)
|
|
DrawRuler(writer.DirectContent);
|
|
}
|
|
else
|
|
{
|
|
E_NumberingSequence numseq = MySection.MyDocStyle.NumberingSequence??0;
|
|
// if a foldout is only printing within its section, don't do increments on pagecounts:
|
|
if (numseq==E_NumberingSequence.WithinEachSection)
|
|
MyPageCounts.CanIncrement = false;
|
|
else
|
|
MyPageCounts.CanIncrement = true;
|
|
base.OnEndPage(writer, document);
|
|
if (!CreatingFoldoutPage)
|
|
DrawRuler(writer.DirectContent);
|
|
}
|
|
if (MySection.MyDocStyle.StructureStyle.Style==null || (MySection.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DontCountInTabOfCont) == 0)
|
|
CurrentTOCPageNumber++;
|
|
if (MySection.ActiveFormat.PlantFormat.FormatData.SectData.PrintPhoneList)
|
|
{
|
|
SectionConfig sc = MySection.MyConfig as SectionConfig;
|
|
if (sc.Section_PhoneList != null && sc.Section_PhoneList == "Y")
|
|
{
|
|
// yoffset the footer length + the size of the phone list:
|
|
float yoff = (float)MySection.MyDocStyle.Layout.FooterLength + PhoneListHeight + 12; // 12 is an extra line for the horizontal.
|
|
DocVersionConfig dvc = MySection.MyDocVersion.MyConfig as DocVersionConfig;
|
|
if (dvc != null)
|
|
DrawPhoneList(writer.DirectContent, (float)MySection.MyDocStyle.Layout.LeftMargin, (float)MySection.MyDocStyle.Layout.PageWidth, yoff, dvc.Print_PhoneList);
|
|
}
|
|
}
|
|
|
|
if (MySection.MyDocStyle.CenterLineX != null && !onBlankPage)
|
|
{
|
|
if ((MySection.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DoubleBoxHLS) == E_DocStructStyle.DoubleBoxHLS)
|
|
DrawHorizontal(writer.DirectContent, (float)MySection.MyDocStyle.Layout.LeftMargin, (float)MySection.MyDocStyle.Layout.PageWidth, (float)MySection.MyDocStyle.CenterLineYTop);
|
|
//if (MySection.ColumnMode > 0 && onBlankPage == false)
|
|
if (MySection.ColumnMode > 0)
|
|
DrawCenterLine(writer.DirectContent, MySection.MyDocStyle.Layout.LeftMargin + MySection.MyDocStyle.CenterLineX ?? 0, MySection.MyDocStyle.CenterLineYTop ?? 0, MySection.MyDocStyle.CenterLineYBottom ?? 0);
|
|
}
|
|
|
|
if (MySection.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
|
|
{
|
|
float left = (float)MySection.MyDocStyle.Layout.LeftMargin + 4.40f - 6; // used 4.40 -6 to line up with the macro & not touch two digit sub-step tabs.
|
|
float right = (float)MySection.MyDocStyle.Layout.PageWidth - .76f; // used -.76 to make bge alarm lines closest to lining up with macro
|
|
if (AlarmYoffStart > 0)
|
|
{
|
|
// draw vertical - either to the alarmyoffend or bottom of page
|
|
if (AlarmYoffEnd > 0) // ends on this page.
|
|
{
|
|
DrawVertical(writer.DirectContent, left, AlarmYoffStart, AlarmYoffEnd);
|
|
DrawVertical(writer.DirectContent, right, AlarmYoffStart, AlarmYoffEnd);
|
|
DrawVertical(writer.DirectContent, (right + left) / 2, AlarmYoffStart, AlarmYoffEnd);
|
|
DrawHorizontal(writer.DirectContent, left, right, AlarmYoffEnd);
|
|
AlarmYoffStart = 0;
|
|
AlarmYoffEnd = 0;
|
|
}
|
|
else
|
|
{
|
|
float yBottom = (float)(writer.DirectContent.PdfWriter.PageSize.Height - ((float)MySection.MyDocStyle.Layout.TopMargin + (float)MySection.MyDocStyle.Layout.PageLength));
|
|
DrawVertical(writer.DirectContent, left, AlarmYoffStart, yBottom);
|
|
DrawVertical(writer.DirectContent, right, AlarmYoffStart, yBottom);
|
|
DrawVertical(writer.DirectContent, (right + left) / 2, AlarmYoffStart, yBottom);
|
|
DrawHorizontal(writer.DirectContent, left, right, yBottom);
|
|
AlarmYoffStart = (float)writer.DirectContent.PdfWriter.PageSize.Height - (float)MySection.MyDocStyle.Layout.TopMargin;
|
|
}
|
|
}
|
|
}
|
|
PageListTopCheckOffHeader = null;
|
|
PageListLastCheckOffHeader = null;
|
|
YMultiplier = 1;
|
|
PrintedAPage = true;
|
|
}
|
|
|
|
private void DrawVertical(PdfContentByte cb, float x, float top, float bottom)
|
|
{
|
|
cb.SaveState();
|
|
if (PageListLayer != null) cb.BeginLayer(PageListLayer);
|
|
cb.SetColorStroke(new Color(PrintOverride.SvgColor));
|
|
cb.SetLineWidth(1.05f); // Tweak the line width to match vlnmacro
|
|
//cb.SetColorStroke(lineColor);
|
|
cb.MoveTo(x, top);
|
|
cb.LineTo(x, bottom);
|
|
cb.Stroke();
|
|
if (PageListLayer != null) cb.EndLayer();
|
|
cb.RestoreState();
|
|
}
|
|
|
|
private void DrawPhoneList(PdfContentByte pdfContentByte, float leftMargin, float pageWidth, float yOff, string plist)
|
|
{
|
|
// draw the line above the phone list:
|
|
yOff = yOff + 4; // move up 1/2 line:
|
|
DrawHorizontal(pdfContentByte, leftMargin, pageWidth, yOff);
|
|
|
|
pdfContentByte.SaveState();
|
|
if (PageListLayer != null) pdfContentByte.BeginLayer(PageListLayer);
|
|
pdfContentByte.SetColorStroke(new Color(PrintOverride.SvgColor));
|
|
|
|
// for each line, break it into phone items for printing. Note that 16bit code also supported
|
|
// a tabbing line - BGE wasn't using this in data at time of development. The following code may
|
|
// need expanded to support the tabbing/column definitions if this is found in data.
|
|
float lyoff = yOff - 4;
|
|
plist = plist.Replace("\r", "");
|
|
string[] lines = plist.Split("\n".ToCharArray());
|
|
DocStyle docstyle = MySection.MyDocStyle;
|
|
try
|
|
{
|
|
foreach (string clinex in lines)
|
|
{
|
|
string cline = clinex.TrimEnd();
|
|
if (cline != "")
|
|
{
|
|
// xoff handles the columns. The separator between phone items is a double space. A phone
|
|
// item may have a single space within it (this comes from 16bit implementation)
|
|
float xoff = (float)docstyle.Layout.LeftMargin;
|
|
int stLineindx = 0;
|
|
int endLineindx = cline.IndexOf(" ");
|
|
bool endOfLine = false;
|
|
while (!endOfLine)
|
|
{
|
|
if (endLineindx - stLineindx > 0)
|
|
{
|
|
string phone = cline.Substring(stLineindx, endLineindx - stLineindx);
|
|
float tmp = 0;
|
|
vlnText vt = new vlnText(pdfContentByte, null, phone, phone, xoff, lyoff, MySection.ActiveFormat.PlantFormat.FormatData.Font);
|
|
vt.ToPdf(pdfContentByte, 0, ref tmp, ref tmp);
|
|
xoff += 132; // columns in 16bit were a little more than 1 3/4 inches.
|
|
stLineindx = endLineindx;
|
|
if (stLineindx >= cline.Length) break;
|
|
while (cline[stLineindx] == ' ' && stLineindx < cline.Length) stLineindx++;
|
|
if (stLineindx >= cline.Length - 1) endOfLine = true;
|
|
else
|
|
{
|
|
endLineindx = cline.IndexOf(" ", stLineindx);
|
|
if (endLineindx == -1) endLineindx = cline.Length;
|
|
}
|
|
}
|
|
else
|
|
endOfLine = true;
|
|
}
|
|
lyoff = lyoff - vlnPrintObject.SixLinesPerInch;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_MyLog.Error("Error processing phone list.", ex);
|
|
}
|
|
if (PageListLayer != null) pdfContentByte.EndLayer();
|
|
pdfContentByte.RestoreState();
|
|
}
|
|
private void DrawHorizontal(PdfContentByte cb, float left, float right, float yoff)
|
|
{
|
|
// if there are gaps, check to be sure top isn't a double line box. If it's a box, don't draw the top line.
|
|
if (MyGaps != null && MyGaps.Count > 0 && MyGaps[0].YTop == (float)MySection.MyDocStyle.CenterLineYTop) return;
|
|
cb.SaveState();
|
|
if (PageListLayer != null) cb.BeginLayer(PageListLayer);
|
|
cb.SetColorStroke(new Color(PrintOverride.SvgColor));
|
|
//cb.SetColorStroke(lineColor);
|
|
cb.MoveTo(left, yoff);
|
|
cb.LineTo(right, yoff);
|
|
cb.Stroke();
|
|
if (PageListLayer != null) cb.EndLayer();
|
|
cb.RestoreState();
|
|
}
|
|
private Gaps _MyGaps;
|
|
public Gaps MyGaps
|
|
{
|
|
get
|
|
{
|
|
if (_MyGaps == null)
|
|
_MyGaps = new Gaps();
|
|
return _MyGaps;
|
|
}
|
|
}
|
|
public void AddGap(float top, float bottom, float left, float right)
|
|
{
|
|
float center = MySection.MyDocStyle.Layout.LeftMargin + MySection.MyDocStyle.CenterLineX ?? 0;
|
|
if(center == 0) return;
|
|
if (center > right || center < left) return;
|
|
MyGaps.Add(top, bottom);
|
|
}
|
|
private void DrawCenterLine(PdfContentByte cb, float xLoc, float yTop, float yBottom)
|
|
{
|
|
//iTextSharp.text.Color lineColor = new iTextSharp.text.Color(PrintOverride.OverrideTextColor(System.Drawing.Color.DarkOrange));
|
|
cb.SaveState();
|
|
if (PageListLayer != null) cb.BeginLayer(PageListLayer);
|
|
cb.SetLineWidth(.95f);
|
|
cb.SetColorStroke(new Color(PrintOverride.SvgColor));
|
|
//cb.SetColorStroke(lineColor);
|
|
cb.MoveTo(xLoc, yTop);
|
|
float ylast = yTop;
|
|
if (_MyGaps != null)
|
|
{
|
|
foreach (Gap gap in MyGaps)
|
|
{
|
|
cb.LineTo(xLoc, gap.YTop);
|
|
cb.MoveTo(xLoc, gap.YTop - (gap.YTop - gap.YBottom) * YMultiplier);
|
|
ylast = gap.YTop - (gap.YTop - gap.YBottom) * YMultiplier;
|
|
}
|
|
_MyGaps = null;
|
|
}
|
|
// put in for V.C. Summer
|
|
// the end message for EOP procedure 15.2 was at the very bottom of the page.
|
|
// the remaining center line was drawn past the page boarder. there was no need
|
|
// to print it for cases like that
|
|
if (ylast > yBottom)
|
|
cb.LineTo(xLoc, yBottom);
|
|
cb.Stroke();
|
|
if (PageListLayer != null) cb.EndLayer();
|
|
cb.RestoreState();
|
|
}
|
|
|
|
private bool SetDocStyleAndValues()
|
|
{
|
|
// if this document style has another style that is for pages other than first, we need to
|
|
// reset the document style off of this section AND reset docstyle values used
|
|
// AND reset the 'svg' data.
|
|
bool forceLoadSvg = false;
|
|
if ((MySection.MyDocStyle.StructureStyle.Where & E_DocStyleUse.UseOnFirstPage) > 0)
|
|
{
|
|
//Console.WriteLine("{0} ResetDocStyleAndValues", MySection.MyDocStyle.Name);
|
|
ItemInfo ii = (ItemInfo) MySection;
|
|
int indx = (int)MySection.MyDocStyle.IndexOtherThanFirstPage;
|
|
foreach (DocStyle ds in ii.ActiveFormat.PlantFormat.DocStyles.DocStyleList)
|
|
{
|
|
if (ds.Index == indx)
|
|
{
|
|
MySection.MyDocStyle = ds;
|
|
forceLoadSvg = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return forceLoadSvg;
|
|
}
|
|
public void ResetSvg()
|
|
{
|
|
Volian.Svg.Library.Svg sectSvg = BuildSvg(_MySection, true);
|
|
if (sectSvg != null) MySvg = sectSvg;
|
|
}
|
|
private float? _YTopMargin = null;
|
|
public float? YTopMargin
|
|
{
|
|
get { return _YTopMargin; }
|
|
set { _YTopMargin = value; }
|
|
}
|
|
private void DrawRuler(PdfContentByte cb)
|
|
{
|
|
if (DebugLayer == null) return;
|
|
Layout layout = MySection.MyDocStyle.Layout;
|
|
cb.SaveState();
|
|
cb.BeginLayer(DebugLayer);
|
|
float x = (cb.PdfWriter.PageSize.Left + cb.PdfWriter.PageSize.Right) / 2;
|
|
cb.SetLineWidth(.1F);
|
|
cb.SetColorStroke(new Color(System.Drawing.Color.CornflowerBlue));
|
|
float yTop = (float)(cb.PdfWriter.PageSize.Height - layout.TopMargin);
|
|
if(YTopMargin != null) yTop = (float)YTopMargin;
|
|
float yBottom = (float)(cb.PdfWriter.PageSize.Height - (layout.TopMargin + layout.PageLength));
|
|
//Console.WriteLine("'{0}',{1},{2}", MySection.MyDocStyle.Name, yTop, yBottom);
|
|
cb.MoveTo(x, yTop);
|
|
cb.LineTo(x, yBottom);
|
|
int i = 0;
|
|
for (float y = yTop; y >= yBottom; y -= 12)
|
|
{
|
|
float w = 10;
|
|
if (i % 10 == 0) w = 30;
|
|
else if (i % 5 == 0) w = 20;
|
|
cb.SetLineWidth(w / 30);
|
|
i++;
|
|
cb.MoveTo(x - w, y);
|
|
cb.LineTo(x, y);
|
|
cb.Stroke();
|
|
}
|
|
i = 0;
|
|
for (float y = yTop; y >= yBottom; y -= 10.1F)
|
|
{
|
|
float w = 10;
|
|
if (i % 10 == 0) w = 30;
|
|
else if (i % 5 == 0) w = 20;
|
|
cb.SetLineWidth(w / 30);
|
|
i++;
|
|
cb.MoveTo(x + w, y-1);
|
|
cb.LineTo(x, y-1);
|
|
cb.Stroke();
|
|
}
|
|
cb.SetLineWidth(.1F);
|
|
cb.Rectangle((float)layout.LeftMargin, yTop, (float)layout.PageWidth - (float)layout.LeftMargin, yBottom - yTop);
|
|
float yFooter = yBottom+(float)layout.FooterLength;
|
|
cb.MoveTo((float)layout.LeftMargin,yFooter);
|
|
cb.LineTo((float)layout.PageWidth, yFooter);
|
|
float yRuler = 612;
|
|
cb.MoveTo(0, yRuler);
|
|
cb.LineTo(612, yRuler);
|
|
for (float x1 = 0; x1 < 612; x1 += 6) // tic marks every 1/12 inch
|
|
{
|
|
if (x1 % 72 == 0)
|
|
{
|
|
cb.MoveTo(x1, yRuler-20);
|
|
cb.LineTo(x1, yRuler+20);
|
|
}
|
|
else if (x1 % 36 == 0)
|
|
{
|
|
cb.MoveTo(x1, yRuler-10);
|
|
cb.LineTo(x1, yRuler+10);
|
|
}
|
|
else
|
|
{
|
|
cb.MoveTo(x1, yRuler-5);
|
|
cb.LineTo(x1, yRuler);
|
|
}
|
|
}
|
|
for (float x1 = 0; x1 < 612; x1 += 7.2f) // tic marks every 1/10 inch
|
|
{
|
|
if (x1 % 72 == 0)
|
|
{
|
|
cb.MoveTo(x1, yRuler);
|
|
cb.LineTo(x1, yRuler + 20);
|
|
}
|
|
else if (x1 % 36 == 0)
|
|
{
|
|
cb.MoveTo(x1, yRuler);
|
|
cb.LineTo(x1, yRuler + 10);
|
|
}
|
|
else
|
|
{
|
|
cb.MoveTo(x1, yRuler);
|
|
cb.LineTo(x1, yRuler + 5);
|
|
}
|
|
}
|
|
//cb.MoveTo(122.4F, 0); //WCN2 HLS
|
|
//cb.LineTo(122.4F, cb.PdfWriter.PageSize.Height);
|
|
//cb.MoveTo(78, 0); // HLP HLS
|
|
//cb.LineTo(78, cb.PdfWriter.PageSize.Height);
|
|
//cb.MoveTo(441, 0); // HLP cover page date
|
|
//cb.LineTo(441, cb.PdfWriter.PageSize.Height);
|
|
//cb.MoveTo(71.4F, 0); // WCN Purpose page, Revision: {REV}
|
|
//cb.LineTo(71.4F, cb.PdfWriter.PageSize.Height);
|
|
cb.Stroke();
|
|
cb.EndLayer();
|
|
cb.RestoreState();
|
|
}
|
|
private void AddBookmarks(PdfWriter writer)
|
|
{
|
|
foreach (PageBookmark pb in PageBookmarks)
|
|
{
|
|
if (!pb.MyItemInfo.IsSection && MyPdfOutline != null)
|
|
new PdfOutline(MyPdfOutline, pb.PdfDestination,Regex.Replace(pb.Title, @"\\{Prerequisite Step: .*?\\}", ""), false);
|
|
else
|
|
{
|
|
PdfDestination dest = new PdfDestination(PdfDestination.FIT);
|
|
MyPdfOutline = new PdfOutline(writer.DirectContent.RootOutline, dest, pb.Title, false);
|
|
}
|
|
}
|
|
PageBookmarks.Clear();
|
|
}
|
|
private void DrawMessages(PdfContentByte cb)
|
|
{
|
|
float tmp = 0;
|
|
if (TopMessage != null)
|
|
{
|
|
TopMessage.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
TopMessage = null; // Only output it once.
|
|
}
|
|
if (TopMessageRs != null && TopMessageRs.Count > 0)
|
|
{
|
|
foreach (vlnText vt in TopMessageRs)
|
|
{
|
|
vt.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
}
|
|
TopMessageRs = null; // Only output it once.
|
|
}
|
|
if (TopMessageSub1s != null)
|
|
{
|
|
foreach (vlnText vts1 in TopMessageSub1s)
|
|
{
|
|
vts1.YOffset = AlarmYoffStart - 3 * vlnPrintObject.SixLinesPerInch;
|
|
vts1.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
}
|
|
TopMessageSub1s = null; // Only output it once.
|
|
}
|
|
if (TopMessageSub2s != null)
|
|
{
|
|
foreach (vlnText vts2 in TopMessageSub2s)
|
|
{
|
|
vts2.YOffset = AlarmYoffStart - 3 * vlnPrintObject.SixLinesPerInch;
|
|
vts2.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
}
|
|
TopMessageSub2s = null; // Only output it once.
|
|
}
|
|
if (BottomMessage != null)
|
|
{
|
|
BottomMessage.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
BottomMessage = null; // Only output it once.
|
|
}
|
|
if (BottomMessageR != null)
|
|
{
|
|
BottomMessageR.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
BottomMessageR = null; // Only output it once.
|
|
}
|
|
if (BottomMessageA != null)
|
|
{
|
|
BottomMessageA.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
BottomMessageA = null; // Only output it once.
|
|
}
|
|
}
|
|
public void DrawBottomMessage(PdfContentByte cb)
|
|
{
|
|
float tmp = 0;
|
|
if (BottomMessage != null)
|
|
{
|
|
BottomMessage.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
BottomMessage = null; // Only output it once.
|
|
}
|
|
}
|
|
private void DrawChangeBars(PdfContentByte cb)
|
|
{
|
|
float tmp = 0;
|
|
foreach (vlnChangeBar vcb in MyChangeBars)
|
|
{
|
|
// TODO: Pass in zeroes because topdf is inherited.
|
|
vcb.ToPdf(cb, 0, ref tmp, ref tmp);
|
|
}
|
|
_MyChangeBars = new List<vlnChangeBar>();
|
|
}
|
|
#region SectionLevelData
|
|
private ChangeBarDefinition _ChangeBarDefinition;
|
|
public ChangeBarDefinition ChangeBarDefinition
|
|
{
|
|
get { return _ChangeBarDefinition; }
|
|
set { _ChangeBarDefinition = value; }
|
|
}
|
|
#endregion
|
|
private PdfLayer _TextLayer;
|
|
public PdfLayer TextLayer
|
|
{
|
|
get { return _TextLayer; }
|
|
set { _TextLayer = value; }
|
|
}
|
|
private PdfLayer _DebugLayer;
|
|
public PdfLayer DebugLayer
|
|
{
|
|
get { return _DebugLayer; }
|
|
set { _DebugLayer = value; }
|
|
}
|
|
private VEPROMS.CSLA.Library.SectionInfo _MySection;
|
|
public VEPROMS.CSLA.Library.SectionInfo MySection
|
|
{
|
|
get { return _MySection; }
|
|
set
|
|
{
|
|
_MySection = value;
|
|
MySectionTitle = ((_MySection.DisplayNumber ?? "")=="" ? "" : _MySection.DisplayNumber + " - ") + _MySection.DisplayText;
|
|
bool forceLoadSvg = false;
|
|
//if (value.SectionConfig.Section_Pagination == SectionConfig.SectionPagination.Separate && value.MyDocStyle.ResetFirstPageOnSection)
|
|
// DidFirstPageDocStyle = false;
|
|
if (DidFirstPageDocStyle)
|
|
forceLoadSvg = SetDocStyleAndValues(); // this method also gets the SVG (the 'else' part of this)
|
|
Volian.Svg.Library.Svg sectSvg = BuildSvg(_MySection, forceLoadSvg);
|
|
if (sectSvg != null) MySvg = sectSvg;
|
|
_YTopMargin = null;
|
|
}
|
|
}
|
|
private string _MySectionTitle;
|
|
public string MySectionTitle
|
|
{
|
|
get { return _MySectionTitle; }
|
|
set { _MySectionTitle = value; }
|
|
}
|
|
private int _MaxRNO;
|
|
public int MaxRNO
|
|
{
|
|
get
|
|
{
|
|
return _MySection.ColumnMode;
|
|
}
|
|
}
|
|
private int _CurrentPageOf = 0;
|
|
public int CurrentPageOf
|
|
{
|
|
get { return _CurrentPageOf; }
|
|
set { _CurrentPageOf = value; }
|
|
}
|
|
private string _Rev = string.Empty;
|
|
public string Rev
|
|
{
|
|
get { return _Rev; }
|
|
set { _Rev = value; }
|
|
}
|
|
private string _RevDate = string.Empty;
|
|
public string RevDate
|
|
{
|
|
get { return _RevDate; }
|
|
set { _RevDate = value; }
|
|
}
|
|
private bool _DoFloatingFoldout = true;
|
|
public bool DoFloatingFoldout
|
|
{
|
|
get { return _DoFloatingFoldout; }
|
|
set { _DoFloatingFoldout = value; }
|
|
}
|
|
|
|
private List<vlnChangeBar> _MyChangeBars = new List<vlnChangeBar>();
|
|
public List<vlnChangeBar> MyChangeBars
|
|
{
|
|
get { return _MyChangeBars; }
|
|
set { _MyChangeBars = value; }
|
|
}
|
|
public void AddChangeBar(vlnChangeBar vcb, string cbmess)
|
|
{
|
|
if (vcb == null) return;
|
|
vlnChangeBar prevCB = null;
|
|
foreach (vlnChangeBar cb in MyChangeBars)
|
|
{
|
|
// only look at changebars in same column
|
|
if (cb.XOffset == vcb.XOffset)
|
|
{
|
|
// if the two change bars end at same location, set prevCB which will
|
|
// adjust the length (top position) of the change bar. This condition
|
|
// also flags that the change bar texts overlap.
|
|
if (cb.YChangeBarBottom == vcb.YChangeBarBottom) prevCB = cb;
|
|
|
|
// continuous case, if changes bars overlap, adjust size and don't add new one to
|
|
// the MyChangeBars list.
|
|
if (MySection.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ContinuousChangeBars ||
|
|
MySection.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds)
|
|
{
|
|
if (OverlapOrSpan(cb, vcb))
|
|
{
|
|
if (prevCB == null) prevCB = cb;
|
|
else if (prevCB.YChangeBarBottom > cb.YChangeBarBottom) prevCB = cb;
|
|
cb.BottomIsTable = (vcb.MyParent.MyItemInfo.IsTable);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// if this and the prevCB overlap, adjust yoffset/height/ybottom in the prevCB so that both change bars are
|
|
// included in this Dictionary item. A new vlnChangeBar is not added to the MyChangeBars list, the current
|
|
// one that overlaps with the new is adjusted.
|
|
if (prevCB != null)
|
|
{
|
|
// Bottom for both change bars is same, adjust top (YOffset) and height.
|
|
if (prevCB.YChangeBarBottom == vcb.YChangeBarBottom)
|
|
{
|
|
prevCB.YOffset = Math.Max(prevCB.YOffset, vcb.YOffset);
|
|
float yChangeBarBottomExtend = prevCB.YChangeBarBottomExtend;
|
|
prevCB.Height = Math.Max(prevCB.Height, vcb.Height);
|
|
prevCB.YExtendLine = prevCB.YChangeBarBottom - Math.Min(yChangeBarBottomExtend, vcb.YChangeBarBottomExtend); //Math.Max(prevCB.YExtendLine, vcb.YExtendLine);
|
|
// if a change bar message at this ychangebarbottom exists, see which message is used
|
|
if (cbmess != null && prevCB.Messages.ContainsKey(prevCB.YChangeBarBottom)) UpdateCbMessage(cbmess, prevCB, vcb.XOffset);
|
|
return;
|
|
}
|
|
// Bottom locations are not the same, but another change bar is not added, i.e. the
|
|
// length of the line is adjusted.
|
|
prevCB.YOffset = Math.Max(prevCB.YOffset, vcb.YOffset);
|
|
float yChangeBarBottomExtend1 = prevCB.YChangeBarBottomExtend;
|
|
prevCB.YChangeBarBottom = Math.Min(prevCB.YChangeBarBottom, vcb.YChangeBarBottom);
|
|
prevCB.YExtendLine = prevCB.YChangeBarBottom - Math.Min(yChangeBarBottomExtend1, vcb.YChangeBarBottomExtend); //Math.Max(prevCB.YExtendLine, vcb.YExtendLine);
|
|
// Two messages at this location, determine which one to use
|
|
if (cbmess != null && prevCB.Messages.ContainsKey(prevCB.YChangeBarBottom)) UpdateCbMessage(cbmess, prevCB, vcb.XOffset);
|
|
|
|
// no message at this location, just add it.
|
|
else if (cbmess != null)
|
|
prevCB.Messages.Add(vcb.YChangeBarBottom, new vlnChangeBarMessage(vcb.MyParent.XOffset, cbmess));
|
|
return;
|
|
}
|
|
|
|
// There was no overlap, add a message if it exists, and then add the change bar to the MyChangeBars list.
|
|
if (cbmess != null) vcb.Messages.Add(vcb.YChangeBarBottom, new vlnChangeBarMessage(vcb.MyParent.XOffset, cbmess));
|
|
MyChangeBars.Add(vcb);
|
|
}
|
|
|
|
private static void UpdateCbMessage(string cbmess, vlnChangeBar prevCB, float xoff)
|
|
{
|
|
// If there are two messages at the same location, for example an AER change bar & and RNO
|
|
// change bar, and the messages have different text, see which change bar message should be
|
|
// added, i.e. use the one in 'rno', the greatest x value.
|
|
vlnChangeBarMessage tmp = prevCB.Messages[prevCB.YChangeBarBottom];
|
|
if (cbmess != tmp.Message)
|
|
{
|
|
if (xoff > tmp.ParentX)
|
|
{
|
|
prevCB.Messages.Remove(prevCB.YChangeBarBottom);
|
|
prevCB.Messages.Add(prevCB.YChangeBarBottom, new vlnChangeBarMessage(xoff, cbmess));
|
|
}
|
|
}
|
|
}
|
|
private bool OverlapOrSpan(vlnChangeBar cb, vlnChangeBar vcb)
|
|
{
|
|
float tolerance = vlnPrintObject.SixLinesPerInch;
|
|
if (cb.MyParent.MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm &&
|
|
(vcb.MyParent.MyItemInfo.IsTable || cb.MyParent.MyItemInfo.IsTable || cb.BottomIsTable)) tolerance *= 1.5f;
|
|
|
|
if (cb.MyParent.MyItemInfo.MyHLS.ItemID != vcb.MyParent.MyItemInfo.MyHLS.ItemID) return false;
|
|
// cb.Yoffset is within range of vcb:
|
|
if (cb.YOffset <= vcb.YOffset &&
|
|
cb.YOffset >= (vcb.YChangeBarBottomExtend - tolerance)) return true;
|
|
// cb.YChangeBarBottom is within range of vcb:
|
|
if ((cb.YChangeBarBottomExtend - tolerance) <= vcb.YOffset &&
|
|
cb.YChangeBarBottomExtend >= (vcb.YChangeBarBottomExtend - tolerance)) return true;
|
|
// vcb.Yoffset is within range of cb:
|
|
if (vcb.YOffset <= cb.YOffset &&
|
|
vcb.YOffset >= (cb.YChangeBarBottomExtend - tolerance)) return true;
|
|
// vcb.YChangeBarBottom is within range of cb:
|
|
if ((vcb.YChangeBarBottomExtend - tolerance) <= cb.YOffset &&
|
|
vcb.YChangeBarBottomExtend >= (cb.YChangeBarBottomExtend - tolerance)) return true;
|
|
return false;
|
|
}
|
|
private PromsPrinter _MyPromsPrinter;
|
|
public PromsPrinter MyPromsPrinter
|
|
{
|
|
get { return _MyPromsPrinter; }
|
|
set { _MyPromsPrinter = value; }
|
|
}
|
|
private int _MyRomanPage = 1;
|
|
public VlnSvgPageHelper(VEPROMS.CSLA.Library.SectionInfo mySection, PromsPrinter myPromsPrinter, string hlsText, int hlsItemId)
|
|
: base()
|
|
{
|
|
HLSText = hlsText;
|
|
HasHLSTextId = hlsItemId;
|
|
MySection = mySection;
|
|
MyPromsPrinter = myPromsPrinter;
|
|
}
|
|
private Volian.Svg.Library.Svg BuildSvg(VEPROMS.CSLA.Library.SectionInfo mySection, bool forceLoad)
|
|
{
|
|
// if mysection uses continuous pagination, and the previous section uses the same format,
|
|
// and the docstyle is set to use on first page only,
|
|
// then set section to use the Use On Rest of Pages
|
|
//SectionConfig.SectionPagination sPag = SectionConfig.SectionPagination.Separate;
|
|
//if (mySection.IsStepSection && mySection.MyPrevious != null && mySection.MyPrevious.IsStepSection)
|
|
//{
|
|
// SectionConfig sc = mySection.MyConfig as SectionConfig;
|
|
// sPag = sc.Section_Pagination;
|
|
// if (sPag == SectionConfig.SectionPagination.Continuous)
|
|
// {
|
|
// if (MySection.MyDocStyle.StructureStyle.Where == E_DocStyleUse.UseOnFirstPage)
|
|
// MySection.DidFirstPageDocStyle = true;
|
|
// }
|
|
//}
|
|
VEPROMS.CSLA.Library.FormatInfo activeFormat = mySection.ActiveFormat;
|
|
VEPROMS.CSLA.Library.DocStyle docStyle = mySection.MyDocStyle;
|
|
Volian.Svg.Library.Svg mySvg = null;
|
|
mySvg = SvgSerializer<Volian.Svg.Library.Svg>.StringDeserialize(BuildMyText(activeFormat));
|
|
mySvg.ViewBox.Height = 1100;
|
|
mySvg.ViewBox.Width = 850;
|
|
mySvg.Height = new SvgMeasurement(11, E_MeasurementUnits.IN);
|
|
mySvg.Width = new SvgMeasurement(8.5F, E_MeasurementUnits.IN);
|
|
mySvg.LeftMargin = (float)docStyle.Layout.LeftMargin;
|
|
mySvg.TopMargin = 9.6F;
|
|
VEPROMS.CSLA.Library.PageStyle pageStyle = docStyle.pagestyle;
|
|
AddPageListItems(mySvg, pageStyle, mySection, forceLoad);
|
|
mySvg.ProcessText += new SvgProcessTextEvent(mySvg_ProcessText);
|
|
// if this section had a previous section and this is continuous, don't generate the svg for
|
|
// it, we'll use the previous section. The only thing we need to do is to process through the
|
|
// pagelist items in case there are some section items, for example the checkoff header needs
|
|
// to be processed for each section whether or not it is continuous.
|
|
SectionConfig.SectionPagination sPag = SectionConfig.SectionPagination.Separate;
|
|
if (mySection.MyContent.Number.ToUpper() != "FOLDOUT" && mySection.IsStepSection && mySection.MyPrevious != null && mySection.MyPrevious.IsStepSection)
|
|
{
|
|
SectionConfig sc = mySection.MyConfig as SectionConfig;
|
|
sPag = sc.Section_Pagination;
|
|
}
|
|
//if (sPag == SectionConfig.SectionPagination.Continuous && !mySection.DidFirstPageDocStyle) return null;
|
|
if (forceLoad) return mySvg;
|
|
if (sPag == SectionConfig.SectionPagination.Continuous) return null;
|
|
return mySvg;
|
|
}
|
|
public PageCounts MyPageCounts = null;
|
|
public PageCounts MyTOCPageCounts = null;
|
|
public Dictionary<string, int> MyTOCPageNums = null;
|
|
private static Regex regexFindToken = new Regex("{[^{}]*}");
|
|
private static Regex regexFindSubToken = new Regex(@"\[[^{}]*\]");
|
|
private string mySvg_ProcessText(object sender, SvgProcessTextArgs args)
|
|
{
|
|
if (args.MyText == null) return string.Empty; // Needed for empty genmac text (was space in 16bit files)
|
|
if (!args.MyText.Contains("{"))
|
|
return args.MyText;
|
|
/*
|
|
* Check if tokens for handling page counts ({PAGE} {OF} etc). if so, do templates.
|
|
*/
|
|
if (args.MyText.Contains("{DOCCURPAGE}") || args.MyText.Contains("{DOCTOTPAGE}"))
|
|
{
|
|
string key = "DocCurPage." + MySection.ItemID;
|
|
string txt = args.MyText.Replace("{DOCCURPAGE}", "{PAGE}").Replace("{DOCTOTPAGE}", "{OF}");
|
|
MyPdfContentByte.AddTemplate(MyPageCounts.AddToTemplateList(key, MyPdfWriter, txt, args.MySvgText.Font, args.MySvgText.Align, args.MySvgText.FillColor), args.MySvgScale.X(args.MySvgText.X), args.MySvgScale.Y(MyPdfContentByte, args.MySvgText.Y));
|
|
return string.Empty;
|
|
}
|
|
//if (args.MyText.Contains("{ROMANPAGE}"))
|
|
//{
|
|
// //return args.MyText.Replace("{ROMANPAGE}", ItemInfo.RomanNumbering(_MyRomanPage++).ToLower());
|
|
// string key = "RomanPage." + MySection.ItemID;
|
|
// string txt = args.MyText;
|
|
// MyPdfContentByte.AddTemplate(MyPageCounts.AddToTemplateList(key, MyPdfWriter, txt, args.MySvgText.Font, args.MySvgText.Align, args.MySvgText.FillColor), args.MySvgScale.X(args.MySvgText.X), args.MySvgScale.Y(MyPdfContentByte, args.MySvgText.Y));
|
|
// return string.Empty;
|
|
//}
|
|
if (args.MyText.Contains("{SECONDARYPAGE}") || args.MyText.Contains("{SECONDARYOF}"))
|
|
{
|
|
string key = "SecondaryPage." + MySection.ItemID;
|
|
string txt = args.MyText.Replace("{SECONDARYPAGE}", "{PAGE}").Replace("{SECONDARYOF}", "{OF}");
|
|
MyPdfContentByte.AddTemplate(MyPageCounts.AddToTemplateList(key, MyPdfWriter, txt, args.MySvgText.Font, args.MySvgText.Align, args.MySvgText.FillColor), args.MySvgScale.X(args.MySvgText.X), args.MySvgScale.Y(MyPdfContentByte, args.MySvgText.Y));
|
|
return string.Empty;
|
|
}
|
|
string tocKey = "TOC" + MySection.ItemID.ToString();
|
|
if (args.MyText.Contains("{PAGE}") || args.MyText.Contains("{OF}"))
|
|
{
|
|
|
|
#region numberingseq
|
|
/*
|
|
public enum E_NumberingSequence : uint
|
|
{
|
|
NoPageNum = 0,
|
|
WithSteps = 1, Add to original steps section page count.
|
|
WithinEachDocStyle = 2,
|
|
WithinEachSection = 3,
|
|
WithinEachDocStyle1 = 4,
|
|
GroupedByPagination = 5,
|
|
GroupedByLevel = 6,
|
|
WithStepsAndSecondaryPageNumber = 7,
|
|
WithStepsAndSecondaryPageNumberGroupedByLevel = 8,
|
|
Like6_ButDoesntNeedSubsection = 9,
|
|
Like6_ButDoesntNeedSubsection1 = 10
|
|
};
|
|
*/
|
|
#endregion
|
|
// default for the key is to make it NumberingSequence. Then handle
|
|
// specific cases.
|
|
string key = ((int)MySection.MyDocStyle.NumberingSequence).ToString();
|
|
|
|
E_NumberingSequence numseq = MySection.MyDocStyle.NumberingSequence??0;
|
|
switch (numseq)
|
|
{
|
|
case E_NumberingSequence.WithSteps: // Number with 'originalstepsection'
|
|
ProcedureInfo pc = MySection.MyProcedure;
|
|
int sectid = 0;
|
|
foreach (SectionInfo si in pc.Sections)
|
|
{
|
|
SectionConfig sc = si.MyConfig as SectionConfig;
|
|
if (sc.Section_OriginalSteps == "Y")
|
|
{
|
|
sectid = si.ItemID;
|
|
break;
|
|
}
|
|
}
|
|
if (sectid != 0) key = (int)E_NumberingSequence.WithinEachSection + "." + sectid;
|
|
break;
|
|
case E_NumberingSequence.WithinEachDocStyle:
|
|
key = key + "." + MySection.ActiveFormat.FormatID + "." + MySection.MyDocStyle.Index;
|
|
break;
|
|
case E_NumberingSequence.WithinEachSection:
|
|
key = key + "." + MySection.ItemID;
|
|
break;
|
|
case E_NumberingSequence.GroupedByLevel:
|
|
case E_NumberingSequence.Like6_ButDoesntNeedSubsection:
|
|
if (MySection.MyParent.IsSection)
|
|
key = key + "." + MySection.MyParent.ItemID;
|
|
else
|
|
key = key + "." + MySection.ItemID;
|
|
break;
|
|
case E_NumberingSequence.WithStepsAndSecondaryPageNumber:
|
|
// For this one, we'll do two keys and templates. One will go with the main steps
|
|
// section and one will be for this secondary section.
|
|
ProcedureInfo pc1 = MySection.MyProcedure;
|
|
int psectid = 0;
|
|
foreach (SectionInfo si in pc1.Sections)
|
|
{
|
|
SectionConfig sc = si.MyConfig as SectionConfig;
|
|
if (sc.Section_OriginalSteps == "Y")
|
|
{
|
|
psectid = si.ItemID;
|
|
break;
|
|
}
|
|
}
|
|
if (psectid != 0)
|
|
{
|
|
key = (int)E_NumberingSequence.WithinEachSection + "." + psectid;
|
|
PdfTemplate tmp1 = MyPageCounts.AddToTemplateList(key, MyPdfWriter, args.MyText, args.MySvgText.Font, args.MySvgText.Align, args.MySvgText.FillColor);
|
|
}
|
|
break;
|
|
}
|
|
PdfTemplate tmp = MyPageCounts.AddToTemplateList(key, MyPdfWriter, args.MyText, args.MySvgText.Font, args.MySvgText.Align, args.MySvgText.FillColor);
|
|
// Proms page numbering designed requires a "{PAGE}" token to increment the page counter. So the easiest way
|
|
// to do that was to add a "{PAGE}" token to every page that is flagged as not to be printed.
|
|
if (!args.MyText.StartsWith("Non-printing ")) MyPdfContentByte.AddTemplate(tmp, args.MySvgScale.X(args.MySvgText.X), args.MySvgScale.Y(MyPdfContentByte, args.MySvgText.Y));
|
|
return string.Empty;
|
|
}
|
|
if (args.MyText.Contains("{FINALPAGE}"))
|
|
{
|
|
if (MySection.ItemID == FinalMessageSectionID)
|
|
{
|
|
string key = "FinalPage";
|
|
MyPdfContentByte.AddTemplate(MyPageCounts.AddToTemplateList(key, MyPdfWriter, args.MyText, MySection.MyDocStyle.Final.Message, args.MySvgText.Font, args.MySvgText.Align, args.MySvgText.FillColor), args.MySvgScale.X(args.MySvgText.X), args.MySvgScale.Y(MyPdfContentByte, args.MySvgText.Y));
|
|
}
|
|
return string.Empty;
|
|
}
|
|
return regexFindToken.Replace(args.MyText, new MatchEvaluator(ReplacePageListToken));
|
|
}
|
|
private string BuildMyText(VEPROMS.CSLA.Library.FormatInfo activeFormat)
|
|
{
|
|
string sGenMac = activeFormat.GenMac;
|
|
if (sGenMac == null || sGenMac == "")
|
|
{
|
|
// If subformat and does not have its own genmac, find an inherited genmac.
|
|
FormatInfo tmpf = FormatInfo.Get(activeFormat.ParentID);
|
|
while (tmpf.FormatID!=1 && (sGenMac==null||sGenMac==""))
|
|
{
|
|
sGenMac = tmpf.GenMac;
|
|
tmpf = FormatInfo.Get(tmpf.ParentID);
|
|
}
|
|
if (sGenMac == null || sGenMac == "")
|
|
sGenMac = "<svg/>";// return "";
|
|
}
|
|
if (!sGenMac.Contains("xmlns"))
|
|
sGenMac = sGenMac.Replace("<svg ", "<svg xmlns='http://www.w3.org/2000/svg' ");
|
|
XmlDocument xDocGenMac = new XmlDocument();
|
|
xDocGenMac.LoadXml(sGenMac); // Add xmlns if necessary
|
|
Volian.Svg.Library.Svg mySvg = new Volian.Svg.Library.Svg();
|
|
SvgDefine def = new SvgDefine();
|
|
mySvg.Add(def);
|
|
def.ID = "GenMac Templates";
|
|
string str = SvgSerializer<Volian.Svg.Library.Svg>.StringSerialize(mySvg);
|
|
XmlDocument xDocPrintout = new XmlDocument();
|
|
xDocPrintout.LoadXml(str);
|
|
XmlNode xn = xDocPrintout.DocumentElement.ChildNodes[0];
|
|
xn.AppendChild(xDocPrintout.ImportNode(xDocGenMac.DocumentElement, true));
|
|
return xDocPrintout.OuterXml;
|
|
}
|
|
private string FirstAndLast(string token)
|
|
{
|
|
// strip the curly braces and return the first and last character
|
|
// For example Header1 becomes H1 and Box2 becomes B2
|
|
return token.Substring(1, 1) + token.Substring(token.Length - 2, 1);
|
|
}
|
|
private static Regex regexJustTokens = new Regex(@"^{([^{}]*}{)*[^{}]*}$");
|
|
|
|
// The following variables are used to keep track of whether a check off header should be printed
|
|
// if the {CHKOFFHEADING} pagelist item is found. PageListTopCheckOffHeader is the text that
|
|
// should be printed at the top of the page. PageListLastCheckOffHeader is the last header that was
|
|
// printed (if a header is on the page, and another is to be printed, it doesn't get printed if it
|
|
// is the same as the previous) and PageListCheckOffHeader is the page list item converted to a
|
|
// SvgText - this stores X/Y location, etc.
|
|
public string PageListTopCheckOffHeader = null;
|
|
public string PageListLastCheckOffHeader = null;
|
|
public SvgText PageListCheckOffHeader = null;
|
|
|
|
public Dictionary<string, bool> PgLogicals;
|
|
private void AddPageListItems(Volian.Svg.Library.Svg mySvg, VEPROMS.CSLA.Library.PageStyle pageStyle, VEPROMS.CSLA.Library.SectionInfo section, bool forceLoad)
|
|
{
|
|
//Console.WriteLine("{0}", section.ActiveFormat.Name);
|
|
//Console.WriteLine("{0} pgstyle {1} section", pageStyle.Name,section.DisplayText);
|
|
if (PgLogicals == null) PgLogicals = new Dictionary<string, bool>();
|
|
else PgLogicals.Clear();
|
|
|
|
PageListCheckOffHeader = null;
|
|
// If this is a continuous section, then the only pagelist items we want are section type since
|
|
// we are still on the same page. - CHECK IF ON SAME PAGE!!!!
|
|
SectionConfig.SectionPagination sPag = SectionConfig.SectionPagination.Separate;
|
|
if (section.IsStepSection && section.MyPrevious != null && section.MyPrevious.IsStepSection && section.MyContent.Number.ToUpper() != "FOLDOUT")
|
|
{
|
|
SectionConfig sc = section.MyConfig as SectionConfig;
|
|
sPag = sc.Section_Pagination;
|
|
}
|
|
SvgGroup svgGroup = new SvgGroup();
|
|
|
|
//int defPtPerRow = 72 / 6;
|
|
//int curLPI = 6; // default
|
|
//int prevLPI = 6;
|
|
//float PrevRow = 0;
|
|
//float rowAdj = 0; // = 18;
|
|
foreach (VEPROMS.CSLA.Library.PageItem pageItem in pageStyle.PageItems)
|
|
{
|
|
if (pageItem.Token == null) continue; // can be null if token is dependent on PSI lookup!
|
|
DidHLSText = false; // reset to false for this group of tokens.
|
|
//if (pageItem.Token.Contains("HLSTEXT"))
|
|
// Console.WriteLine("{0} - PageList Token", pageItem.Token);
|
|
|
|
// the pagelist 'justify="{PSNotFirst}"' flag only puts item out if not on first page of section, check for this
|
|
if (((pageItem.Justify & VEPROMS.CSLA.Library.E_Justify.PSNotFirst) == VEPROMS.CSLA.Library.E_Justify.PSNotFirst)
|
|
&& PrintedSectionPage == 0)
|
|
{
|
|
PrintedSectionPage++;
|
|
continue;
|
|
}
|
|
|
|
VE_Font useFontForCheckOffHeader = null;
|
|
if (forceLoad || (sPag == SectionConfig.SectionPagination.Separate || ((sPag == SectionConfig.SectionPagination.Continuous || sPag ==0 )&& (pageItem.Row < 0))))
|
|
{
|
|
//if (PrevRow > 0)
|
|
//{
|
|
// //float pgRow = (float)(pageItem.Row + rowAdj);
|
|
// if (curLPI != prevLPI)
|
|
// {
|
|
// int prow = (int)(PrevRow / defPtPerRow);
|
|
// int nrows = ((int)(pageItem.Row / defPtPerRow)) - prow;
|
|
// rowAdj += (float)Math.Abs(((nrows * (72 / curLPI)) - ((nrows * defPtPerRow) + rowAdj)));
|
|
// //rowAdj += (float)(((pgRow - PrevRow) / (72 * prevLPI)) * (72 / curLPI));
|
|
// prevLPI = curLPI;
|
|
// }
|
|
//}
|
|
MatchCollection matches = regexFindToken.Matches(pageItem.Token);
|
|
if (matches.Count > 0)
|
|
{
|
|
string plstr = "";
|
|
// When a pagelist line (row) has more than one token that is resolved to text, each resolved token text was place on top
|
|
// of each other. Use a temporary string (plstr) to process the pagelist tokens for each pagelist line (row) before adding
|
|
// it to the svgGroup.
|
|
plstr = pageItem.Token;
|
|
foreach (Match match in matches)
|
|
{
|
|
string token = match.Value;
|
|
//token = Regex.Replace(token, @"[\xB3-\xDF]", " ");
|
|
|
|
// handle any conditional PS tokens
|
|
if (plstr.Contains(@"PS="))
|
|
{
|
|
ProcedureConfig procConfig = new ProcedureConfig(section.MyProcedure.MyContent.Config);
|
|
if (procConfig != null)
|
|
{
|
|
int indx = token.IndexOf("=");
|
|
int qindx = token.IndexOf("?", indx);
|
|
string pstok = token.Substring(indx + 1, qindx - indx - 1);
|
|
string val = procConfig.GetValue("PSI", pstok);
|
|
int bindx = token.IndexOf("|", indx);
|
|
if (val == "Y")
|
|
val = token.Substring(qindx + 1, bindx - qindx - 1);
|
|
else
|
|
{
|
|
int eindx = token.IndexOf("}", bindx);
|
|
val = token.Substring(bindx + 1, eindx - bindx - 1);
|
|
}
|
|
if (val != null && val != "" && !PgLogicals.ContainsKey(pstok)) PgLogicals.Add(pstok, val != null);
|
|
//if (val == null || val == "")
|
|
//val = " ";
|
|
if (val == null)
|
|
val = "";
|
|
plstr = plstr.Replace(token, val);
|
|
// Get a list of Pagelist token that are inside the PS= conditional result
|
|
// Paglist tokens inside a PS= conditional are surrounded by square brackets instead of curley
|
|
// ex. [BOX3] instead of {BOX3}
|
|
MatchCollection subMatches = regexFindSubToken.Matches(plstr);
|
|
if (subMatches.Count > 0)
|
|
{
|
|
foreach (Match subMatch in subMatches)
|
|
{
|
|
string subToken = subMatch.Value;
|
|
ProcessPaglistToken(section, svgGroup, pageItem, ref useFontForCheckOffHeader, ref plstr, subToken);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!ProcessPaglistToken(section, svgGroup, pageItem, ref useFontForCheckOffHeader, ref plstr, token)) break;
|
|
}
|
|
} // end foreach matches
|
|
if (plstr.StartsWith("RO_Lookup("))
|
|
{
|
|
string parms = plstr.Substring(10,plstr.Length-11);
|
|
string[] parts = parms.Split(",".ToCharArray());
|
|
plstr = ROLookup(parts[0], parts[1], parts[2]);
|
|
}
|
|
if (plstr != "")
|
|
{
|
|
if (useFontForCheckOffHeader != null)
|
|
svgGroup.Add(PageItemToSvgText(pageItem, plstr, useFontForCheckOffHeader, MySection));
|
|
else
|
|
svgGroup.Add(PageItemToSvgText(pageItem, plstr, MySection));
|
|
}
|
|
}
|
|
else
|
|
svgGroup.Add(PageItemToSvgText(pageItem, pageItem.Token, MySection));
|
|
}
|
|
}
|
|
// Proms page numbering designed requires a "{PAGE}" token to increment the page counter. So the easiest way
|
|
// to do that was to add a "{PAGE}" token to every page that is flagged as not to be printed.
|
|
if (sPag == SectionConfig.SectionPagination.Separate)
|
|
{
|
|
SvgText st = new SvgText(new System.Drawing.PointF(300, 300), "Non-printing {PAGE}", new System.Drawing.Font("Arial", 10), System.Drawing.Color.Black);
|
|
svgGroup.Add(st);
|
|
}
|
|
if (svgGroup.Count>0) mySvg.Add(svgGroup);
|
|
}
|
|
private string ROLookup(string accpageid, string multiid, string deflt)
|
|
{
|
|
ROFSTLookup myLookup = MySection.MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(MySection.MyDocVersion);
|
|
string accpgid = accpageid;
|
|
accpgid = accpgid.Replace("-HIGH", "-HI").Replace("-LOW", "-LO").Replace("_HIGH", "-HI").Replace("_LOW", "-LO").Replace(@"\u8209?", "-");
|
|
string val = myLookup.GetROValueByAccPagID("<" + accpgid + "." + multiid + ">", MySection.MyDocVersion.DocVersionConfig.RODefaults_setpointprefix, MySection.MyDocVersion.DocVersionConfig.RODefaults_graphicsprefix);
|
|
if (!deflt.StartsWith("[") && val != null)
|
|
{
|
|
val = val.Replace("[xB3]", "\xB3");
|
|
val = val.Replace("[xB2]", "\xB2");
|
|
return val;
|
|
}
|
|
return deflt;
|
|
}
|
|
private bool _DidHLSText = false;
|
|
public bool DidHLSText
|
|
{
|
|
get { return _DidHLSText; }
|
|
set { _DidHLSText = value; }
|
|
}
|
|
private int _HasHLSTextId = 0;
|
|
public int HasHLSTextId
|
|
{
|
|
get { return _HasHLSTextId; }
|
|
set { _HasHLSTextId = value; }
|
|
}
|
|
private string _HLSText = "";
|
|
public string HLSText
|
|
{
|
|
get { return _HLSText; }
|
|
set
|
|
{
|
|
if (_HLSText == "")
|
|
_HLSText = value;
|
|
}
|
|
}
|
|
private string _HLSTAB = "";
|
|
public string HLSTAB
|
|
{
|
|
get { return _HLSTAB; }
|
|
set { _HLSTAB = value; }
|
|
}
|
|
private string _HLRNO = "";
|
|
public string HLRNO
|
|
{
|
|
get { return _HLRNO; }
|
|
set { _HLRNO = value; }
|
|
}
|
|
/// <summary>
|
|
/// </summary>
|
|
/// <param name="section"></param>
|
|
/// <param name="svgGroup"></param>
|
|
/// <param name="pageItem"></param>
|
|
/// <param name="useFontForCheckOffHeader"></param>
|
|
/// <param name="plstr"></param>
|
|
/// <param name="token"></param>
|
|
/// <returns>
|
|
/// true - if token is resolved
|
|
/// false - if entire text is processed
|
|
/// </returns>
|
|
private bool ProcessPaglistToken(VEPROMS.CSLA.Library.SectionInfo section, SvgGroup svgGroup, VEPROMS.CSLA.Library.PageItem pageItem, ref VE_Font useFontForCheckOffHeader, ref string plstr, string token)
|
|
{
|
|
bool retval = true;
|
|
|
|
//Console.WriteLine("{0} ProcessPagelistToken", token);
|
|
// Paglist token inside a PS= conditional are surrounded by square brackets instead of curley
|
|
// ex. [BOX3] instead of {BOX3}, thus the redunant looking cases
|
|
switch (token)
|
|
{
|
|
case "{!atom}":
|
|
// Add an Atom Figure to the SVG
|
|
plstr = plstr.Replace(token, "");
|
|
AddImage(svgGroup, 160.5f, 170.5f, 288f, 323f, "atom.bmp");
|
|
break;
|
|
case "{!cpllogo}":
|
|
plstr = plstr.Replace(token, "");
|
|
AddImage(svgGroup, 10f, 10f, 78.7f, 29.8f, "cpllogo.bmp");
|
|
break;
|
|
//case "{!domlogo}":
|
|
// AddImage(svgGroup, 10f, 70f, 123f, 40.1f, "domlogo.bmp");
|
|
// break;
|
|
//case "{!gpclogo}":
|
|
// AddImage(svgGroup, 10f, 150f, 35.2f, 35.8f, "gpclogo.bmp");
|
|
// break;
|
|
case "{HEADER1}":
|
|
case "[HEADER1]":
|
|
case "{HEADER2}":
|
|
case "[HEADER2]":
|
|
case "{HEADER3}":
|
|
case "[HEADER3]":
|
|
case "{HEADER4}":
|
|
case "[HEADER4]":
|
|
case "{HEADER5}":
|
|
case "[HEADER5]":
|
|
case "{BOX1}":
|
|
case "[BOX1]":
|
|
case "{BOX2}":
|
|
case "[BOX2]":
|
|
case "{BOX3}":
|
|
case "[BOX3]":
|
|
case "{BOX4}":
|
|
case "[BOX4]":
|
|
case "{BOX5}":
|
|
case "[BOX5]":
|
|
case "{BOX6}":
|
|
case "[BOX6]":
|
|
case "{BOX7}":
|
|
case "[BOX7]":
|
|
case "{BOX8}":
|
|
case "[BOX8]":
|
|
case "{BOX9}":
|
|
case "[BOX9]":
|
|
plstr = plstr.Replace(token, "");
|
|
svgGroup.Add(PageItemToSvgUse(pageItem, FirstAndLast(token)));
|
|
break;
|
|
case "{PMODEBOX}": // need to set either 1 or 2 depending on number of columns
|
|
case "[PMODEBOX]":
|
|
string box = "1";
|
|
if (_MySection.SectionConfig.Section_ColumnMode == SectionConfig.SectionColumnMode.Four)
|
|
box = "4";
|
|
else if (_MySection.SectionConfig.Section_ColumnMode == SectionConfig.SectionColumnMode.Three)
|
|
box = "3";
|
|
else if (_MySection.SectionConfig.Section_ColumnMode == SectionConfig.SectionColumnMode.Two)
|
|
box = "2";
|
|
box = "{BOX" + box + "}";
|
|
plstr = plstr.Replace(token, "");
|
|
svgGroup.Add(PageItemToSvgUse(pageItem, FirstAndLast(box)));
|
|
break;
|
|
case "{DRAFTPAGE}":
|
|
if (!AllowedWatermarks.Contains("Draft")) AllowedWatermarks.Add("Draft");
|
|
plstr = plstr.Replace(token, "");// Remove token since it is handled now
|
|
break;
|
|
case "{REFERENCEPAGE}":
|
|
if (!AllowedWatermarks.Contains("Reference")) AllowedWatermarks.Add("Reference");
|
|
plstr = plstr.Replace(token, "");// Remove token since it is handled now
|
|
break;
|
|
case "{MASTERPAGE}":
|
|
if (!AllowedWatermarks.Contains("Master")) AllowedWatermarks.Add("Master");
|
|
plstr = plstr.Replace(token, "");// Remove token since it is handled now
|
|
break;
|
|
case "{SAMPLEPAGE}":
|
|
if (!AllowedWatermarks.Contains("Sample")) AllowedWatermarks.Add("Sample");
|
|
plstr = plstr.Replace(token, "");// Remove token since it is handled now
|
|
break;
|
|
case "{INFORMATIONPAGE}":
|
|
if (!AllowedWatermarks.Contains("Information Only")) AllowedWatermarks.Add("Information Only");
|
|
break;
|
|
case "{PROCTITLE}":
|
|
case "[PROCTITLE]":
|
|
case "{PROCTITLE1}":
|
|
case "[PROCTITLE1]":
|
|
case "{PROCTITLE2}":
|
|
case "[PROCTITLE2]":
|
|
case "{COVERPROCTITLE}":
|
|
case "[COVERPROCTITLE]":
|
|
int tlen = (token.Contains("COVERPROCTITLE"))?(int)section.ActiveFormat.PlantFormat.FormatData.ProcData.CoverTitleLength : (int)section.ActiveFormat.PlantFormat.FormatData.ProcData.TitleLength;
|
|
//float linelen = (int)section.ActiveFormat.PlantFormat.FormatData.ProcData.TitleLength * (float)pageItem.Font.CPI / 12;
|
|
float linelen = tlen * (float)pageItem.Font.CPI / 12;
|
|
string title = section.MyProcedure.MyContent.Text;
|
|
if (title.Contains("<NO TITLE>") && !section.ActiveFormat.PlantFormat.FormatData.ProcData.PrintNoTitle)
|
|
plstr = "";
|
|
else
|
|
{
|
|
if (section.ActiveFormat.PlantFormat.FormatData.ProcData.CapitalizeTitle) title = title.ToUpper();
|
|
plstr = SplitTitle(svgGroup, pageItem, title, (int)linelen, token, plstr); //,rowAdj);
|
|
}
|
|
break;
|
|
case "{COVERTITLE1}":
|
|
case "[COVERTITLE1]":
|
|
case "{COVERTITLE2}":
|
|
case "[COVERTITLE2]":
|
|
int ctlen = section.ActiveFormat.PlantFormat.FormatData.ProcData.CoverTitleLength ?? 0;
|
|
float coverlinelen = ((ctlen == 0) ? (int)section.ActiveFormat.PlantFormat.FormatData.ProcData.TitleLength : ctlen) * (float)pageItem.Font.CPI / 12;
|
|
string title1 = section.MyProcedure.MyContent.Text;
|
|
if (section.ActiveFormat.PlantFormat.FormatData.ProcData.CapitalizeTitle) title1 = title1.ToUpper();
|
|
plstr = SplitCoverTitle(svgGroup, pageItem, title1, (int)coverlinelen, token, plstr);//, rowAdj);
|
|
break;
|
|
case "{TITLE&UNIT}":
|
|
case "[TITLE&UNIT]":
|
|
tlen = (token.Contains("COVERPROCTITLE"))?(int)section.ActiveFormat.PlantFormat.FormatData.ProcData.CoverTitleLength : (int)section.ActiveFormat.PlantFormat.FormatData.ProcData.TitleLength;
|
|
linelen = tlen * (float)pageItem.Font.CPI / 12;
|
|
plstr = SplitTitleAndUnit(svgGroup, pageItem, section.MyProcedure.MyContent.Text.ToUpper(), (int)linelen, token, plstr); //,rowAdj);
|
|
break;
|
|
case "{SPLITEOPNUM}":
|
|
case "[SPLITEOPNUM]":
|
|
string eopnum1 = section.MyProcedure.MyContent.Number;
|
|
string unitnum1 = MySection.MyDocVersion.DocVersionConfig.Unit_ProcedureNumber;
|
|
string unitname1 = MySection.MyDocVersion.DocVersionConfig.Unit_Name;
|
|
if (unitnum1.Length > 0)
|
|
{
|
|
if (unitnum1.Contains("#"))
|
|
eopnum1 = unitnum1.Replace("#", eopnum1);
|
|
if (unitnum1.Contains("!"))
|
|
eopnum1 = unitnum1.Replace("!", unitname1);
|
|
if (eopnum1 == string.Empty)
|
|
eopnum1 = section.MyProcedure.MyContent.Number;
|
|
}
|
|
plstr = SplitEOPNumber(svgGroup, pageItem, eopnum1, token, plstr);
|
|
break;
|
|
case "{EOPNUM}":
|
|
case "[EOPNUM]":
|
|
case "{PREDELIMEOPNUM}":
|
|
case "[PREDELIMEOPNUM]":
|
|
string eopnum = section.MyProcedure.MyContent.Number;
|
|
string unitnum = MySection.MyDocVersion.DocVersionConfig.Unit_ProcedureNumber;
|
|
string unitname = MySection.MyDocVersion.DocVersionConfig.Unit_Name;
|
|
if (unitnum.Length > 0)
|
|
{
|
|
if (unitnum.Contains("#"))
|
|
eopnum = unitnum.Replace("#", eopnum);
|
|
if (unitnum.Contains("!"))
|
|
eopnum = unitnum.Replace("!", unitname);
|
|
if (eopnum == string.Empty)
|
|
eopnum = section.MyProcedure.MyContent.Number;
|
|
}
|
|
if (token.Equals("{PREDELIMEOPNUM}"))
|
|
{
|
|
// only use up to the first non-alphanumeric character of the procedur number
|
|
// Prairie Island (NSP) Alarms use this token
|
|
int idx = 0;
|
|
while (idx < eopnum.Length && char.IsLetterOrDigit(eopnum[idx])) idx++;
|
|
if (idx < eopnum.Length)
|
|
eopnum = eopnum.Substring(0, idx);
|
|
}
|
|
plstr = plstr.Replace(token, eopnum);
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, pageItem.Token.Replace(token, eopnum)));
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, pageItem.Token.Replace(token, section.MyProcedure.MyContent.Number)));
|
|
break;
|
|
case "{SECTIONLEVELTITLE}":
|
|
case "[SECTIONLEVELTITLE]":
|
|
bool printsectlevel = ((pageItem.Justify & VEPROMS.CSLA.Library.E_Justify.PSOnlyFirst) != VEPROMS.CSLA.Library.E_Justify.PSOnlyFirst) ||
|
|
(((pageItem.Justify & VEPROMS.CSLA.Library.E_Justify.PSOnlyFirst) == VEPROMS.CSLA.Library.E_Justify.PSOnlyFirst) && PrintedSectionPage==0);
|
|
// if there is 'no title' for the section, only print it if a format flag says to print it.
|
|
if (printsectlevel)
|
|
{
|
|
if (section.DisplayText.ToUpper().Contains("<NO TITLE>") && !section.ActiveFormat.PlantFormat.FormatData.ProcData.PrintNoTitle) printsectlevel = false;
|
|
}
|
|
if (printsectlevel)
|
|
{
|
|
plstr = SplitTitle(svgGroup, pageItem, section.DisplayText, section.ActiveFormat.PlantFormat.FormatData.SectData.SectionTitleLength, token, plstr);
|
|
PrintedSectionPage = (int)pageItem.Row - _sectLevelNumTtlDiff;
|
|
}
|
|
else
|
|
plstr = plstr.Replace(token, "");
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, section.DisplayText));
|
|
break;
|
|
case "{METASECTIONTITLE}":
|
|
case "[METASECTIONTITLE]":
|
|
if (section.MyParent.IsSection)
|
|
plstr = SplitTitle(svgGroup, pageItem, section.MyParent.DisplayText, section.ActiveFormat.PlantFormat.FormatData.SectData.SectionTitleLength, token, plstr);
|
|
else
|
|
plstr = plstr.Replace(token, "");
|
|
break;
|
|
case "{SECTIONLEVELNUMBER}":
|
|
case "[SECTIONLEVELNUMBER]":
|
|
plstr = plstr.Replace(token, section.DisplayNumber);
|
|
_sectLevelNumTtlDiff = (int)pageItem.Row;
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, pageItem.Token.Replace(token, section.DisplayNumber)));
|
|
break;
|
|
case "{METASECTIONNUMBER}":
|
|
case "[METASECTIONNUMBER]":
|
|
if (section.MyParent.IsSection)
|
|
plstr = plstr.Replace(token, section.MyParent.DisplayNumber);
|
|
else
|
|
plstr = plstr.Replace(token, "");
|
|
break;
|
|
case "{UNITTEXT}":
|
|
case "[UNITTEXT]":
|
|
plstr = plstr.Replace(token, MySection.MyDocVersion.DocVersionConfig.Unit_Text);
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, pageItem.Token.Replace(token, MySection.MyDocVersion.DocVersionConfig.Unit_Text)));
|
|
break;
|
|
case "{UNITNUMBER}":
|
|
case "[UNITNUMBER]":
|
|
string unbr = MySection.MyDocVersion.DocVersionConfig.Unit_Number;
|
|
if (MySection.ActiveFormat.PlantFormat.FormatData.PrintData.PrintCommonForZeroUnit && unbr == "0")
|
|
plstr = "COMMON"; // for Comanche Peak, replace "Unit 0" with "COMMON"
|
|
else
|
|
plstr = plstr.Replace(token, unbr);
|
|
break;
|
|
case "{ATTACHNUM}":
|
|
case "[ATTACHNUM]":
|
|
plstr = plstr.Replace(token, "1"); // used by SHESDD - but 16bit returns '1' unless has format flag 'MoveParensToToken' that was only in SCE (San Onofre)
|
|
break;
|
|
case "{ATTACHNUM1}":
|
|
case "[ATTACHNUM1]":
|
|
string numAtt = GetAttachNum1();
|
|
plstr = plstr.Replace(token, numAtt); // used by SHESDD - but 16bit returns '1' unless has format flag 'MoveParensToToken' that was only in SCE (San Onofre)
|
|
break;
|
|
case "{CHKOFFHEADING}":
|
|
case "[CHKOFFHEADING]":
|
|
// unfortunately, the font is not stored on the page list item if there is an active
|
|
// check off header. It is stored with the checkoff data as defined by user selection
|
|
// of the selected header (selection stored in section config).
|
|
int sindx = section.CheckOffHeadingIndex();
|
|
VE_Font vf = sindx <= 0 ? pageItem.Font :
|
|
section.ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList[sindx].Font;
|
|
useFontForCheckOffHeader = vf;
|
|
PageListCheckOffHeader = PageItemToSvgText(pageItem, pageItem.Token, vf, section);
|
|
break;
|
|
case "{HLSTEXT}":
|
|
DidHLSText = true;
|
|
plstr = plstr.Replace(token, HLSText);
|
|
break;
|
|
case "{PROCDES}":
|
|
ProcDescrList pdl = section.ActiveFormat.PlantFormat.FormatData.PrintData.ProcDescrList;
|
|
if (pdl != null && pdl.Count > 0)
|
|
{
|
|
string procnum = section.MyProcedure.MyContent.Number.Replace(@"\u8209?", "-");
|
|
foreach (ProcDescr pd in pdl)
|
|
{
|
|
if (pd.MatchProcNumber != null)
|
|
{
|
|
string matchStr = (pd.MatchProcNumber.StartsWith("*}")) ? pd.MatchProcNumber.Substring(2) : pd.MatchProcNumber;
|
|
if (procnum.Contains(matchStr))
|
|
{
|
|
if (pd.ProcDescr1 == "{null}") // used to override fmt file inheritance & set null/empty string
|
|
plstr = "";
|
|
else
|
|
plstr = pd.ProcDescr1;
|
|
break;
|
|
}
|
|
if (pd.MatchProcNumber == "@")
|
|
{
|
|
// 16bit code looked like it only checked for the first character, but this code looks at
|
|
// all characters. It was not working correctly for BGE. Didn't want to change it for other
|
|
// plants that have been delivered - so added special code for BGE.
|
|
if (section.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert)
|
|
{
|
|
if (Regex.IsMatch(procnum.Substring(0,1),"[A-Za-z]"))
|
|
plstr = pd.ProcDescr1;
|
|
else
|
|
plstr = "";
|
|
break;
|
|
}
|
|
if (Regex.IsMatch(procnum, "^[A-Za-z]+$"))
|
|
plstr = pd.ProcDescr1;
|
|
else
|
|
plstr = "";
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
plstr = "UNKNOWN";
|
|
}
|
|
}
|
|
break;
|
|
case "{PROCDES2}":
|
|
ProcDescrList pdl2 = section.ActiveFormat.PlantFormat.FormatData.PrintData.ProcDescrList;
|
|
if (pdl2 != null && pdl2.Count > 0)
|
|
{
|
|
string procnum = section.MyProcedure.MyContent.Number.Replace(@"\u8209?", "-");
|
|
foreach (ProcDescr pd in pdl2)
|
|
{
|
|
if (pd.MatchProcNumber != null)
|
|
{
|
|
string matchStr = (pd.MatchProcNumber.StartsWith("*}")) ? pd.MatchProcNumber.Substring(2) : pd.MatchProcNumber;
|
|
if (procnum.Contains(matchStr))
|
|
{
|
|
plstr = pd.ProcDescr2;
|
|
break;
|
|
}
|
|
if (pd.MatchProcNumber == "@")
|
|
{
|
|
if (Regex.IsMatch(procnum, "^[A-Za-z]+$"))
|
|
plstr = pd.ProcDescr2;
|
|
else
|
|
plstr = "";
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
plstr = "UNKNOWN";
|
|
}
|
|
}
|
|
break;
|
|
case "{CURDATE}":
|
|
DateTime thisDate1 = DateTime.Today;
|
|
plstr = plstr.Replace(token, thisDate1.ToString("MMMM dd, yyyy"));
|
|
break;
|
|
case "{CURTIME}":
|
|
DateTime thisDate2 = DateTime.Now;
|
|
plstr = plstr.Replace(token, thisDate2.ToString("H:mm"));
|
|
break;
|
|
case "{HLRNO}":
|
|
plstr = HLRNO==null?"":plstr.Replace(token, HLRNO);
|
|
break;
|
|
case "{HLSTAB}":
|
|
plstr = plstr.Replace(token, HLSTAB);
|
|
break;
|
|
case "{UNITALPHA}":
|
|
// copied from 16bit's pagelist.cs for BGE:
|
|
string unitnm = MySection.MyDocVersion.DocVersionConfig.Print_UnitNumberForPageList;
|
|
if (unitnm == "1")
|
|
plstr = plstr.Replace(token, "ONE");
|
|
else if (unitnm == "2")
|
|
plstr = plstr.Replace(token, "TWO");
|
|
else
|
|
plstr = plstr.Replace(token, "ONE AND TWO");
|
|
break;
|
|
case "{REVUNIT}":
|
|
// copied from 16bit's pagelist.cs for BGE:
|
|
string revUnit = null;
|
|
string unitNum = MySection.MyDocVersion.DocVersionConfig.Print_UnitNumberForPageList;
|
|
if (Rev != null && Rev != "")
|
|
{
|
|
revUnit = Rev;
|
|
int indxs = Rev.IndexOf(MySection.ActiveFormat.PlantFormat.FormatData.PrintData.RevDateWithForwardSlash ? '\\' : '/');
|
|
if (indxs > 0) revUnit = Rev.Substring(0, indxs);
|
|
}
|
|
else
|
|
revUnit = " ";
|
|
|
|
if (unitNum == "2")
|
|
revUnit += "/Unit 2";
|
|
else if (unitNum == "1")
|
|
revUnit += "/Unit 1";
|
|
plstr = plstr.Replace(token, revUnit);
|
|
break;
|
|
default:
|
|
if (token.Contains(@"RO-"))
|
|
{
|
|
plstr = token.Replace("{","").Replace("}","");
|
|
svgGroup.Add(PageItemToSvgText(pageItem, plstr, MySection));
|
|
}
|
|
if (token.Contains(@"PS-"))
|
|
{
|
|
//Console.WriteLine("RefreshConfig {0} {1}", section.MyProcedure.ItemID, section.MyProcedure.MyItemInfoUnique);
|
|
//section.MyProcedure.RefreshConfig();
|
|
//ProcedureConfig procConfig = section.MyProcedure.MyConfig as ProcedureConfig;
|
|
//Console.WriteLine("> ProcConfig {0} {1}",procConfig,section.MyProcedure.MyItemInfoUnique);
|
|
//Console.WriteLine("> MyContent {0}", section.MyProcedure.MyContent.Config);
|
|
//section.MyProcedure.RefreshConfig();
|
|
ProcedureConfig procConfig = new ProcedureConfig(section.MyProcedure.MyContent.Config);
|
|
//Console.WriteLine("< ProcConfig {0}", procConfig);
|
|
if (procConfig != null)
|
|
{
|
|
int indx = token.IndexOf("-");
|
|
int qindx = token.IndexOf("?", indx);
|
|
string val = null;
|
|
if (qindx == -1)
|
|
{
|
|
val = procConfig.GetValue("PSI", token.Substring(4, token.Length - 5));
|
|
plstr = plstr.Replace(token, val);
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, plstr, MySection));
|
|
}
|
|
else
|
|
{
|
|
string pstok = token.Substring(indx + 1, qindx - indx - 1);
|
|
plstr = procConfig.GetValue("PSI", pstok);
|
|
// the first part of the string between the ? and ' ' is the other logical
|
|
// to see if it's on. If on, just use col and/or row as defined. Otherwise use
|
|
// value between = and |.
|
|
int sindx2 = token.IndexOf(" ", qindx);
|
|
string logcheck = token.Substring(qindx + 1, sindx2 - qindx - 1);
|
|
if (PgLogicals.ContainsKey(logcheck))
|
|
{
|
|
int bindx = token.IndexOf("|", indx);
|
|
string newval = token.Substring(sindx2 + 1, bindx - sindx2 - 1);
|
|
float col = pageItem.Col ?? 0;
|
|
if (newval.ToUpper().Contains("COL"))
|
|
{
|
|
col = System.Convert.ToInt32(newval.Substring(4));
|
|
}
|
|
svgGroup.Add(PageItemToSvgText(pageItem.Token, pageItem.Row ?? 0, col, pageItem.Justify ?? VEPROMS.CSLA.Library.E_Justify.PSLeft, pageItem.Font, plstr, MySection));
|
|
plstr = ""; // clear so it doesn't get added twice, i.e. in the method that calls this.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plstr != "")
|
|
{
|
|
svgGroup.Add(PageItemToSvgText(pageItem, plstr, MySection));
|
|
plstr = "";
|
|
}
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, pageItem.Token));
|
|
}
|
|
//_MyLog.InfoFormat("Token not processed {0}", token);
|
|
if (plstr == "") retval = false;
|
|
break;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
private string GetAttachNum1()
|
|
{
|
|
int cnt = 0;
|
|
SectionInfo si = MySection;
|
|
while (si != null)
|
|
{
|
|
if (si.MyContent.Type == MySection.MyContent.Type) cnt++;
|
|
si = si.MyPrevious as SectionInfo;
|
|
}
|
|
return cnt.ToString();
|
|
}
|
|
private static void AddImage(SvgGroup svgGroup, float x, float y, float w, float h, string figure)
|
|
{
|
|
svgGroup.Add(new SvgImage(new System.Drawing.PointF(x, y), new System.Drawing.SizeF(w, h),
|
|
System.Windows.Forms.Application.StartupPath + @"\Resources\" + figure));
|
|
}
|
|
|
|
private string SplitTitle(SvgGroup svgGroup, VEPROMS.CSLA.Library.PageItem pageItem, string title, int? len, string match, string plstr)
|
|
{
|
|
if (match == "{PROCTITLE2}" || match == "[PROCTITLE2]") return plstr.Replace(match, "");
|
|
if (len == null || len == 0 || ItemInfo.StripRtfFormatting(title).Length < len)
|
|
{
|
|
if (match == "{PROCTITLE2}" || match == "[PROCTITLE2]") return plstr.Replace(match, ""); // this would have been done in proctitle1
|
|
plstr = plstr.Replace(match, title).Replace("@@","");
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, title));
|
|
return plstr;
|
|
}
|
|
|
|
// BGE has a '@@' in its section number/title pagelist item for eops. If the title goes onto two lines,
|
|
// the '@@' marked the starting location for the title. Process this differently than other split titles:
|
|
if (plstr.Contains("@@"))
|
|
{
|
|
DoSpecialSectNumTitle(svgGroup, pageItem, title, len, match, plstr);
|
|
return ""; // all resolved pagelist items were already added to svgGroup for printing.
|
|
}
|
|
|
|
// Otherwise determine how many line to split the text into
|
|
List<string> titleLines = Volian.Base.Library.RtfTools.SplitText(title, (int)len);
|
|
|
|
// Adjust y location based on which pagelist token & how many lines. Proctitle1 is adjusted if
|
|
// there are more than 2 lines (proctitle1 should have it's own y location that is used if there are 1 or 2 lines.)
|
|
float yOffset = (pageItem.Token.Contains("1") && titleLines.Count <= 2) ? 0 : (-6 * (titleLines.Count - 1));
|
|
int cnt = 0;
|
|
|
|
// if the title broke into two lines & proctitle1 & proctitle2 are on the same line, handle that
|
|
// and return the string:
|
|
if (titleLines.Count == 2 && pageItem.Token.Contains("1") && pageItem.Token.Contains("2"))
|
|
{
|
|
plstr = plstr.Replace("{PROCTITLE1}", titleLines[0]);
|
|
plstr = plstr.Replace("[PROCTITLE1]", titleLines[0]);
|
|
plstr = plstr.Replace("{PROCTITLE2}", titleLines[1]);
|
|
plstr = plstr.Replace("[PROCTITLE2]", titleLines[1]);
|
|
return plstr;
|
|
}
|
|
foreach (string line in titleLines)
|
|
{
|
|
cnt++;
|
|
if (cnt == 1 && yOffset == 0) // adj == 0 means we use PROCTITLE1/PROCTITLE2 pagelist tokens with 2 or less lines
|
|
plstr = plstr.Replace(match, line);
|
|
else
|
|
{
|
|
//if (cnt == 1)
|
|
//{
|
|
// plstr = plstr.Replace(match, line);
|
|
// svgGroup.Add(PageItemToSvgText(pageItem, plstr, yOffset));
|
|
// plstr = "";
|
|
//}
|
|
//else
|
|
svgGroup.Add(PageItemToSvgText(pageItem, line, yOffset));
|
|
plstr = plstr.Replace(match, "");
|
|
}
|
|
yOffset += (float)((pageItem.Font.Size > 14) ? pageItem.Font.Size : 12);
|
|
}
|
|
return plstr;
|
|
}
|
|
|
|
private void DoSpecialSectNumTitle(SvgGroup svgGroup, VEPROMS.CSLA.Library.PageItem pageItem, string title, int? len, string match, string plstr)
|
|
{
|
|
// first add anything up to the "@@" to the svgGroup:
|
|
string befAts = plstr.Substring(0, plstr.IndexOf("@@"));
|
|
svgGroup.Add(PageItemToSvgText(pageItem, befAts, 0));
|
|
|
|
// get the new xoffset. This will be the column value + the size of 'stuff' before the '@@'
|
|
float xoff = (float)pageItem.Col;
|
|
xoff += (befAts.Length * pageItem.Font.CharsToTwips);
|
|
|
|
float yoff = (float)pageItem.Row;
|
|
|
|
List<string> titleLines = Volian.Base.Library.RtfTools.SplitText(title, (int)len);
|
|
foreach (string line in titleLines)
|
|
{
|
|
svgGroup.Add(PageItemToSvgText(pageItem.Token, yoff, xoff, (E_Justify)pageItem.Justify, pageItem.Font, line, MySection));
|
|
yoff += (float)((pageItem.Font.Size > 14) ? pageItem.Font.Size : 12);
|
|
}
|
|
}
|
|
private string SplitTitleAndUnit(SvgGroup svgGroup, VEPROMS.CSLA.Library.PageItem pageItem, string title, int? len, string token, string plstr)
|
|
{
|
|
List<string> titleLines = Volian.Base.Library.RtfTools.SplitText(title, (int)len);
|
|
// Add a separate line with the Unit Number
|
|
titleLines.Add("UNIT " + MySection.MyDocVersion.DocVersionConfig.Unit_Number);
|
|
// Adjust y location based on which pagelist token & how many lines.
|
|
float yOffset = (-6 * (titleLines.Count - 1));
|
|
foreach (string line in titleLines)
|
|
{
|
|
svgGroup.Add(PageItemToSvgText(pageItem, line, yOffset));
|
|
yOffset += (float)((pageItem.Font.Size > 14) ? pageItem.Font.Size : 12);
|
|
}
|
|
return plstr.Replace(token, "");
|
|
}
|
|
private string SplitEOPNumber(SvgGroup svgGroup, PageItem pageItem, string eopnum, string token, string plstr)
|
|
{
|
|
string[] eopnums = eopnum.Split(" ".ToCharArray());
|
|
float yOffset = (-6 * (eopnums.Length - 1));
|
|
foreach (string line in eopnums)
|
|
{
|
|
svgGroup.Add(PageItemToSvgText(pageItem, line, yOffset));
|
|
yOffset += (float)((pageItem.Font.Size > 14) ? pageItem.Font.Size : 12);
|
|
}
|
|
return plstr.Replace(token, "");
|
|
}
|
|
//private string symblsStr = "\u25CF\u0394"; // string of possible symbol character in a tab
|
|
//// add symbol characters as needed
|
|
//// "\u25CF" - solid bullet
|
|
//// \x0394 - delta
|
|
//private float GetTextWidth(VE_Font vefont, string txt, string symblFontName)
|
|
//{
|
|
// System.Drawing.Font font = new System.Drawing.Font(vefont.Family, (float)vefont.Size, GetSysFontStyle(vefont));
|
|
// System.Drawing.Font symbFont = new System.Drawing.Font(symblFontName, (float)vefont.Size);
|
|
// iTextSharp.text.Font iFont = Volian.Svg.Library.VolianPdf.GetFont(font);
|
|
// iTextSharp.text.Font iSymblFont = Volian.Svg.Library.VolianPdf.GetFont(symbFont);
|
|
// float w = 0;
|
|
// foreach (char c in txt)
|
|
// {
|
|
// int idx = symblsStr.IndexOf(c);
|
|
// if (idx >= 0) // symbol character - use symbol font to find its width
|
|
// w += iSymblFont.BaseFont.GetWidthPointKerned(symblsStr[idx].ToString(), (float)vefont.Size);
|
|
// else
|
|
// w += iFont.BaseFont.GetWidthPointKerned(c.ToString(), (float)vefont.Size);
|
|
// }
|
|
// //float w = iFont.BaseFont.GetWidthPointKerned(Text.Replace("\u25CF","@"), (float)vefont.Size);
|
|
// return w;
|
|
//}
|
|
|
|
private string SplitCoverTitle(SvgGroup svgGroup, VEPROMS.CSLA.Library.PageItem pageItem, string title, int? len, string match, string plstr)
|
|
{
|
|
if (len == null || ItemInfo.StripRtfFormatting(title).Length < len)
|
|
{
|
|
if (match == "{COVERTITLE2}" || match == "[COVERTITLE2]") return plstr; // this would have been done in COVERTITLE1
|
|
plstr = plstr.Replace(match, title);
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, title));
|
|
return plstr;
|
|
}
|
|
// Otherwise determine how many line to split the text into
|
|
List<string> titleLines = Volian.Base.Library.RtfTools.SplitText(title, (int)len);
|
|
if (match == "{COVERTITLE1}" || match == "[COVERTITLE1]")
|
|
{
|
|
plstr = plstr.Replace(match, titleLines[0]);
|
|
//svgGroup.Add(PageItemToSvgText(pageItem, titleLines[0]));
|
|
return plstr;
|
|
}
|
|
// if the token was proctitle, dont' adjust. If the token was PROCTITLE1/2 then
|
|
// move down 6.
|
|
// int adj = pageItem.Token.Contains("1") || pageItem.Token.Contains("2") ? 0 : -6;
|
|
int adj = (titleLines.Count > 2) ? -6 : 0;
|
|
float yOffset = adj * (titleLines.Count - 2);
|
|
int lnCnt = 0;
|
|
foreach (string line in titleLines)
|
|
{
|
|
lnCnt++;
|
|
if (lnCnt == 1) continue;
|
|
plstr = plstr.Replace(match, line);
|
|
svgGroup.Add(PageItemToSvgText(pageItem, plstr, yOffset));
|
|
plstr = ""; // clear it because it was added into the list in the line above this, i.e. don't duplicate
|
|
yOffset += 12;
|
|
}
|
|
return plstr;
|
|
}
|
|
private int FindWidth(string title, int start, int len)
|
|
{
|
|
for (int ii = start + len; ii > start; ii--)
|
|
{
|
|
if (title[ii] == ' ')
|
|
{
|
|
while (title[ii] == ' ') ii--;
|
|
if (ii > start)
|
|
return 2 + ii - start;
|
|
return len;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
private SvgPart PageItemToSvgUse(VEPROMS.CSLA.Library.PageItem pageItem, string templateName)
|
|
{
|
|
SvgUse svgUse = new SvgUse();
|
|
svgUse.UseID = templateName;
|
|
svgUse.X = new SvgMeasurement((float)(pageItem.Col ?? 0), E_MeasurementUnits.PT);
|
|
svgUse.Y = new SvgMeasurement((float)(pageItem.Row ?? 0), E_MeasurementUnits.PT);
|
|
return svgUse;
|
|
}
|
|
private static SvgText PageItemToSvgText(VEPROMS.CSLA.Library.PageItem pageItem, string text, VE_Font font, SectionInfo mySection)
|
|
{
|
|
SvgText svgText = PageItemToSvgText(pageItem, text, mySection);
|
|
svgText.Font = font.WindowsFont;
|
|
return svgText;
|
|
}
|
|
private static SvgText PageItemToSvgText(VEPROMS.CSLA.Library.PageItem pageItem, string text, SectionInfo mySection)
|
|
{
|
|
SvgText svgText = new SvgText();
|
|
svgText.Text = text;
|
|
VEPROMS.CSLA.Library.E_Justify justify = pageItem.Justify ?? VEPROMS.CSLA.Library.E_Justify.PSLeft;
|
|
float colAdj16bit = 0;
|
|
if ((justify & VEPROMS.CSLA.Library.E_Justify.PSLeft) == VEPROMS.CSLA.Library.E_Justify.PSLeft)
|
|
svgText.Justify = SvgJustify.Left;
|
|
else if ((justify & VEPROMS.CSLA.Library.E_Justify.PSRight) == VEPROMS.CSLA.Library.E_Justify.PSRight)
|
|
svgText.Justify = SvgJustify.Right;
|
|
else
|
|
{
|
|
svgText.Justify = SvgJustify.Center;
|
|
if (((justify & VEPROMS.CSLA.Library.E_Justify.PSTrue) != VEPROMS.CSLA.Library.E_Justify.PSTrue) &&
|
|
!mySection.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PicaIgnoreFiveSixths)
|
|
{
|
|
// the default CPI for Proms is 12, in 16bit 12 is the default - if a font wasn't defined
|
|
// or when doing a positioning calculation 12 was used. So we need to make an adjustment
|
|
// to handle non-12 CPI (12CPI will just cancel out in the following calculation).
|
|
|
|
// Take the difference between the width in Points of a character at 12CPI and a character
|
|
// at the defined font's CPI. Multiply that times the length of title and divide by two
|
|
// to find the half-way point.
|
|
|
|
// if the PageItem's font CPI is null, then default to 12 CPI
|
|
colAdj16bit = (1 + text.Length) * ((72 / (float)(pageItem.Font.CPI ?? 12)) - (72 / 12)) / 2;
|
|
}
|
|
}
|
|
svgText.Font = pageItem.Font.WindowsFont;
|
|
float row = (float)pageItem.Row < 0 ? -(float)pageItem.Row : (float)pageItem.Row;
|
|
if ((justify & VEPROMS.CSLA.Library.E_Justify.PSTop) == VEPROMS.CSLA.Library.E_Justify.PSTop) row -= ((72 / 6) / 2);
|
|
float lcol = pageItem.Col ?? 0;
|
|
|
|
// the column may need adjusted based on the document styles PageWidth. This was done in
|
|
// the 16bit code and was needed here to get the printed output to match.
|
|
if (pageItem.Font.FontIsProportional() && svgText.Justify == SvgJustify.Center)
|
|
{
|
|
int dotsPerChar = (int)(2400 / (mySection.MyDocStyle.Layout.PageWidth / 6));
|
|
lcol = (lcol * 25) / dotsPerChar;
|
|
}
|
|
|
|
svgText.X = new SvgMeasurement((float)lcol - colAdj16bit, E_MeasurementUnits.PT);
|
|
svgText.Y = new SvgMeasurement(row, E_MeasurementUnits.PT);
|
|
if (svgText.Font.Underline && svgText.Text.EndsWith(" ")) svgText.Text = svgText.Text.Substring(0, svgText.Text.Length - 1) + "\xA0";// replace last space with a hardspace
|
|
return svgText;
|
|
}
|
|
private SvgPart PageItemToSvgText(VEPROMS.CSLA.Library.PageItem pageItem, string text, float yOffset)
|
|
{
|
|
SvgText svgText = new SvgText();
|
|
svgText.Text = text;
|
|
VEPROMS.CSLA.Library.E_Justify justify = pageItem.Justify ?? VEPROMS.CSLA.Library.E_Justify.PSLeft;
|
|
float colAdj16bit = 0;
|
|
if ((justify & VEPROMS.CSLA.Library.E_Justify.PSLeft) == VEPROMS.CSLA.Library.E_Justify.PSLeft)
|
|
svgText.Justify = SvgJustify.Left;
|
|
else if ((justify & VEPROMS.CSLA.Library.E_Justify.PSRight) == VEPROMS.CSLA.Library.E_Justify.PSRight)
|
|
svgText.Justify = SvgJustify.Right;
|
|
else
|
|
{
|
|
svgText.Justify = SvgJustify.Center;
|
|
if (((justify & VEPROMS.CSLA.Library.E_Justify.PSTrue) != VEPROMS.CSLA.Library.E_Justify.PSTrue) &&
|
|
!MySection.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PicaIgnoreFiveSixths)
|
|
{
|
|
// the default CPI for Proms is 12, in 16bit 12 is the default - if a font wasn't defined
|
|
// or when doing a positioning calculation 12 was used. So we need to make an adjustment
|
|
// to handle non-12 CPI (12CPI will just cancel out in the following calculation).
|
|
|
|
// Take the difference between the width in Points of a character at 12CPI and a character
|
|
// at the defined font's CPI. Multiply that times the length of title and divide by two
|
|
// to find the half-way point.
|
|
colAdj16bit = (1 + text.Length) * ((72 / (float)pageItem.Font.CPI) - (72 / 12)) / 2;
|
|
}
|
|
}
|
|
float lcol = pageItem.Col ?? 0;
|
|
|
|
// the column may need adjusted based on the document styles PageWidth. This was done in
|
|
// the 16bit code and was needed here to get the printed output to match.
|
|
if (pageItem.Font.FontIsProportional() && svgText.Justify == SvgJustify.Center)
|
|
{
|
|
int dotsPerChar = (int)(2400 / (MySection.MyDocStyle.Layout.PageWidth / 6));
|
|
lcol = (lcol * 25) / dotsPerChar;
|
|
}
|
|
svgText.Font = pageItem.Font.WindowsFont;
|
|
svgText.X = new SvgMeasurement((float)lcol - colAdj16bit, E_MeasurementUnits.PT); // new SvgMeasurement((float)(pageItem.Col ?? 0), E_MeasurementUnits.PT);
|
|
svgText.Y = new SvgMeasurement((float)(yOffset + pageItem.Row ?? 0), E_MeasurementUnits.PT);
|
|
if (svgText.Font.Underline && svgText.Text.EndsWith(" ")) svgText.Text = svgText.Text.Substring(0, svgText.Text.Length - 1) + "\xA0";// replace last space with a hardspace
|
|
return svgText;
|
|
}
|
|
private SvgPart PageItemToSvgText(string token, float row, float col, E_Justify just, VE_Font font, string text, SectionInfo MySection)
|
|
{
|
|
SvgText svgText = new SvgText();
|
|
svgText.Text = text;
|
|
VEPROMS.CSLA.Library.E_Justify justify = just;
|
|
float colAdj16bit = 0;
|
|
if ((justify & VEPROMS.CSLA.Library.E_Justify.PSLeft) == VEPROMS.CSLA.Library.E_Justify.PSLeft)
|
|
svgText.Justify = SvgJustify.Left;
|
|
else if ((justify & VEPROMS.CSLA.Library.E_Justify.PSRight) == VEPROMS.CSLA.Library.E_Justify.PSRight)
|
|
svgText.Justify = SvgJustify.Right;
|
|
else
|
|
{
|
|
svgText.Justify = SvgJustify.Center;
|
|
if (((justify & VEPROMS.CSLA.Library.E_Justify.PSTrue) != VEPROMS.CSLA.Library.E_Justify.PSTrue) &&
|
|
!MySection.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PicaIgnoreFiveSixths)
|
|
{
|
|
// the default CPI for Proms is 12, in 16bit 12 is the default - if a font wasn't defined
|
|
// or when doing a positioning calculation 12 was used. So we need to make an adjustment
|
|
// to handle non-12 CPI (12CPI will just cancel out in the following calculation).
|
|
|
|
// Take the difference between the width in Points of a character at 12CPI and a character
|
|
// at the defined font's CPI. Multiply that times the length of title and divide by two
|
|
// to find the half-way point.
|
|
colAdj16bit = (1 + text.Length) * ((72 / (float)font.CPI) - (72 / 12)) / 2;
|
|
}
|
|
}
|
|
float lcol = col;
|
|
|
|
// the column may need adjusted based on the document styles PageWidth. This was done in
|
|
// the 16bit code and was needed here to get the printed output to match.
|
|
if (font.FontIsProportional() && svgText.Justify == SvgJustify.Center)
|
|
{
|
|
int dotsPerChar = (int)(2400 / (MySection.MyDocStyle.Layout.PageWidth / 6));
|
|
lcol = (lcol * 25) / dotsPerChar;
|
|
}
|
|
svgText.Font = font.WindowsFont;
|
|
svgText.X = new SvgMeasurement((float)lcol - colAdj16bit, E_MeasurementUnits.PT); // new SvgMeasurement((float)(pageItem.Col ?? 0), E_MeasurementUnits.PT);
|
|
svgText.Y = new SvgMeasurement(row, E_MeasurementUnits.PT);
|
|
if (svgText.Font.Underline && svgText.Text.EndsWith(" ")) svgText.Text = svgText.Text.Substring(0, svgText.Text.Length - 1) + "\xA0";// replace last space with a hardspace
|
|
return svgText;
|
|
}
|
|
private static List<string> _MissingTokens = new List<string>();
|
|
protected override string ReplacePageListToken(Match match)
|
|
{
|
|
switch (match.Value)
|
|
{
|
|
case "{PAGE}": // Current Page Number
|
|
return CurrentPageNumber.ToString();
|
|
case "{OF}": // Total Page Count for this section
|
|
return CurrentPageOf.ToString();
|
|
case "{REV}": // Revision Number and/or Revision string.
|
|
case "{REV2}":
|
|
// The 16bit code has a revision number & then a revision date. This revision date
|
|
// was actually either a date OR a string. The 32bit code no longer will call this
|
|
// token or string RevDate. HLP procs & stpdif show the different types of data
|
|
// that are used.
|
|
|
|
// 16-bit had code to string preceeding blanks.
|
|
if (Rev != null && Rev != "") Rev = Rev.TrimStart(" ".ToCharArray());
|
|
|
|
// Now check the format flags to determine if/how the Rev string should be parsed.
|
|
if ((MySection.ActiveFormat.PlantFormat.FormatData.PrintData.DoRevDate && Rev.Contains("/"))
|
|
|| (MySection.ActiveFormat.PlantFormat.FormatData.PrintData.RevDateWithForwardSlash && Rev.Contains("\\")))
|
|
{
|
|
int indx = Rev.IndexOf(MySection.ActiveFormat.PlantFormat.FormatData.PrintData.RevDateWithForwardSlash ? '\\' : '/');
|
|
if (match.Value == "{REV}") return Rev.Substring(0,indx);
|
|
return Rev.Substring(indx+1);
|
|
}
|
|
if (match.Value == "{REV}")return Rev;
|
|
return System.DateTime.Today.ToShortDateString();
|
|
case "{CHKOFFHEADING}":
|
|
return PageListTopCheckOffHeader;
|
|
case "{ROMANPAGE}":
|
|
return ItemInfo.RomanNumbering(CurrentPageNumber).ToLower();
|
|
case "{SETREV}":
|
|
return MySection.MyDocVersion.DocVersionConfig.ProcedureSetRev;
|
|
}
|
|
if (!_MissingTokens.Contains(match.Value))
|
|
{
|
|
_MissingTokens.Add(match.Value);
|
|
_MyLog.InfoFormat("Unhandled token {0}", match.Value);
|
|
}
|
|
return "";
|
|
}
|
|
}
|
|
public class ChkListBoxesHelper : List<ChkListBoxHelper>
|
|
{
|
|
private float _yOffsetStart;
|
|
private float _yOffsetEnd;
|
|
public ChkListBoxesHelper()
|
|
: base()
|
|
{
|
|
}
|
|
public void Add(ItemInfo myHls, float yoffStart, float yoffend)
|
|
{
|
|
Add(new ChkListBoxHelper());
|
|
}
|
|
public void Draw()
|
|
{
|
|
foreach (ChkListBoxHelper cb in this)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
public class ChkListBoxHelper
|
|
{
|
|
public ChkListBoxHelper()
|
|
{
|
|
}
|
|
}
|
|
public class PageBookmarks : List<PageBookmark>
|
|
{
|
|
public PageBookmarks()
|
|
: base()
|
|
{
|
|
}
|
|
public void Add(ItemInfo itemInfo, string title, PdfDestination pdfDestination)
|
|
{
|
|
Add(new PageBookmark(itemInfo, title, pdfDestination));
|
|
}
|
|
}
|
|
public class PageBookmark
|
|
{
|
|
private ItemInfo _MyItemInfo;
|
|
public ItemInfo MyItemInfo
|
|
{
|
|
get { return _MyItemInfo; }
|
|
set { _MyItemInfo = value; }
|
|
}
|
|
private string _Title;
|
|
public string Title
|
|
{
|
|
get { return _Title; }
|
|
set { _Title = value; }
|
|
}
|
|
private PdfDestination _PdfDestination;
|
|
public PdfDestination PdfDestination
|
|
{
|
|
get { return _PdfDestination; }
|
|
set { _PdfDestination = value; }
|
|
}
|
|
public PageBookmark(ItemInfo itemInfo, string title, PdfDestination pdfDestination)
|
|
{
|
|
_MyItemInfo = itemInfo;
|
|
_Title = title;
|
|
_PdfDestination = pdfDestination;
|
|
}
|
|
}
|
|
public class ChangeBarDefinition // anything that is section level should go in here.
|
|
{
|
|
private PrintChangeBar _MyChangeBarType;
|
|
public PrintChangeBar MyChangeBarType
|
|
{
|
|
get { return _MyChangeBarType; }
|
|
set { _MyChangeBarType = value; }
|
|
}
|
|
private PrintChangeBarLoc _MyChangeBarLoc;
|
|
public PrintChangeBarLoc MyChangeBarLoc
|
|
{
|
|
get { return _MyChangeBarLoc; }
|
|
set { _MyChangeBarLoc = value; }
|
|
}
|
|
private PrintChangeBarText _MyChangeBarText;
|
|
public PrintChangeBarText MyChangeBarText
|
|
{
|
|
get { return _MyChangeBarText; }
|
|
set { _MyChangeBarText = value; }
|
|
}
|
|
private string _MyChangeBarMessage; // user defined change bar message from docconfig
|
|
public string MyChangeBarMessage
|
|
{
|
|
get { return _MyChangeBarMessage; }
|
|
set { _MyChangeBarMessage = value; }
|
|
}
|
|
private int _MyChangeBarColumn; // two dimensional array, if both on same side, values are =
|
|
public int MyChangeBarColumn
|
|
{
|
|
get { return _MyChangeBarColumn; }
|
|
set { _MyChangeBarColumn = value; }
|
|
}
|
|
/*
|
|
* could have line thickness (set default from 16-bit), line color (set default as black), line style
|
|
*/
|
|
public ChangeBarDefinition()
|
|
{
|
|
}
|
|
public ChangeBarDefinition(PrintChangeBar myCBT, PrintChangeBarLoc myCBL, PrintChangeBarText myCBTxt, string myCBMsg)
|
|
{
|
|
_MyChangeBarType = myCBT;
|
|
_MyChangeBarLoc = myCBL;
|
|
_MyChangeBarText = myCBTxt;
|
|
}
|
|
public ChangeBarDefinition(DocVersionConfig docverConfig, FormatInfo formatInfo)
|
|
{
|
|
// if there is not overridden data on the docversion, prompt user...
|
|
ChangeBarData changeBarData = formatInfo.PlantFormat.FormatData.ProcData.ChangeBarData;
|
|
if (docverConfig == null || docverConfig.Print_ChangeBar == PrintChangeBar.SelectBeforePrinting)
|
|
{
|
|
// use these for now, i.e. this is what user would have selected from dialog.
|
|
_MyChangeBarType = PrintChangeBar.WithDefault;
|
|
_MyChangeBarLoc = PrintChangeBarLoc.OutsideBox;
|
|
_MyChangeBarText = PrintChangeBarText.None;
|
|
}
|
|
else
|
|
{
|
|
_MyChangeBarType = docverConfig.Print_ChangeBar;
|
|
_MyChangeBarLoc = docverConfig.Print_ChangeBarLoc;
|
|
_MyChangeBarText = docverConfig.Print_ChangeBarText;
|
|
}
|
|
if (_MyChangeBarType == PrintChangeBar.WithDefault) // get data from format
|
|
{
|
|
_MyChangeBarText = changeBarData.ChangeBarMessage == "ChgID" ? PrintChangeBarText.ChgID :
|
|
changeBarData.ChangeBarMessage == "DateAndChgID" ? PrintChangeBarText.DateChgID :
|
|
changeBarData.ChangeBarMessage == "None" ? PrintChangeBarText.None :
|
|
changeBarData.ChangeBarMessage == "RevNum" ? PrintChangeBarText.RevNum : PrintChangeBarText.UserDef;
|
|
}
|
|
if (_MyChangeBarType != PrintChangeBar.Without)
|
|
{
|
|
// if the format has the absolutefixedchangecolumn format flag, then always use the fixedchangecolumn from the
|
|
// format, otherwise, use the default column based on the selected location, stored in the base format.
|
|
_MyChangeBarColumn = (changeBarData.AbsoluteFixedChangeColumn) ?
|
|
(int)changeBarData.FixedChangeColumn :
|
|
System.Convert.ToInt32(changeBarData.DefaultCBLoc.Split(",".ToCharArray())[(int)(_MyChangeBarLoc)]);
|
|
if (_MyChangeBarText == PrintChangeBarText.UserDef)
|
|
_MyChangeBarMessage = docverConfig.Print_UserCBMess1 + @"\n" + docverConfig.Print_UserCBMess2;
|
|
|
|
}
|
|
}
|
|
}
|
|
public class CheckOffHeaderHelper
|
|
{
|
|
private SvgText _SvgText;
|
|
public SvgText SvgText
|
|
{
|
|
get { return _SvgText; }
|
|
set { _SvgText = value; }
|
|
}
|
|
private VEPROMS.CSLA.Library.VE_Font _CheckOffHeaderFont;
|
|
public VEPROMS.CSLA.Library.VE_Font CheckOffHeaderFont
|
|
{
|
|
get { return _CheckOffHeaderFont; }
|
|
set { _CheckOffHeaderFont = value; }
|
|
}
|
|
public CheckOffHeaderHelper(SvgText stext, VEPROMS.CSLA.Library.VE_Font vf)
|
|
{
|
|
_SvgText = stext;
|
|
_CheckOffHeaderFont = vf;
|
|
}
|
|
}
|
|
public class Gap
|
|
{
|
|
private float _YTop;
|
|
public float YTop
|
|
{
|
|
get { return _YTop; }
|
|
set { _YTop = value; }
|
|
}
|
|
private float _YBottom;
|
|
public float YBottom
|
|
{
|
|
get { return _YBottom; }
|
|
set { _YBottom = value; }
|
|
}
|
|
public Gap(float yTop, float yBottom)
|
|
{
|
|
_YTop = yTop;
|
|
_YBottom = yBottom;
|
|
}
|
|
}
|
|
public class Gaps : List<Gap>
|
|
{
|
|
public void Add(float yTop, float yBotttom)
|
|
{
|
|
this.Add(new Gap(yTop, yBotttom));
|
|
}
|
|
}
|
|
}
|