Kathy
06944c6503
Initial Wolf Creek Training macros Added WCNTraining flag Use WCNTraining flag to always paginate on subsection Don’t do docstyle reset if in WCNTraining format Do centerline if in WCNTraining format
2621 lines
101 KiB
C#
2621 lines
101 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;
|
|
using Volian.Base.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 List<PdfOutline> _MyPdfOutlines = new List<PdfOutline>();
|
|
public List<PdfOutline> MyPdfOutlines
|
|
{
|
|
get { return _MyPdfOutlines; }
|
|
}
|
|
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; }
|
|
}
|
|
private Dictionary<int, List<int>> _NotesToFootNotesHLS = new Dictionary<int, List<int>>();
|
|
public Dictionary<int, List<int>> NotesToFootNotesHLS
|
|
{
|
|
get { return _NotesToFootNotesHLS; }
|
|
set { _NotesToFootNotesHLS = value; }
|
|
}
|
|
private List<vlnParagraph> _NotesToFootNotes = new List<vlnParagraph>();
|
|
public List<vlnParagraph> NotesToFootNotes
|
|
{
|
|
get { return _NotesToFootNotes; }
|
|
set { _NotesToFootNotes = value; }
|
|
}
|
|
private float _NotesToFootNotesYoffset = 0;
|
|
|
|
public float NotesToFootNotesYoffset
|
|
{
|
|
get { return _NotesToFootNotesYoffset; }
|
|
set { _NotesToFootNotesYoffset = 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)
|
|
{
|
|
//string path = Volian.Base.Library.vlnStackTrace.StackToStringLocal(3, 1);
|
|
//Console.WriteLine("End {0}",path);
|
|
int profileDepth = ProfileTimer.Push(">>>> OnEndPage");
|
|
InitialsPrinted = false;
|
|
MyPromsPrinter.OnStatusChanged(string.Format("Page {0}", CurrentPageNumber+1));
|
|
bool onBlankPage = OnBlankPage;
|
|
if (OnBlankPage)
|
|
{
|
|
OnBlankPage = false;
|
|
}
|
|
else if (!OnFoldoutPage)
|
|
{
|
|
if (DidFirstPageDocStyle) SetDocStyleAndValues();
|
|
AddBookmarks(writer);
|
|
MyPageCounts.CanIncrement = true;
|
|
base.OnEndPage(writer, document);
|
|
DrawFootnotes(writer.DirectContent);
|
|
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 || MySection.ActiveFormat.PlantFormat.FormatData.PrintData.WCNTraining)
|
|
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;
|
|
ProfileTimer.Pop(profileDepth);
|
|
}
|
|
|
|
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 - _AdjustTopMarginForMultiLinePageListItems; }
|
|
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 (Volian.Base.Library.VlnSettings.GetCommandFlag("InchRuler"))
|
|
{
|
|
if (i % 6 == 0) w = 30;
|
|
else if (i % 3 == 0) w = 20;
|
|
}
|
|
else
|
|
{
|
|
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 (Volian.Base.Library.VlnSettings.GetCommandFlag("InchRuler"))
|
|
{
|
|
if (i % 7 == 0) w = 30;
|
|
//else if (i % 5 == 0) w = 20;
|
|
}
|
|
else
|
|
{
|
|
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)
|
|
{
|
|
int lev = pb.Level;
|
|
if (MyPdfOutlines.Count < lev || lev==0)
|
|
{
|
|
PdfDestination dest = new PdfDestination(PdfDestination.FIT);
|
|
PdfOutline pdo = new PdfOutline(writer.DirectContent.RootOutline, dest, pb.Title, false);
|
|
if (MyPdfOutlines.Count == lev)
|
|
MyPdfOutlines.Add(pdo);
|
|
else
|
|
MyPdfOutlines[lev] = pdo;
|
|
}
|
|
else
|
|
{
|
|
PdfDestination dest =pb.PdfDestination;
|
|
if(dest==null) dest = new PdfDestination(PdfDestination.FIT);
|
|
PdfOutline pdo = new PdfOutline(MyPdfOutlines[lev-1], dest,Regex.Replace(pb.Title, @"\\{Prerequisite Step: .*?\\}", ""), false);
|
|
if (MyPdfOutlines.Count == lev)
|
|
MyPdfOutlines.Add(pdo);
|
|
else
|
|
MyPdfOutlines[lev] = pdo;
|
|
}
|
|
}
|
|
PageBookmarks.Clear();
|
|
}
|
|
private void DrawFootnotes(PdfContentByte cb)
|
|
{
|
|
float tmp = 0;
|
|
if (NotesToFootNotes != null && NotesToFootNotes.Count > 0)
|
|
{
|
|
float _PointsPerPage = 792;
|
|
float yTopMargin = _PointsPerPage - (float)MySection.MyDocStyle.Layout.TopMargin;
|
|
float myYOff = NotesToFootNotesYoffset;
|
|
foreach (vlnParagraph ntfn in NotesToFootNotes)
|
|
{
|
|
// subtract from yTopMargin to take the location from the 'roll of paper'
|
|
// to the physical page location.
|
|
ntfn.YOffset = yTopMargin - myYOff;
|
|
ntfn.YTopMost = yTopMargin - myYOff;
|
|
|
|
ntfn.Processed = false; // process from here
|
|
// Only use ParagraphToPdf for printing of a single step.
|
|
// This is assuming that footnotes do not have child steps.
|
|
ntfn.ParagraphToPdf(cb, yTopMargin, yTopMargin, tmp);
|
|
//ntfn.ToPdf(cb, yTopMargin, ref yTopMargin, ref tmp);
|
|
|
|
myYOff -= (ntfn.Height); // - vlnPrintObject.SixLinesPerInch);
|
|
}
|
|
NotesToFootNotes = null;
|
|
}
|
|
}
|
|
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;
|
|
bool bothFootnotes = cb.MyParent.MyItemInfo.IsFootnote && vcb.MyParent.MyItemInfo.IsFootnote;
|
|
if (!bothFootnotes && cb.MyParent.MyItemInfo.MyHLS != null && vcb.MyParent.MyItemInfo.MyHLS != null &&
|
|
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;
|
|
HasInitials = false;
|
|
PIInitials = null;
|
|
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.DisplayNumber;
|
|
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;
|
|
//Console.WriteLine("\"{0}\"\t\"{1}\"\t{2}", MySection.DisplayNumber, MySection.DisplayText, numseq);
|
|
switch (numseq)
|
|
{
|
|
case E_NumberingSequence.GroupedByPagination:
|
|
key = ((int)E_NumberingSequence.WithSteps).ToString();
|
|
break;
|
|
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.WithinEachDocStyle1:
|
|
// key = key + "." + MySection.DisplayNumber;
|
|
// break;
|
|
case E_NumberingSequence.WithinEachSection:
|
|
key = key + "." + MySection.ItemID;
|
|
break;
|
|
case E_NumberingSequence.WithinEachSectionNumber:
|
|
key = key + "." + ( MySection.DisplayNumber == "" ? (MySection.ActiveParent as ItemInfo).DisplayNumber : MySection.DisplayNumber);
|
|
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; }
|
|
}
|
|
private bool _OldTemplateContMsg = false;
|
|
public bool OldTemplateContMsg
|
|
{
|
|
get { return _OldTemplateContMsg; }
|
|
set { _OldTemplateContMsg = value; }
|
|
}
|
|
private float _AdjustTopMarginForMultiLinePageListItems = 0;
|
|
public float AdjustTopMarginForMultiLinePageListItems
|
|
{
|
|
get { return _AdjustTopMarginForMultiLinePageListItems; }
|
|
set { _AdjustTopMarginForMultiLinePageListItems = 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 "{CM:(Cont)}":
|
|
if (OldTemplateContMsg)
|
|
plstr = plstr.Replace("{CM:(Cont)}", "(Cont)");
|
|
else
|
|
plstr = plstr.Replace("{CM:(Cont)}", "");
|
|
break;
|
|
case "{RF:REFERENCE}":
|
|
// This token is used by IP2. In 16bit it is processed when the PO_DISTRIBUTEAPPROVED
|
|
// purchase option is set and a file 'ref.dat' exists. Text from this file replaced
|
|
// the token. It was decided by RHM/KBR on 10/7/14 that this would not be implemented
|
|
// unless/until it is determined that it is used (no data that Volian currently has
|
|
// contains this file). To implement it requires a config item off of the procedure level,
|
|
// user interface support on the Procedure Properties dialog and print support.
|
|
plstr = plstr.Replace("{RF:REFERENCE}", "");
|
|
break;
|
|
case "{NULLDOCCURPAGE}":
|
|
// This token is used by IP2. There was no support for it in 16bit and the 16bit to 32bit
|
|
// output compared so it is just removed here so that a pagelist token error is not output
|
|
// in error log.
|
|
plstr = plstr.Replace("{NULLDOCCURPAGE}", "");
|
|
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]":
|
|
case "{ATTACHTITLECONT}":
|
|
case "[ATTACHTITLECONT]":
|
|
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)
|
|
{
|
|
string stitle = section.DisplayText;
|
|
if (((section.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListAddSectCont) == E_DocStructStyle.DSS_PageListAddSectCont)
|
|
&& token.Contains("ATTACHTITLECONT") && DidFirstPageDocStyle)
|
|
{
|
|
string myMsg = section.MyDocStyle.Continue.Top.Message;
|
|
if (myMsg != null && myMsg != "")stitle = stitle + myMsg;
|
|
}
|
|
plstr = SplitTitle(svgGroup, pageItem, stitle, 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 "{VALTYPE}":
|
|
ItemInfo firstHigh = ValveGetFirstStep(section);
|
|
if (firstHigh != null)
|
|
{
|
|
int typ = (int)firstHigh.MyContent.Type - 20000;
|
|
switch (typ)
|
|
{
|
|
case 2:
|
|
plstr = plstr.Replace(token, "VALVE");
|
|
break;
|
|
case 9:
|
|
plstr = plstr.Replace(token, "SWITCH");
|
|
break;
|
|
case 3:
|
|
plstr = plstr.Replace(token, "BREAKER");
|
|
break;
|
|
default:
|
|
plstr = plstr.Replace(token, "");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
plstr = plstr.Replace(token, "");
|
|
break;
|
|
case "{STARTUP}":
|
|
ItemInfo firstHighs = ValveGetFirstStep(section);
|
|
if (firstHighs != null)
|
|
{
|
|
int typs = (int)firstHighs.MyContent.Type - 20000;
|
|
switch (typs)
|
|
{
|
|
case 2:
|
|
// the following test for OI-3A came from 16bit code:
|
|
string num = section.MyProcedure.MyContent.Number.ToUpper().Replace(@"\U8209?", "-");
|
|
if (num.Equals("OI-3A"))
|
|
plstr = plstr.Replace(token, " SDC/");
|
|
else
|
|
plstr = plstr.Replace(token, "STARTUP/");
|
|
break;
|
|
default:
|
|
plstr = plstr.Replace(token, "");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
plstr = plstr.Replace(token, "");
|
|
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 "{INITIALS}":
|
|
// For Calvert: if this section has checkoffs turned on, put out this pagelist item:
|
|
// Get SectionInfos to access specific section config items...
|
|
//SectionInfo si = SectionInfo.Get(MySection.ItemID);
|
|
//SectionInfo si = MySection.GetSectionInfo();
|
|
//SectionConfig sectCfg = si.MyConfig as SectionConfig;
|
|
//int sc = sectCfg.Section_CheckoffListSelection;
|
|
if (!MySection.HasInitials)
|
|
{
|
|
plstr = plstr.Replace(token, "");
|
|
//PIInitials = pageItem;
|
|
}
|
|
else
|
|
{
|
|
if (pageItem.Row == -MySection.MyDocStyle.Layout.TopMargin)
|
|
{
|
|
plstr = plstr.Replace(token, "");
|
|
PIInitials = pageItem;
|
|
}
|
|
else
|
|
plstr = plstr.Replace(token, "INITIALS");
|
|
}
|
|
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;
|
|
case "[UNIT]":
|
|
string un = MySection.MyDocVersion.DocVersionConfig.Print_UnitNumberForPageList;
|
|
plstr = plstr.Replace(token, un);
|
|
break;
|
|
default:
|
|
if (token.Contains(@"SI-")) // folder or working draft specific information.
|
|
{
|
|
DocVersionConfig dvConfig = new DocVersionConfig(section.MyProcedure.MyDocVersion.Config);
|
|
FolderConfig folderConfig = new FolderConfig(section.MyProcedure.MyDocVersion.MyFolder.Config);
|
|
if (dvConfig != null || folderConfig != null)
|
|
{
|
|
int indx = token.IndexOf("-");
|
|
int qindx = token.IndexOf("?", indx);
|
|
string val = null;
|
|
if (qindx == -1)
|
|
{
|
|
val = GetInheritedSIValue(section.MyProcedure, token.Substring(4, token.Length - 5));
|
|
plstr = plstr.Replace(token, val);
|
|
}
|
|
else
|
|
{
|
|
string pstok = token.Substring(indx + 1, qindx - indx - 1);
|
|
plstr = GetInheritedSIValue(section.MyProcedure, pstok);
|
|
//if (dvConfig != null)
|
|
// plstr = dvConfig.GetValue("SI", pstok);
|
|
//if ((plstr == null || plstr == "") && folderConfig != null)
|
|
// plstr = folderConfig.GetValue("SI", 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.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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));
|
|
|
|
// MaxWidth is used to define width that the PSI text spans x-direction on page. If it is
|
|
// defined, see if the text is too wide for a single line (SplitTextMaxWidth). The
|
|
// AdjustTopMarginForMultLinePageListItem contains the y-adjustment that must be considered
|
|
// in the TopMargin if the PSI text split onto more than one line.
|
|
if ((pageItem.MaxWidth??0)>0)
|
|
{
|
|
int locwid = (int)pageItem.MaxWidth;
|
|
AdjustTopMarginForMultiLinePageListItems = SplitTextMaxWidth(svgGroup, pageItem, val, locwid, token, ref plstr);
|
|
}
|
|
else
|
|
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 GetInheritedSIValue(ProcedureInfo pi, string fieldName)
|
|
{
|
|
string val = null;
|
|
DocVersionConfig dvConfig = new DocVersionConfig(pi.MyDocVersion.Config);
|
|
if (dvConfig != null)
|
|
{
|
|
val = dvConfig.GetValue("SI", fieldName);
|
|
if (val != null && val != "") return val; // the value exists within the docversion level
|
|
}
|
|
FolderInfo fi = pi.MyDocVersion.MyFolder;
|
|
while (fi != null)
|
|
{
|
|
FolderConfig folderConfig = new FolderConfig(fi.Config);
|
|
if (folderConfig != null)
|
|
{
|
|
val = folderConfig.GetValue("SI", fieldName);
|
|
if (val != null && val != "") return val; // the value exists within this folder
|
|
}
|
|
fi = fi.ActiveParent as FolderInfo;
|
|
}
|
|
return val;
|
|
}
|
|
private static ItemInfo ValveGetFirstStep(VEPROMS.CSLA.Library.SectionInfo section)
|
|
{
|
|
ItemInfo firstHigh = null;
|
|
if (section.Steps == null || section.Steps.Count == 0)
|
|
{
|
|
// see if there is a 1st subsection with a step. The formats must match
|
|
// if this is true, use that step. Otherwise just clear the token.
|
|
if (section.Sections != null && section.Sections.Count > 0 &&
|
|
section.Sections[0].Steps != null || section.Sections[0].Steps.Count != 0)
|
|
{
|
|
if (section.ActiveFormat.FormatID == section.Sections[0].ActiveFormat.FormatID &&
|
|
section.MyContent.Type == section.Sections[0].MyContent.Type)
|
|
firstHigh = section.Sections[0].Steps[0];
|
|
}
|
|
}
|
|
else
|
|
firstHigh = section.Steps[0];
|
|
return firstHigh;
|
|
}
|
|
|
|
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 float SplitTextMaxWidth(SvgGroup svgGroup, VEPROMS.CSLA.Library.PageItem pageItem, string title, int? len, string match, ref string plstr)
|
|
{
|
|
List<string> titleLines = Volian.Base.Library.RtfTools.SplitText(title, (int)len);
|
|
float yOffset = 0;
|
|
int cnt = 0;
|
|
foreach (string line in titleLines)
|
|
{
|
|
cnt++;
|
|
if (cnt == 1 && yOffset == 0)
|
|
plstr = plstr.Replace(match, line);
|
|
else
|
|
{
|
|
if (cnt == 1)
|
|
{
|
|
plstr = plstr.Replace(match, line); // include preceeding text with the first line v.c. summer
|
|
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 Math.Max(0, yOffset);
|
|
}
|
|
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); // include preceeding text with the first line v.c. summer
|
|
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 PageItem _PIInitials = null;
|
|
public PageItem PIInitials
|
|
{
|
|
get { return _PIInitials; }
|
|
set
|
|
{
|
|
if (_PIInitials != null && value == null)
|
|
_LastPIInitials = _PIInitials;
|
|
_PIInitials = value;
|
|
}
|
|
}
|
|
private PageItem _LastPIInitials = null;
|
|
public PageItem LastPIInitials
|
|
{
|
|
get { return _LastPIInitials; }
|
|
set { _LastPIInitials = value; }
|
|
}
|
|
private bool _HasInitials = false;
|
|
public bool HasInitials
|
|
{
|
|
get { return _HasInitials; }
|
|
set { _HasInitials = value; }
|
|
}
|
|
private bool _InitialsPrinted = false;
|
|
public bool InitialsPrinted
|
|
{
|
|
get { return _InitialsPrinted; }
|
|
set { _InitialsPrinted = value; }
|
|
}
|
|
public bool PrintInitials(PdfContentByte cb,float yLocation, float leftMargin)
|
|
{
|
|
if (InitialsPrinted) return false;
|
|
InitialsPrinted = true;
|
|
vlnParagraph.TextAt(cb,this, PIInitials ?? LastPIInitials, yLocation, leftMargin);
|
|
return true;
|
|
}
|
|
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;
|
|
case "{NULLDOCCURPAGE}":
|
|
return "";
|
|
}
|
|
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;
|
|
}
|
|
internal bool IsTopLevel
|
|
{
|
|
get
|
|
{
|
|
ItemInfo parent = MyItemInfo.ActiveParent as ItemInfo;
|
|
if (parent == null || parent.IsProcedure) return true;
|
|
return false;
|
|
}
|
|
}
|
|
internal int Level
|
|
{
|
|
get
|
|
{
|
|
int level = 0;
|
|
ItemInfo parent = MyItemInfo.ActiveParent as ItemInfo;
|
|
while (parent != null && !parent.IsProcedure)
|
|
{
|
|
level++;
|
|
parent = parent.ActiveParent as ItemInfo;
|
|
}
|
|
return level;
|
|
}
|
|
}
|
|
}
|
|
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));
|
|
}
|
|
}
|
|
}
|