Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
SourceCode/PROMS/Volian.Print.Library/Pagination.cs

1888 lines
117 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Text;
using VEPROMS.CSLA.Library;
using Volian.Base.Library;
using iTextSharp.text.pdf;
using Volian.Svg.Library;
namespace Volian.Print.Library
{
public partial class vlnParagraph
{
private string _PageBreakReason = null;
public string PageBreakReason
{
get { return _PageBreakReason; }
set { _PageBreakReason = value; }
}
private bool _CompressPartOfStep = false;
public bool CompressPartOfStep
{
get { return _CompressPartOfStep; }
set { _CompressPartOfStep = value; }
}
private bool _CompressFirstPartOfStep = false;
public bool CompressFirstPartOfStep
{
get { return _CompressFirstPartOfStep; }
set { _CompressFirstPartOfStep = value; }
}
private bool _BreakHighLevelStepWithSection = false;
public bool BreakHighLevelStepWithSection
{
get { return _BreakHighLevelStepWithSection; }
set { _BreakHighLevelStepWithSection = value; }
}
/// <summary>
/// This variable is used to match 16 bit pagination
/// </summary>
private bool _Match16BitPagination = false;
private bool _CompressFoldout = false;
public bool CompressFoldout
{
get { return _CompressFoldout; }
set { _CompressFoldout = value; }
}
/// <summary>
/// Dtermines if the current step is preceded by a Page Break
/// </summary>
/// <param name="yLocation"></param>
/// <param name="yTopMargin"></param>
/// <param name="yBottomMargin"></param>
/// <returns>
/// 0 - No page break
/// 1 - Break on High Level Step
/// 2 - Break within a Step
/// 3 - Break on High Level Step (SevenLinesPerInch)
/// </returns>
private int Paginate(float yLocation, float yTopMargin, float yBottomMargin)
{
// Check if paginate on a separate section, if within a section. Top level section pagination happens in PromsPrinter
float yPageSize = yTopMargin - yBottomMargin;
bool ManualPageBreak = false;
float yWithinMargins = CalculateYLocation(yLocation, yTopMargin) - yBottomMargin; // -SixLinesPerInch;
if (MyItemInfo.IsSection && MyParent != null && MyParent.MyItemInfo.IsSection && (MyItemInfo as SectionInfo).IsSeparatePagination())
{
ShowPageBreak(1, "Page Break between separate sections", "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
// if parent was continuous & this is separate, need to paginate to get subsection on
// its own page. This occurred in BGE/OI3 set/OI-7 procedure/10.0 Attachments.
if (!(MyParent.MyItemInfo as SectionInfo).IsSeparatePagination()) return 1;
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.WCNTraining && (MyItemInfo as SectionInfo).IsSeparatePagination()) return 1;
// B2017-273 added a check for Farley format, we don't want the subsection pagelist infor to appear on the parent section page - works with ToPDF() logic - (section has steps and a sub-section ex: FNP-2-EEP-0 Attachment 4)
if (MyItemInfo.ActiveFormat.Name.ToUpper().StartsWith("FNP") && (MyItemInfo as SectionInfo).IsSeparatePagination()) return 1;
if (MyItemInfo.MyPrevious != null) // add if statement to fix Westinghouse print issue 3-21-2014
return 1;
}
if (MyItemInfo.IsSection && _ChildrenBelow == null && YSize > (yLocation-yBottomMargin))
{
ShowPageBreak(1, "Page Break before empty section", "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 1;
}
// If printing a supinfo pdf, see if there is a page break at this supinfo paragraph, i.e. an entry will
// exist in the list that contains the supinfo paragraph pagebreaks that was generated in the first pagebreak pass
if (MyPromsPrinter.SupInfoPrintType == E_SupInfoPrintType.SupInfoPdfPrint)
{
int retval = 0;
SectionInfo supInfoSect = MyItemInfo.ActiveSection as SectionInfo; // C2018-003 fixed use of getting the active section
if (supInfoSect != null && supInfoSect.StepSectPageBreaksForSupInfo != null && supInfoSect.StepSectPageBreaksForSupInfo.Contains(MyItemInfo.ItemID))
{
MyPromsPrinter.SupInfoPdfPageCount++;
retval = 1;
}
// Printing the supplemental information pages to a pdf: add an item to the dictionary that says what page in the supinfo pdf
// this item can be found on.
if (MyItemInfo.IsSupInfoPart)
{
MyPromsPrinter.SupInfoPdfPage.Add(MyItemInfo.ItemID, MyPromsPrinter.SupInfoPdfPageCount);
}
return retval;
}
else if (MyItemInfo.MyDocStyle.SupplementalInformation && MyItemInfo.IsStep)
{
// if this is the first caution or note from a substep, if the substep has preferred page break, break at the first caution or note:
if ((MyItemInfo.IsCaution || MyItemInfo.IsNote) && MyItemInfo.MyParent.IsSubStep)
{
StepConfig scs = MyItemInfo.MyParent.MyConfig as StepConfig;
if (MyItemInfo.MyPrevious == null && scs.Step_PreferredPagebreak)
{
// B2018-103: The following flags a break within the step. Before returning a '2' (flags break within step), clear it out of the
// ParaBreaks. Without the 'RemoveAt', a page break will occur after this step also.
if (MyPageHelper.ParaBreaks != null && MyPageHelper.ParaBreaks.Count > 0 && this == MyPageHelper.ParaBreaks[0])
{
MyPageHelper.ParaBreaks.RemoveAt(0);
string reason1 = AddReason("Partial Step - Case 5");
ShowPageBreak(1, reason1, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
}
return 2;
}
}
// Now see if there is a preferred page break on this step.
StepConfig sci = MyItemInfo.MyConfig as StepConfig;
if (sci.Step_PreferredPagebreak)
{
if (MyItemInfo.IsHigh) return 1;
// if this is the top caution/note return 1 also. Cautions always are first, that is why the check does not need to know if on a
// caution that there are notes, but check does need if on a note, are there cautions:
if (MyItemInfo.MyParent.IsHigh && MyItemInfo.IsCaution && MyItemInfo.MyPrevious == null) return 1;
if (MyItemInfo.MyParent.IsHigh && MyItemInfo.IsNote && (MyItemInfo.MyParent.Cautions == null || MyItemInfo.MyParent.Cautions.Count == 0) && MyItemInfo.MyPrevious == null) return 1;
// if this is a substep that has a preferredpage break, and it has caution/note that is where the page break had to go
if (MyItemInfo.IsSubStep && ChildrenAbove != null && ChildrenAbove.Count > 0) return 0;
// B2017-228: The following flags a break within the step. Before returning a '2' (flags break within step), clear it out of the
// ParaBreaks. Without the 'RemoveAt', a page break will occur after this step also.
string reason = "Unknown";
if (MyPageHelper.ParaBreaks != null && MyPageHelper.ParaBreaks.Count > 0 && this == MyPageHelper.ParaBreaks[0])
{
MyPageHelper.ParaBreaks.RemoveAt(0);
reason = AddReason("Partial Step - Case 1");
ShowPageBreak(1, reason, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
}
return 2;
}
}
// if the EndForSingle format flag is set to false, then we do not print an End message if the section
// is a single column section.
//bool _skipEndMessage = MyPageHelper.MySection.SectionConfig.Section_ColumnMode == SectionConfig.SectionColumnMode.One && !MyItemInfo.ActiveFormat.MyStepSectionLayoutData.EndForSingle;
SectionInfo si = MyItemInfo.ActiveSection as SectionInfo; // C2018-003 fixed use of getting the active section
bool _skipEndMessage = si != null && si.SectionConfig.Section_ColumnMode == SectionConfig.SectionColumnMode.One && !MyItemInfo.ActiveFormat.MyStepSectionLayoutData.EndForSingle;
// TODO: This does not account for a long step as the last step that would exceed more than one page and
// that has an end message that needs to be accounted for in determining pagination. To do that the last
// child should be the only paragraph that accounts for the End message.
//
// If last step & there should be an end message, pagination tests need to account for the 3 lines the end
// message uses. The 3 is for a line above, the end message line & the line below (in case there is a border/box line).
// The 3 was changed to 2 for the end line & the line below. The blank line below the step gives the blank
// line above the end message, thus 2 not 3. This change was made on July 20, 2011 by RHM & KBR. The
// procedure in questions was VEWCNEMG\EMGAPP.PRC, ES-01, Step 8.
//float yEndMsg = !_skipEndMessage && !MyItemInfo.IsSection && MyItemInfo.MyHLS != null && MyItemInfo.MyHLS.NextItem == null && (MyItemInfo.MyDocStyle.End.Message ?? "") != "" ? 2 * SixLinesPerInch : 0;
float yEndMsg = (!_skipEndMessage && !MyItemInfo.IsSection && MyItemInfo.MyHLS != null && MyItemInfo.MyHLS.NextItem == null)? GetEndMessageHeight(MyItemInfo.MyDocStyle) : 0; // B2018-068 account for mult-line End Messages
// also consider if there is a phone list at the bottom of the page, add the amount of space the phone
// list requires onto yEndMsg to make it easier to figure out pagination (include an extra line for the
// horizonal line above the phone list.
// B2018-079 - we don't need the phone list length in this case only the length of the end message because the phone list is printed below the footer but the end message is shifted up.
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.PrintPhoneList && MyPageHelper.PhoneListHeight != 0)
yEndMsg += GetBottomContinueMessageSize(MyItemInfo.MyDocStyle);//(MyPageHelper.PhoneListHeight - vlnPrintObject.SixLinesPerInch);
// The following code is to fix a pagination issue in SHE. It was decided to not put it into development
// because some of the pagination logic may be redesigned. Without this fix, some pages had a page break
// before they should. I did not want to lose this code, in case at some point we want to revisit this.
// if doing an end message & we already are ending with a blank line, add one line for the end message
// otherwise, we need to add two lines, i.e. ((2 * SixLinesPerInch) - yEndsWithBlankLine)
// this change was necessary to fix a pagination problem in Shearon Harris, EOPs, User Guide, Attachment 2.
//float yEndsWithBlankLine = AdjustForBlankLines();
//KBR debug: if (yEndsWithBlankLine != 0) Console.WriteLine("*** yEndsWithBlankLine = {0}", yEndsWithBlankLine);
//float yEndMsg = !MyItemInfo.IsSection && MyItemInfo.MyHLS.NextItem == null && (MyItemInfo.MyDocStyle.End.Message ?? "") != "" ? ((2 * SixLinesPerInch) - yEndsWithBlankLine) : 0;
bool isFirstChild = MyItemInfo.MyPrevious == null;
bool nearTheTop = (yWithinMargins < yPageSize) && (yWithinMargins > (yPageSize - 5 * SixLinesPerInch));
// if step is breaking over a number of pages, determine if the current step is the
// location of a pagebreak. ParaBreaks contains the paragraphs that break within a step.
if (MyPageHelper.ParaBreaks.Count > 0)
{
string reason = "Unknown";
// if on current step and it is also the substep that will cause a pagebreak, i.e. the top substep in pagebreaks[[0]:
if (this == MyPageHelper.ParaBreaks[0])
{
MyPageHelper.ParaBreaks.RemoveAt(0);
reason = AddReason("Partial Step - Case 1");
ShowPageBreak(1,reason, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 2; // break on this item within a step
}
// check for rnos:
else if (MyPageHelper.ParaBreaks[0].CheckAlternates(this))
{
MyPageHelper.ParaBreaks.RemoveAt(0);
reason = AddReason("Partial Step - Case 2");
ShowPageBreak(1, reason, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 2; // break on this item within a step
}
///////////////////
// The following else ifs are reached if something previously went wrong in pagination & this code tries to account for it.
///////////////////
// PageBreakOnStep flags break for cautions/notes/HLS in backgrounds & deviations. Don't check for that case.
// If you are in this code debugging, consider looking at ToPdf to see why the 'pagebreak above' (MyPageHelper.ParaBreaks[0])
// the current step (this) has not caused a page break in the pdf prior to reaching this code. (RHM & KBR)
else if (!MyPageHelper.ParaBreaks[0].PageBreakOnStep && this.YTopMost > MyPageHelper.ParaBreaks[0].YTopMost) // current step is further down on page than MyPageHelper.ParaBreaks[0]
{
MyPageHelper.ParaBreaks.RemoveAt(0);
reason = AddReason("Partial Step - Case 3");
ShowPageBreak(1, reason, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 2; // break on this item within a step
}
// B2018-015 Pagination Issue VCS EOP-15.0 Step 15 - Handle when RNO is exactly aligned with the AER column
// B2018-065 Calvert's continue message was not including the substep number in AOP-1A Attachment 1, added AERandRNO check
else if (!MyPageHelper.ParaBreaks[0].PageBreakOnStep && this.YTopMost >= MyPageHelper.ParaBreaks[0].YTopMost && AERandRNO(this.MyItemInfo, MyPageHelper.ParaBreaks[0].MyItemInfo))
{
//vlnParagraph removed = MyPageHelper.ParaBreaks[0];// 2018-081 Remember where the page break was going to be
MyPageHelper.ParaBreaks.RemoveAt(0);
//if (MyParent == removed && MyItemInfo.IsRNOPart && MyParent.MyItemInfo.IsHigh)// B2018-081 If The High Level Step was going to break from the High Level RNO
//{
// reason = AddReason("Partial Step - Case 4B");
// ShowPageBreak(1, reason, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
// return 0;
//}
reason = AddReason("Partial Step - Case 4");
ShowPageBreak(1, reason, "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 2; // break on this item within a step
}
return 0; // this is not an item with a break
}
float mySize = YSize * MyPageHelper.YMultiplier;
vlnParagraph firstChild = ChildrenBelow.Count > 0 ? ChildrenBelow[0] : null;
// Steps that have the smart template (the WCNCKL format for example), always include two children.
if (MyItemInfo.IsHigh && MyItemInfo.FormatStepData.UseSmartTemplate) //
{
if (ChildrenBelow.Count > 1)
firstChild = ChildrenBelow[1];
}
else if (!MyItemInfo.IsSection && firstChild != null && firstChild.MyItemInfo != null && !firstChild.MyItemInfo.IsNumbered) // If not numbered get the last child
firstChild = firstChild.MyParent.ChildrenBelow[firstChild.MyParent.ChildrenBelow.Count - 1];
float ySizeIncludingFirst = firstChild == null ? YSize : firstChild.YSize + (firstChild.YTopMost - YTopMost);
bool KeepStepsOnPage = MyItemInfo.ActiveFormat.MyStepSectionLayoutData.KeepStepsOnPage;
if (MyItemInfo.IsStepSection)
{
if (yLocation < yTopMargin) // continuous section
{
if (ChildrenBelow == null || ChildrenBelow.Count == 0)
{
// see if there is an end message. This is stored in the helper - if there is,
// we need to be sure that there is room for it.
if (MyPageHelper.BottomMessage != null && MyPageHelper.BottomMessage.Count != 0)
{
if (mySize + yEndMsg <= yWithinMargins) return 1;
}
return 0;
}
// This is a continuous section. There may be cases where the user put a manual page
// break on the first step (child) in the section. if so, break on the section. The
// flag SectionPageBreak is set to true to flag that a pagebreak should not be done
// on that first step.
StepConfig sc = firstChild.MyItemInfo.MyConfig as StepConfig;
ManualPageBreak = MyPageHelper.OriginalPageBreak ? (sc == null ? false : sc.Step_ManualPagebreak) :
sc == null ? false :
MyPageHelper.MyPromsPrinter.RemoveTrailingHardReturnsAndManualPageBreaks ? false : sc.Step_NewManualPagebreak;
if (ManualPageBreak)
{
SectionPageBreak = true;
ShowPageBreak(2, "Section Page Break", "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 1;
}
// can the title and the first step fit?
// add the first child's size + (the section title's size)
//if (ySizeIncludingFirst > (yLocation - yBottomMargin - SixLinesPerInch)) return 1;
//if (ySizeIncludingFirst > (yLocation - yBottomMargin) && ySizeIncludingFirst < yPageSize)
vlnParagraph firstStepChild = firstChild;
//while (firstStepChild.MyItemInfo.IsSection && firstStepChild.ChildrenBelow.Count > 0) firstStepChild = firstStepChild.ChildrenBelow[0];
if (firstStepChild.MyItemInfo.IsNumbered)
while (firstStepChild.ChildrenBelow.Count > 0 && (firstStepChild.MyItemInfo.IsSection || firstStepChild.MyItemInfo.IsHigh))
{
firstStepChild = firstStepChild.ChildrenBelow[0];
if (!firstStepChild.MyItemInfo.IsNumbered)
{
firstStepChild = firstStepChild.MyParent.ChildrenBelow[firstStepChild.MyParent.ChildrenBelow.Count - 1];
break;
}
}
else
firstStepChild = firstStepChild.MyParent.ChildrenBelow[firstStepChild.MyParent.ChildrenBelow.Count - 1];
float ySizeIncludingFirstStep = firstStepChild.YSize + (firstStepChild.YTopMost - YTopMost);
float ySizeBtmCtnMess = GetBottomContinueMessageSize(MyItemInfo.MyDocStyle);
float ySizeBtmEndMess = GetBottomEndMessageSize(MyItemInfo.MyDocStyle);
bool firstSubstepExceedsSpaceAvailable = ySizeIncludingFirstStep > (yWithinMargins - ySizeBtmCtnMess -ySizeBtmEndMess);
if (KeepStepsOnPage && firstSubstepExceedsSpaceAvailable && !isFirstChild)
KeepStepsOnPage = false;
if (ySizeIncludingFirst == YSize) KeepStepsOnPage = false;
//float ySectionEndMsg = !_skipEndMessage && MyItemInfo.IsSection && MyItemInfo.Steps != null && MyItemInfo.Steps.Count == 1 && (MyItemInfo.MyDocStyle.End.Message ?? "") != "" ? 2 * SixLinesPerInch : 0;
float ySectionEndMsg = (!_skipEndMessage && MyItemInfo.IsSection && MyItemInfo.Steps != null && MyItemInfo.Steps.Count == 1) ? GetEndMessageHeight(MyItemInfo.MyDocStyle) : 0; // B2018-068 account for mult-line End Messages
if (MyPageHelper.NotesToFootNotes != null && MyPageHelper.NotesToFootNotes.Count > 0)
{
float vpHeight = SixLinesPerInch;
foreach (vlnParagraph vp in MyPageHelper.NotesToFootNotes) vpHeight += vp.Height;
ySectionEndMsg += vpHeight;
}
if (ySizeIncludingFirstStep < yWithinMargins && ySizeIncludingFirst > yWithinMargins && yWithinMargins > (yPageSize / 2))
ySizeIncludingFirst = ySizeIncludingFirstStep;
if (!KeepStepsOnPage && (ySizeIncludingFirst + ySectionEndMsg) >
(yLocation - (MyItemInfo.MyDocStyle.Layout.FooterLength + yBottomMargin)) && !nearTheTop)
{
if (!MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert ||
(ySizeIncludingFirst < yPageSize || yWithinMargins < (yPageSize - (2 * 72))))
{
// .oooooo. . o8o .oooooo..o . o8o
// d8P' `Y8b .o8 `"' d8P' `Y8 .o8 `"'
// 888 .ooooo. ooo. .oo. .o888oo oooo ooo. .oo. oooo oooo .ooooo. oooo oooo .oooo.o Y88bo. .ooooo. .ooooo. .o888oo oooo .ooooo. ooo. .oo. .oooo.o
// 888 d88' `88b `888P"Y88b 888 `888 `888P"Y88b `888 `888 d88' `88b `888 `888 d88( "8 `"Y8888o. d88' `88b d88' `"Y8 888 `888 d88' `88b `888P"Y88b d88( "8
// 888 888 888 888 888 888 888 888 888 888 888 888 888 888 888 `"Y88b. `"Y88b 888ooo888 888 888 888 888 888 888 888 `"Y88b.
// `88b ooo 888 888 888 888 888 . 888 888 888 888 888 888 888 888 888 o. )88b oo .d8P 888 .o 888 .o8 888 . 888 888 888 888 888 o. )88b
// `Y8bood8P' `Y8bod8P' o888o o888o "888" o888o o888o o888o `V88V"V8P' `Y8bod8P' `V88V"V8P' 8""888P' 8""88888P' `Y8bod8P' `Y8bod8P' "888" o888o `Y8bod8P' o888o o888o 8""888P'
ShowPageBreak(4, "Page Break Before Continuous Step Section", "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 1;
}
}
if (ChildrenBelow.Count > 0)
{
vlnParagraph firstHLS = ChildrenBelow[0];
if (firstHLS.MyItemInfo.IsHigh)
firstHLS.BreakHighLevelStepWithSection = true;
}
}
// Compress Foldout
//
// .oooooo. oooooooooooo oooo .o8 .
// d8P' `Y8b `888' `8 `888 "888 .o8
// 888 .ooooo. ooo. .oo. .oo. oo.ooooo. oooo d8b .ooooo. .oooo.o .oooo.o 888 .ooooo. 888 .oooo888 .ooooo. oooo oooo .o888oo
// 888 d88' `88b `888P"Y88bP"Y88b 888' `88b `888""8P d88' `88b d88( "8 d88( "8 888oooo8 d88' `88b 888 d88' `888 d88' `88b `888 `888 888
// 888 888 888 888 888 888 888 888 888 888ooo888 `"Y88b. `"Y88b. 888 " 888 888 888 888 888 888 888 888 888 888
// `88b ooo 888 888 888 888 888 888 888 888 888 .o o. )88b o. )88b 888 888 888 888 888 888 888 888 888 888 888 .
// `Y8bood8P' `Y8bod8P' o888o o888o o888o 888bod8P' d888b `Y8bod8P' 8""888P' 8""888P' o888o `Y8bod8P' o888o `Y8bod88P" `Y8bod8P' `V88V"V8P' "888"
// 888
// o888o
// This is a foldout pages
// The format supports compression
// The contents exceeds the length of the page
// The Contents fit at seven lines per inch
//C2019-042 Section_IsFoldout checks Section Number, Section Title, and use of check box
if ((MyItemInfo.MyActiveSection.MyConfig as SectionConfig).Section_IsFoldout == "Y"
&& MyItemInfo.ActiveFormat.MyStepSectionLayoutData.CompressSteps
&& mySize > yPageSize
&& mySize <= yPageSize * SixLinesPerInch / _SevenLinesPerInch)
CompressFoldout = true;
return 0; // Don't Paginate (page break) on a Step Section if it's first thing on page
}
if (!MyItemInfo.IsHigh) return 0; // Don't Paginate on a Substep level
bool doSectionTitleContinued = false;
if (MyPageHelper.NotesToFootNotes != null && MyPageHelper.NotesToFootNotes.Count > 0)
{
float vpHeight = SixLinesPerInch;
foreach (vlnParagraph vp in MyPageHelper.NotesToFootNotes) vpHeight += vp.Height;
yEndMsg += vpHeight;
}
if (MyItemInfo.MyPrevious != null && !MyItemInfo.IsSection && MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ContinueSectionHeader)
{
SectionConfig sch = MyItemInfo.ActiveSection.MyConfig as SectionConfig;
doSectionTitleContinued = (sch == null || sch.Section_PrintHdr == "Y") && !MyItemInfo.MyDocStyle.CancelSectTitle;
}
// Document style: DSS_PageBreakHLS breaks on hls.
if (MyItemInfo.IsHigh && (MyItemInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageBreakHLS) == E_DocStructStyle.DSS_PageBreakHLS)
{
BuildPageBreakList(yPageSize, yPageSize, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, true);
ShowPageBreak(1, "Page Break on DSS_PageBreakHLS", "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 1;
}
// if this is a step, see if it has the 'PageBreakOnStep' format flag set to true, if so, break here.
if (MyItemInfo.FormatStepData != null && MyItemInfo.FormatStepData.PageBreakOnStep)
{
// if this step contains Cautions or Notes page breaks have to be added for those.
if (TopMostChild != this) PageBreakOnStep = true;
BuildPageBreakList(yPageSize, yPageSize, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, true); // Case 1 :Works for ES05 Step 15 SubStep 7
ShowPageBreak(1, "Page Break on Steps, Cautions or Notes", "Yes", YSize, yPageSize, yWithinMargins, ManualPageBreak);
return 1;
}
//MyPageHelper.HLSText = MyItemInfo.DisplayText; // save the High Level Step Text
//Console.WriteLine("{0} Paginate", MyPageHelper.HLSText);
StepConfig sc1 = MyItemInfo.MyConfig as StepConfig;
ManualPageBreak = MyPageHelper.OriginalPageBreak ? (sc1 == null ? false : sc1.Step_ManualPagebreak) :
sc1 == null ? false : MyPageHelper.MyPromsPrinter.RemoveTrailingHardReturnsAndManualPageBreaks ? false : sc1.Step_NewManualPagebreak;
if (MyItemInfo.FirstSibling == MyItemInfo && ManualPageBreak)
{
// if parent/section used this pagebreak, skip it.
if (MyParent.SectionPageBreak)
{
ManualPageBreak = false;
MyParent.SectionPageBreak = false;
}
}
if (_Match16BitPagination) mySize = YSize;
string firstStep = "No";
if (MyItemInfo.IsHigh && MyItemInfo.MyPrevious == null)
firstStep = "Yes";
//if (!ManualPageBreak && mySize + yEndMsg <= yWithinMargins) // Don't Paginate if there is enough room, will fit on page
// Pagination Fix - Break1LineShort1
float yExtra = (yWithinMargins == yPageSize ? 0 : SixLinesPerInch - MyItemInfo.MyDocStyle.Layout.FooterLength) ?? 0;
// Adjust yExtra and mySize for Component List items.
if (MyItemInfo.ActiveSection.MyDocStyle.ComponentList && yExtra > 0)
{
yExtra = 0;
if (mySize < Height) mySize = Height * MyPageHelper.YMultiplier;
}
float yExtra2 = (SixLinesPerInch - MyItemInfo.MyDocStyle.Layout.FooterLength) ?? 0;
if (KeepStepsOnPage && !MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PaginateOnLowerStepLevel && ySizeIncludingFirst > yWithinMargins)
KeepStepsOnPage = false;
bool KeepWithHeader = isFirstChild && nearTheTop;
if (BreakHighLevelStepWithSection) KeepWithHeader = true;
// for a HLS that has an asterisk box with the rno separator IN the box, adjust the size by 2 lines to account for box.
if (MyItemInfo.IsStep && MyItemInfo.MyHLS.FormatStepData.StepLayoutData.STBoxindex != null && MyItemInfo.MyHLS.FormatStepData.StepLayoutData.STBoxindex >= 0 &&
(MyItemInfo.RNOs==null ||MyItemInfo.RNOs.Count==0))
mySize += (2*SixLinesPerInch);
// mySize is the size of this step and includes an extra blank line. For HLS, if this is the last step in section & there is room in footer to keep
// step on the page, do so by eliminating the blank line before doing the test to see if it fits.
// B2017-254 Fixed Pagination Logic when checking to see if the current item is the last high level step
if (MyItemInfo.IsHigh && mySize >= (2 * SixLinesPerInch) && MyItemInfo.MyDocStyle.Layout.FooterLength > 0 && (MyItemInfo.MyDocStyle.End.Message == null || MyItemInfo.MyDocStyle.End.Message == "") && MyItemInfo.NextItem == null && (MyItemInfo.Steps == null || MyItemInfo.Steps.Count == 0) && (MyItemInfo.RNOs == null || MyItemInfo.RNOs.Count == 0))
mySize -= SixLinesPerInch;
//// Account for extra lines in the end message (flag < 0)
float adjMsgY = 0;
if (MyItemInfo.IsHigh && MyItemInfo.NextItem == null && MyItemInfo.MyDocStyle.End.Flag < 0) // Adjust this many lines down the page.
{
adjMsgY = (float)-MyItemInfo.MyDocStyle.End.Flag * SixLinesPerInch;
if (yEndMsg != 0) yEndMsg += adjMsgY;
}
if (!ManualPageBreak && (mySize + yEndMsg <= yWithinMargins + yExtra) || // Don't Paginate if there is enough room, will fit on page
(mySize <= yWithinMargins + yExtra && SpecialCaseForRobinson()))
//if (!ManualPageBreak && mySize + yEndMsg <= yWithinMargins + SixLinesPerInch) // Don't Paginate if there is enough room, will fit on page
{
// ooooo ooooo ooooo .oooooo..o o8o oooo oooo .o88o. o8o .
// `888' `888' `888' d8P' `Y8 `"' `888 `888 888 `" `"' .o8
// 888 888 888 Y88bo. oooo oooo ooo oooo 888 888 o888oo oooo .o888oo
// 888ooooo888 888 `"Y8888o. `88. `88. .8' `888 888 888 888 `888 888
// 888 888 888 `"Y88b `88..]88..8' 888 888 888 888 888 888
// 888 888 888 o oo .d8P `888'`888' 888 888 888 888 888 888 .
// o888o o888o o888ooooood8 8""88888P' `8' `8' o888o o888o o888o o888o o888o "888"
//Console.WriteLine("'PageBreak',1,'No','HLS will fit on page',{0},{1},{2}, {3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
ShowPageBreak(-1, "HLS will fit on page", firstStep, YSize, yPageSize, yWithinMargins,ManualPageBreak);
return 0;
}
// !MyItemInfo.IsHigh - if (MyItemInfo.IsRNOPart && MyParent.XOffset < XOffset) return 0; // Don't paginate on an RNO to the right
// YSize includes a blank line after the step which we don't want to include in the page break test, thus the
// YSize - SixLinesPerInch:
// yPageSizeNextPage is the page size of the 'next' page. A format variable exists off of the docstyle
// For UseOnFirstPage vs UseOnAllButFirstPage. If this is set for this format, and processing the FIRST
// page, the size of next page, which may be different, is used in pagination calculationstop.
// If this format flag is not set, or not printing the first page of the section with this flag,
// this next page size is the same as current page size.
float yPageSizeNextPage = yPageSize;
mySize = YSize; // reset in case mySize changed for current page is compressed
// for a HLS that has an asterisk box with the rno separator IN the box, adjust the size by 2 lines to account for box.
if (MyItemInfo.IsStep && MyItemInfo.MyHLS.FormatStepData.StepLayoutData.STBoxindex != null && MyItemInfo.MyHLS.FormatStepData.StepLayoutData.STBoxindex >= 0 &&
(MyItemInfo.RNOs == null || MyItemInfo.RNOs.Count == 0))
mySize += (2 * SixLinesPerInch);
//if (firstStep == "No")
// ResetDocStyleAndValues(ref yTopMargin, ref yBottomMargin);
if (MyPageHelper.DidFirstPageDocStyle && MyItemInfo.ActiveSection != null && (MyItemInfo.ActiveSection.MyDocStyle.StructureStyle.Where & E_DocStyleUse.UseOnAllButFirstPage) > 0)// C2018-003 fixed use of getting the active section
yPageSizeNextPage = GetYPageSizeUseOnAllButFirstPage();
if (KeepStepsOnPage
&& !MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PaginateOnLowerStepLevel
&& YSize == ySizeIncludingFirst
&& YSize + yEndMsg > yWithinMargins)
{
// If the first step is the size of the entire step and the step has an end message then don't try to break the step
KeepStepsOnPage = false;
//_MyLog.WarnFormat("Kick Step to Next Page {0},{1}", MyItemInfo.ItemID, MyItemInfo.ShortPath);
}
if (yWithinMargins < SixLinesPerInch) KeepStepsOnPage = false; // if there is no room to print, don't keep steps on the page
// The following was added for IP2 background printing. There were situations where there was a HLS and its paragraph was
// put on next page (IP2 bck: E-3/References), and a paragraph was writing into the footer (FR-H.1 step 2.2.3.1. KBR 10/14/14)
if (KeepStepsOnPage
&& MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PaginateOnLowerStepLevel
&& YSize == ySizeIncludingFirst
&& ((ChildrenBelow.Count >= 1 && ChildrenBelow[0].MyItemInfo.IsParagraph && ChildrenBelow[0].ChildrenBelow.Count == 0)
|| ChildrenBelow.Count == 0))
{
KeepStepsOnPage = false;
}
// Keep figure (the only figure, i.e. count==1) with its parent.
if (ChildrenBelow.Count == 1 && ChildrenBelow[0].MyItemInfo.IsFigure) KeepStepsOnPage = false;
float sectionSpace = 0;
if (doSectionTitleContinued)
{
if (SectionShowTitles)
{
vlnParagraph paraSect = MyParent;
while (!paraSect.MyItemInfo.IsSection) paraSect = paraSect.MyParent;
if (paraSect.ContinueHeight > 24)
sectionSpace = paraSect.ContinueHeight;
else
sectionSpace = 2 * SixLinesPerInch;
// sectionSpace = 3 * SixLinesPerInch;// this should actuall use the physical size of the continue messsage.
// Fixing this caused problems with pagination ex Calvert Unit 2 IO-1l section 6.1.B step 2
//if (MyItemInfo.ActiveSection.DisplayText.Length < 40) sectionSpace = SixLinesPerInch;
yPageSizeNextPage -= sectionSpace;
yExtra -= sectionSpace;
//yExtra2 -= sectionSpace; // This was removed for Calvert STP O-73H-2 Section 6.3.O.4 and 6.3.R.3
}
}
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert && yPageSizeNextPage < yWithinMargins + 3*72 && MyItemInfo.MyPrevious == null)
KeepStepsOnPage = true;
float mySize7LPI = mySize; // +SixLinesPerInch;
if (_Match16BitPagination) mySize7LPI += SixLinesPerInch;
float tableSpaceAvailable = TableSpaceAvailable;// RHM20150525 - Table Scrunch
float ySizeBtmCtnMess1 = GetBottomContinueMessageSize(MyItemInfo.MyDocStyle);
float ySizeBtmEndMess1 = GetBottomEndMessageSize(MyItemInfo.MyDocStyle);
// B2017-154 Don't leave an orphan on the next page if the high level step and first sub-step will fit on the current page
if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.NoOrphans1 && KeepStepsOnPage && ChildrenBelow.Count == 2)// Handle Orphans when there are two sub-steps and only one will fit.
{
vlnParagraph orphan = ChildrenBelow[1];// Verify that the orphan has no children
if (orphan.ChildrenBelow.Count == 0 && orphan.ChildrenAbove.Count == 0 && orphan.ChildrenLeft.Count == 0 && orphan.ChildrenRight.Count == 0)
{
//_MyLog.WarnFormat("Orphan Found {0},{1}", MyItemInfo.ItemID, MyItemInfo.ShortPath);
KeepStepsOnPage = false;
}
}
if (KeepStepsOnPage && ySizeIncludingFirst > (yWithinMargins - ySizeBtmCtnMess1 - ySizeBtmEndMess1)) KeepStepsOnPage = false;
if (!KeepWithHeader && !KeepStepsOnPage && mySize - SixLinesPerInch + yEndMsg - tableSpaceAvailable <= yPageSizeNextPage) // if the entire step can fit on one page, do a page break
{
// Don't want extra line before step
//Console.WriteLine("'PageBreak',2,'Yes','HLS will fit on 1 Page',{0},{1},{2}, {3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
// A page break will occur before the step is put out. ShowPageBreak with first argument of -1 is NOT a page break.
// .ooo ooooo ooooooooo. ooooo
// .88' `888' `888 `Y88. `888'
// d88' 888 888 .d88' 888
// d888P"Ybo. 888 888ooo88P' 888
// Y88[ ]88 888 888 888
// `Y88 88P 888 o 888 888
// `88bod8' o888ooooood8 o888o o888o
ShowPageBreak(5, "HLS will fit on 1 Page at 6 LPI", "Yes", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
return 1;
}
// TODO - yEndMsg - compressed size?
// ySize7LPI includes a blank line after the step which we don't want to include in the page break test.
else if (!KeepStepsOnPage && MyItemInfo.ActiveFormat.MyStepSectionLayoutData.CompressSteps
//&& (mySize7LPI - SixLinesPerInch + yEndMsg - tableSpaceAvailable) < (yPageSizeNextPage * SixLinesPerInch / _SevenLinesPerInch))// RHM20150525 - Table Scrunch
// if this is the first step, then the step has to fit in the space that remains on the page
// otherwise it needs to fit on a blank page
// This was originally (10/12/2015) added for Farley Shared AOP 79 but was found to be unnecessary
// jsj 5-17-2016 B2015-090 - Turns out that Wolf Creek needs this logic to properly print
// the Purpose, Symptoms or Entry Conditions, and References and Commitments sections which are set to print continuous.
// Without this logic, the first step of section 2.0 print on top of the section text in OFN BB-007
&& (mySize7LPI - SixLinesPerInch + yEndMsg - tableSpaceAvailable) < ((MyItemInfo.MyPrevious == null ? yWithinMargins : yPageSizeNextPage) * SixLinesPerInch / _SevenLinesPerInch))// RHM20150525 - Table Scrunch
{
// ooooooooo ooooo ooooooooo. ooooo
// d"""""""8' `888' `888 `Y88. `888'
// .8' 888 888 .d88' 888
// .8' 888 888ooo88P' 888
// .8' 888 888 888
// .8' 888 o 888 888
// .8' o888ooooood8 o888o o888o
//Console.WriteLine("'PageBreak',3,'Yes','HLS will fit on 1 Page at 7 LPI',{0},{1},{2}, {3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
ShowPageBreak(7, "HLS will fit on 1 Page at 7 LPI", "Yes", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
//Console.WriteLine("'7LPI',{0},{1}", MyItemInfo.DBSequence, YSize);
return 3; // High Level Step can fit at SevenLinesPerInch
}
else // The entire step cannot fit on a blank page or KeepStepsOnPage is true.
{
// if there is more than half a page left, then start to print on the current page
float myFirstPieceSize = GetFirstPieceSize(); //Case 0
if (_Match16BitPagination) myFirstPieceSize += 2 * SixLinesPerInch;
// TODO: Put this line back to case 0, i.e. previous line. This fixes a 16-bit vs 32-bit pagination diff in EO30 Step 20.
//float myFirstPieceSize = GetFirstPieceSize() + 2 * SixLinesPerInch; //Case 10 - this is to match 16bit
//is the amount of space left (yWithinMargins) is greater than 1/2 of the current page (yPageSize / 2):
// VCS EOP-4.3 Step 15
// ***** Adjust yWithinMargins for the bottom continue message
//DocStyle docstyle = MyItemInfo.MyDocStyle;
//string myBottomMsg = docstyle.Continue.Bottom.Message;
//float myBottomMsgSpace = ((myBottomMsg ?? "") != "") ? 2 * SixLinesPerInch : 0;
//switch (docstyle.Continue.Bottom.Location)
//{
// case E_ContBottomLoc.BottomOfPage: // place continue message at bottom of page
// // The following format flag was added for FNP, without the flag (which stops the reset of BottomMsgSpace)
// // a number of FNP procedures had overwritten steps/bottom continue message. An example can be
// // found in FNP = SAMGS;FNP-1-SACRG-2, step 1.
// if (!docstyle.Continue.Bottom.NoOverrideSpace)
// myBottomMsgSpace = 0;
// break;
//}
//float yWithinMarginsCM = yWithinMargins - myBottomMsgSpace;
//// **** Adjust yWithinMargins for the bottom continue message
// B2018-080 Don't break if HLS and High Level RNO each have one line of text and there are substeps (keep single line HSL and High Level RNO with their substeps) AEP AOP Unit 1 016-004 steps 36 & 74
// B2018-081 The previous fix caused a different issue
if ((KeepWithHeader || (!ManualPageBreak && ((MyItemInfo.ActiveFormat.MyStepSectionLayoutData.SpecialPageBreakFlag && yWithinMargins > yPageSize / 2 &&
myFirstPieceSize < yWithinMargins) || KeepStepsOnPage))))
{
//Console.WriteLine("'PageBreak',4,'No','HLS will have to split anyway',{0},{1},{2}, {3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
// yPageSize is space on next page. This may be different if the format flag 'UseOnAllButFirst' is
// set.
// yWithinMargins is space available on current page.
// if the HLS is part of a Smart Template (i.e. WCNCKL table), don't add in an extra line because
// that makes pagination work incorrectly because the Smart Template has a 'table' line after the
// text.
float ySpaceOnFirstPage = yWithinMargins + (MyItemInfo.FormatStepData.UseSmartTemplate ? 0 : SixLinesPerInch);
if (firstStep == "Yes")
//{
ySpaceOnFirstPage = yWithinMargins; // Accounts for Section Title Line
//ShowPageBreak(8, CheckForCompression("First HLS has to split on current page"), firstStep, YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
//}
//else
// ShowPageBreak(6, CheckForCompression("HLS will have to split on current page"), "Special", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
//BuildPageBreakList(yWithinMargins + SixLinesPerInch, yPageSizeNextPage + yExtra2, KeepStepsOnPage); // Case 5 - Determine items where page break(s) occur
// B2020-027: adjust for lines that may print on first page of section only, added MyPageHelper.PrintedSectionPage
// B2020-108: The bug itself was related to keeping a table with its parent. However compression for some pages was
// not working because onnewpage was always false in the next BuildPageBreakList call. onnewpage is used to determine compression
// (has to be on a new page to compress page). Use calculated value rather than always false in this case.
bool onnewpage = MyItemInfo.MyPrevious == null && (MyItemInfo.MyActiveSection as SectionInfo) != null
&& (MyItemInfo.MyActiveSection as SectionInfo).IsSeparatePagination();
BuildPageBreakList(ySpaceOnFirstPage, yPageSize + yExtra2 + MyPageHelper.PrintedSectionPage, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, onnewpage); // Case 5 - Determine items where page break(s) occur
// ooooo ooooo ooooo .oooooo..o .oooooo..o oooo o8o . .oooooo. .
// `888' `888' `888' d8P' `Y8 d8P' `Y8 `888 `"' .o8 d8P' `Y8b .o8
// 888 888 888 Y88bo. Y88bo. oo.ooooo. 888 oooo .o888oo 888 oooo oooo oooo d8b oooo d8b .ooooo. ooo. .oo. .o888oo
// 888ooooo888 888 `"Y8888o. `"Y8888o. 888' `88b 888 `888 888 888 `888 `888 `888""8P `888""8P d88' `88b `888P"Y88b 888
// 888 888 888 `"Y88b `"Y88b 888 888 888 888 888 888 888 888 888 888 888ooo888 888 888 888
// 888 888 888 o oo .d8P oo .d8P 888 888 888 888 888 . `88b ooo 888 888 888 888 888 .o 888 888 888 .
// o888o o888o o888ooooood8 8""88888P' 8""88888P' 888bod8P' o888o o888o "888" `Y8bood8P' `V88V"V8P' d888b d888b `Y8bod8P' o888o o888o "888"
// 888
// o888o
if (firstStep == "Yes")
{
//ySpaceOnFirstPage = yWithinMargins; // Accounts for Section Title Line
ShowPageBreak(8, CheckForFirstCompression("First HLS has to split on current page"), firstStep, YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
}
else
ShowPageBreak(6, CheckForFirstCompression("HLS will have to split on current page"), "Special", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
// B2018-081 - Fix pagination when a Step and it's substeps are so complicated that the high level step is separated from its high level RNO
if(this.MyItemInfo.IsHigh && MyPageHelper.ParaBreaks.Count > 0 && MyPageHelper.ParaBreaks[0].MyItemInfo.IsHigh)
{
MyPageHelper.ParaBreaks.Clear();
BuildPageBreakList(yPageSize + yExtra, yPageSizeNextPage + yExtra2, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, true); // Case 1 :Works for ES05 Step 15 SubStep 7
ShowPageBreak(6, CheckForFirstCompression("HLS will have to split on next page"), "Special", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
return 1;
}
// B2019-173: Pagination problem fix for VCS. Originally similar code was in FindPageBreak, but having code at the lower level caused the problem in VCS.
else if (MyPageHelper.ParaBreaks.Count > 0 && this.MyItemInfo.IsHigh
&& yWithinMargins > 0 && YSize > yPageSizeNextPage && ChildrenRight != null && ChildrenRight.Count > 0
&& ChildrenRight[0].YSize <= yPageSizeNextPage && ChildrenRight[0].YSize > yWithinMargins)
{
MyPageHelper.ParaBreaks.Clear();
BuildPageBreakList(yPageSize + yExtra, yPageSizeNextPage + yExtra2, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, true); // Case 1 :Works for ES05 Step 15 SubStep 7
ShowPageBreak(6, CheckForFirstCompression("HLS with RNO will have to split on next page"), "Special", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
return 1;
}
return 0; // Stay on this page
}
// Less than half a page left, start printing on a new page.
//Console.WriteLine("'PageBreak',5,'Yes','HLS will have to split',{0},{1},{2}, {3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
// Determine items where page break(s) occur
//BuildPageBreakList(yPageSize, yPageSize - 2 * SixLinesPerInch); // Case Base
//BuildPageBreakList(yPageSize, yPageSize); // Case 1 :Works for ES05 Step 15 SubStep 7
// Pagination Fix Break1LineShort2
//BuildPageBreakList(yPageSize + yExtra, yPageSize); // Case 1 :Works for ES05 Step 15 SubStep 7
// Pagination Fix Break1LineShort4
BuildPageBreakList(yPageSize + yExtra, yPageSizeNextPage + yExtra2, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, true); // Case 1 :Works for ES05 Step 15 SubStep 7
// ooooo ooooo ooooo .oooooo..o .oooooo..o oooo o8o . ooooo ooo
// `888' `888' `888' d8P' `Y8 d8P' `Y8 `888 `"' .o8 `888b. `8'
// 888 888 888 Y88bo. Y88bo. oo.ooooo. 888 oooo .o888oo 8 `88b. 8 .ooooo. oooo oooo ooo
// 888ooooo888 888 `"Y8888o. `"Y8888o. 888' `88b 888 `888 888 8 `88b. 8 d88' `88b `88. `88. .8'
// 888 888 888 `"Y88b `"Y88b 888 888 888 888 888 8 `88b.8 888ooo888 `88..]88..8'
// 888 888 888 o oo .d8P oo .d8P 888 888 888 888 888 . 8 `888 888 .o `888'`888'
// o888o o888o o888ooooood8 8""88888P' 8""88888P' 888bod8P' o888o o888o "888" o8o `8 `Y8bod8P' `8' `8'
// 888
// o888o
if (firstStep == "Yes")
ShowPageBreak(9, CheckForFirstCompression("First HLS will have to split on new page"), "Yes", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
else
ShowPageBreak(3, CheckForFirstCompression("HLS will have to split on new page"), "Yes", YSize, yPageSizeNextPage, yWithinMargins, ManualPageBreak);
return 1; // Paginate on High Level Steps
}
//if (yWithinMargins > yPageSize / 2)
//{
// Console.WriteLine("'PageBreak',4,'No','Not Half way down the page',{0},{1},{2}, {3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
// return 0; // More than half way down the page
//}
//if (ChildrenBelow.Count > 0 && ChildrenBelow[0].YSize < yWithinMargins)
// return 0;
//Console.WriteLine("'PageBreak',5,'Yes','At least half the page is filled',{0},{1},{2},{3}, {4},'{5}'", MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize), MyItemInfo.ShortPath);
//return 2;
throw new Exception("PageBreak Logic Missing, vlnParagraph.cs");
}
// B2018-065 Calvert's continue message was not including the substep number in AOP-1A Attachment 1, added AERandRNO check
private bool AERandRNO(ItemInfo itemInfo1, ItemInfo itemInfo2)
{
bool hasAER = false;
bool hasRNO = false;
if (itemInfo1.IsInRNO) hasRNO |= true;
else
hasAER |=true;
if (itemInfo2.IsInRNO) hasRNO |= true;
else
hasAER |= true;
return hasAER && hasRNO;
}
// B2018-058 the the end message height accounting for multi-line end messages
private float GetEndMessageHeight(DocStyle docstyle)
{
float EndMsgHeight = 0;
string endmsg = MyItemInfo.MyDocStyle.End.Message ?? "";
if (endmsg != "")
{
string[] splitOn = { "\\par" }; // B2018-058 account for RTF newlines ( used for V.C. Summer End messages)
EndMsgHeight = (endmsg.Split(splitOn,StringSplitOptions.RemoveEmptyEntries).Length + 1) * SixLinesPerInch;
}
return EndMsgHeight;
}
private float GetBottomEndMessageSize(DocStyle docstyle)
{
float myBottomMsgSpace = 0;
if (MyItemInfo.IsHigh && MyItemInfo.NextItem == null && MyItemInfo.MyDocStyle.End.Flag < 0) // Adjust this many lines down the page.
{
docstyle = MyItemInfo.MyDocStyle;
string myBottomMsg = docstyle.End.Message;
myBottomMsgSpace = ((myBottomMsg ?? "") != "") ? 2 * SixLinesPerInch : 0;
if (myBottomMsg != null && docstyle.End.Flag < 0) myBottomMsgSpace += (-(float)docstyle.End.Flag * SixLinesPerInch);
}
return myBottomMsgSpace;
}
private string CheckForFirstCompression(string reason)
{
if (MyPageHelper.ParaBreaks.Count > 0 && MyPageHelper.ParaBreaks[0].CompressFirstPartOfStep)
return reason + " - 7 LPI";
return reason;
}
private string CheckForCompression(string reason)
{
if (CompressPartOfStep)
return reason + " - 7 LPI";
return reason;
}
private string AddReason(string prefix)
{
string retval = prefix;
if (PageBreakReason != null)
retval += " - " + PageBreakReason;
return retval;
}
private bool SectionShowTitles
{
get
{
vlnParagraph parent = MyParent;
while (!parent.MyItemInfo.IsSection)
parent = parent.MyParent;
return parent.ShowSectionTitles;
}
}
private bool SpecialCaseForRobinson()
{
if (MyItemInfo.ActiveFormat.Name.StartsWith("CPL") &&
MyItemInfo.MyPrevious == null &&
MyItemInfo.NextItem == null &&
MyItemInfo.Tables != null &&
MyItemInfo.Cautions == null &&
MyItemInfo.Notes == null &&
MyItemInfo.Steps == null) return true;
return false;
}
private float GetYPageSizeUseOnAllButFirstPage()
{
float _PointsPerPage = PDFPageSize.PaperSizePoints(MyItemInfo.ActiveFormat.PlantFormat.FormatData.PDFPageSize.PaperSize); // C2020-002 paper size is now set in the format files
int indx = (int)MyItemInfo.MyDocStyle.IndexOtherThanFirstPage;
foreach (DocStyle ds in MyItemInfo.ActiveFormat.PlantFormat.DocStyles.DocStyleList)
{
if (ds.Index == indx)
{
float yTopMargin = _PointsPerPage - (float)ds.Layout.TopMargin;
float yBottomMargin = Math.Max(0, yTopMargin - (float)ds.Layout.PageLength);
return yTopMargin - yBottomMargin;
}
}
return 0;
}
private void ForcePagination(PdfContentByte cb, ref float yPageStart, float yTopMargin, float yBottomMargin, ref float yLocation, ref float retval)
{
MyPromsPrinter.NewPage();
DebugText.WriteLine("*****PaginateError");
yPageStart = yTopMargin + YVeryTop;
yLocation = yPageStart - YOffset;
//MyItemInfo.ItemID, YSize, yPageSize, yLocation
//_MyLog.ErrorFormat("<<< ERROR >>> Forced Pagination - ItemID = {0}\r\nLocation = '{1}'", MyItemInfo.ItemID, MyItemInfo.ShortPath);
_MyLog.ErrorFormat("<<< ERROR >>> Forced Pagination\r\n==>'Forced Pagination',{0},'{1}','{2}'"
, MyItemInfo.ItemID, MyItemInfo.MyDocVersion.MyFolder.Name, MyItemInfo.ShortPath);
if(DebugPagination.IsOpen) DebugPagination.WriteLine("=====>,'Yes','Forced Pagination',{0},{1},,{3},'{4}'", MyItemInfo.ItemID, YSize, 0, yLocation, MyItemInfo.ShortPath);
if (BaselineMetaFile.IsOpen) BaselineMetaFile.WriteLine("!! =====>,'Yes','Forced Pagination',{0},{1},,{3},'{4}'", MyItemInfo.ItemID, YSize, 0, yLocation, MyItemInfo.ShortPath); //C2018-015 add debug pagination to meta file
if (MyPromsPrinter.SupInfoPrintType == E_SupInfoPrintType.Merge && MyPageHelper.CreatingSupInfoPage)
MyPromsPrinter.SupInfoPdfPageCount++; // this adjusts the page count offset when Forced Pagination occures in a SupInfo page
retval = Rtf2Pdf.TextAt(cb, IParagraph, XOffset, yLocation, Width, 100, DebugInfo, yBottomMargin, MyItemInfo.ItemID); // C2018-004 ItemID for create meta file for baseline compares
}
private void ShowPageBreak(int instance, string message, string breakOrNot, float YSize, float yPageSize, float yWithinMargins, bool manualPageBreak)
{
if (breakOrNot != "No")
{
bool hasBox = MyItemInfo.IsStep && MyItemInfo.MyHLS.FormatStepData.StepLayoutData.STBoxindex != null && MyItemInfo.MyHLS.FormatStepData.StepLayoutData.STBoxindex >= 0;
bool rnoSepIn = (MyItemInfo.RNOs==null ||MyItemInfo.RNOs.Count==0);
// DebugPagination.WriteLine("{0}", MyItemInfo.DBSequence); //,instance);
if (DebugPagination.IsOpen) DebugPagination.WriteLine("{0:D6},'{1}',{2},'{3}','{4}',{5},{6},{7},{8},{9},{10},{11}",
MyPageHelper.MyPdfContentByte.PdfWriter.CurrentPageNumber - (breakOrNot == "Yes" ? 0 : 1),
MyItemInfo.ShortPath, instance,
(manualPageBreak ? "Manual " : "") + message, breakOrNot,
MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize),
hasBox, rnoSepIn
);
//C2018-015 add debug pagination to meta file
if (BaselineMetaFile.IsOpen) BaselineMetaFile.WriteLine("!! {0:D6},'{1}',{2},'{3}','{4}',{5},{6},{7},{8},{9},{10},{11}",
MyPageHelper.MyPdfContentByte.PdfWriter.CurrentPageNumber - (breakOrNot == "Yes" ? 0 : 1),
MyItemInfo.ShortPath, instance,
(manualPageBreak ? "Manual " : "") + message, breakOrNot,
MyItemInfo.ItemID, YSize, yPageSize, yWithinMargins, (int)(100 * yWithinMargins / yPageSize),
hasBox, rnoSepIn
);
}
// Console.WriteLine("{0},{1}", MyItemInfo.DBSequence, IsFirstSubStep(MyItemInfo)); //,instance);
}
private bool ParentHasCalvertMacro
{
get
{
if (HasCalvertMacro) return true;
if (MyParent != null) return MyParent.ParentHasCalvertMacro;
return false;
}
}
private List<vlnParagraph> _AlternateBreaks = null;
public List<vlnParagraph> AlternateBreaks
{
get
{
if (_AlternateBreaks == null)
_AlternateBreaks = new List<vlnParagraph>();
return _AlternateBreaks;
}
}
private void AddAlternateBreak(vlnParagraph vp)
{
AlternateBreaks.Add(vp);
}
private bool CheckAlternates(vlnParagraph vpBrk)
{
if (_AlternateBreaks == null) return false;
foreach(vlnParagraph vp in AlternateBreaks)
if (vp.MyItemInfo.ItemID == vpBrk.MyItemInfo.ItemID)
{
// _MyLog.WarnFormat("alternate used '{0}'-'{1}'",vpBrk.MyItemInfo.ShortPath,vp.MyItemInfo.ShortPath);
return true;
}
return false;
}
private vlnParagraph FirstCRParagraph(vlnParagraph pg)
{
if (pg.HasCalvertMacro) return null;
while ( !pg.MyParent.HasCalvertMacro)
pg = pg.MyParent;
if(pg.MyItemInfo.MyPrevious == null)
return pg;
return pg.MyParent.ChildrenBelow[0];
}
private void BuildPageBreakList(float ySpaceOnCurPage, float yPageSize, bool KeepStepsOnPage, float yEndMsg, bool doSectionTitleContinued, bool onNewPage)
{
float topContinueHeight = 2 * SixLinesPerInch;
int profileDepth = ProfileTimer.Push(">>>> BuildPageBreakList");
// if this paragraph is flagged to pagebreakonstep (i.e. these are used by background documents
// to get each hls/caution/note to be on its own page), then any of the children above should
// also have the flag set and be added to the pagebreakonsteplist so that a break occurs.
List<vlnParagraph> PageBreakOnStepList = new List<vlnParagraph>();
if (PageBreakOnStep)
{
foreach (vlnParagraph chldAbove in _ChildrenAbove)
{
if (TopMostChild != chldAbove)
{
chldAbove.PageBreakOnStep = true;
PageBreakOnStepList.Add(chldAbove);
}
}
PageBreakOnStepList.Add(this);
}
ParagraphLocations myLocations = new ParagraphLocations();
BuildLocationList(YTopMost, myLocations);
StepLevelList myList = myLocations.BuildStepLevelList(KeepStepsOnPage);
SortedList<float, vlnParagraph> myPreferredBreaks = GetMyPreferredBreaks(myList);
// Find Break Locations in the list based upon StepLevel and yLocation
float yTop = 0;
float yLowerLimit = (yPageSize - 2 * SixLinesPerInch) / 2;
float yStart = Math.Max(0, (yPageSize - 2 * SixLinesPerInch) - ySpaceOnCurPage);
//Console.WriteLine("'yStart',{0},{1}", MyItemInfo.DBSequence, yStart);
// The following three lines make page breaking match 16-bit:
if (_Match16BitPagination)
{
yLowerLimit = yStart - SixLinesPerInch + ySpaceOnCurPage / 2;
if ((yStart + MyItemInfo.MyDocStyle.Layout.TopMargin + 2 * SixLinesPerInch) > ((MyItemInfo.MyDocStyle.Layout.TopMargin + yPageSize - 2 * SixLinesPerInch) / 2))
yLowerLimit = yStart + 2 * SixLinesPerInch;
}
// Make sure that the FirstPiece (Caution Note HLS and First Substeps) fit
float myFirstPieceSize = GetFirstPieceSize(); //Case 0
// the following logic was added to fix Pagination for VCS BDMG1 Step 4
if (ChildrenRight.Count > 0 && ChildrenRight[0].YOffset == YOffset)
{
float myFirstPieceRNOSize = 0;
myFirstPieceRNOSize = ChildrenRight[0].GetFirstPieceSize();
if(myFirstPieceRNOSize < ySpaceOnCurPage)
if (ChildrenBelow.Count > 0)
{
float myFirstPieceAERSize = ChildrenBelow[0].GetFirstPieceSize() + ChildrenBelow[0].YOffset - YOffset;
if (myFirstPieceAERSize < myFirstPieceRNOSize)
myFirstPieceSize = myFirstPieceAERSize;
}
}
if (myFirstPieceSize < ySpaceOnCurPage) yLowerLimit = Math.Max(myFirstPieceSize + yStart, yLowerLimit);
//while ((YSize - yTop) >= ySpaceOnCurPage)
// Pagination Fix Break1LineShort3b
DocStyle docstyle = MyItemInfo.MyDocStyle;
float myBottomMsgSpace = GetBottomContinueMessageSize(docstyle);
switch (docstyle.Continue.Bottom.Location)
{
case E_ContBottomLoc.BottomOfPage: // place continue message at bottom of page
// The following format flag was added for FNP, without the flag (which stops the reset of BottomMsgSpace)
// a number of FNP procedures had overwritten steps/bottom continue message. An example can be
// found in FNP = SAMGS;FNP-1-SACRG-2, step 1.
if (!docstyle.Continue.Bottom.NoOverrideSpace)
myBottomMsgSpace = 0;
break;
}
// also account for phonelist for locating bottom continue message:
// B2018-079 - we don't need the phone list length in this case only the length of the end message plus a blank line because the phone list is printed below the footer but the end message is shifted up.
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.PrintPhoneList && MyPageHelper.PhoneListHeight != 0)
myBottomMsgSpace += vlnPrintObject.SixLinesPerInch; //(MyPageHelper.PhoneListHeight - vlnPrintObject.SixLinesPerInch);
string myTopMsg = docstyle.Continue.Top.Message;
float myTopMsgSpace = ((myTopMsg ?? "") != "") ? 2 * SixLinesPerInch : 0;
// For B2016-157 & B2015-211: myTopMsgSpace is 1 line, not 2. Note that this may be a more generic solution, but
// it was found during print testing for BGE and flag is used to minimize impact on other formats
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertPagination) myTopMsgSpace = ((myTopMsg ?? "") != "") ? SixLinesPerInch : 0;
if (myTopMsgSpace > 0 && doSectionTitleContinued)
{
vlnParagraph parSection = this.MyParent;
while (!parSection.MyItemInfo.IsSection) parSection = parSection.MyParent;
topContinueHeight = parSection.ContinueHeight;
if (topContinueHeight > myTopMsgSpace)
{
myTopMsgSpace = topContinueHeight;
}
}
// while the amount to print is larger than one page, i.e. ((YSize - yTop) > ySpaceOnCurPage))
// OR there are page breaks for HLS/cautions/notes remaining, typically for backgrounds (PageBreakOnStepList.Count > 0)
vlnParagraph paraBreak = null;
float accountForCalvertAlarmConditionResponseFooter = 0;
// The following code determines space required by the Checklist header (Wolf Creek) if a break occurs
// Their 2 HLS that define the checklists have 'UseSmartTemplate'.
float accountForSmartTemplateHeader = 0;
//if (MyItemInfo.InList(878)) Console.WriteLine("Here");
if (MyItemInfo.FormatStepData.UseSmartTemplate)
{
if (((MyItemInfo.MyDocStyle.End.Message ?? "") == "") || MyItemInfo.MyHLS.NextItem != null)
ySpaceOnCurPage += SixLinesPerInch;
accountForSmartTemplateHeader = Height - (2 * SixLinesPerInch);
}
// This was added so that if a page break was immediately necessary the code would use the current step.
// However, a better solution was found and put in Paginate()
//if (YSize == Height + SixLinesPerInch && YSize + yEndMsg >= ySpaceOnCurPage)
//{
// _MyLog.WarnFormat("Would have been unable to break {0},{1}",MyItemInfo.ItemID, MyItemInfo.ShortPath);
// MyPageHelper.ParaBreaks.Add(this);
// return;
//}
// ooooo ooo . oooooooooo. oooo
// `888b. `8' .o8 `888' `Y8b `888
// 8 `88b. 8 .ooooo. oooo ooo .o888oo 888 888 oooo d8b .ooooo. .oooo. 888 oooo
// 8 `88b. 8 d88' `88b `88b..8P' 888 888oooo888' `888""8P d88' `88b `P )88b 888 .8P'
// 8 `88b.8 888ooo888 Y888' 888 888 `88b 888 888ooo888 .oP"888 888888.
// 8 `888 888 .o .o8"'88b 888 . 888 .88P 888 888 .o d8( 888 888 `88b.
// o8o `8 `Y8bod8P' o88' 888o "888" o888bood8P' d888b `Y8bod8P' `Y888""8o o888o o888o
// For B2016-157 & B2015-211. Note that this may be a more generic solution, but
// it was found during print testing for BGE and flag is used to minimize impact on other formats
float yAccountForBottomMsg = (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertPagination) ? myBottomMsgSpace : 0;
while (((YSize - yTop) > (ySpaceOnCurPage - (accountForCalvertAlarmConditionResponseFooter + yEndMsg))) || PageBreakOnStepList.Count > 0)
{
float ySpaceOnCurPageSave = ySpaceOnCurPage;
if (((YSize - yTop) <= (ySpaceOnCurPage - accountForCalvertAlarmConditionResponseFooter)) || PageBreakOnStepList.Count > 0)
ySpaceOnCurPage -= yEndMsg;
ySpaceOnCurPage -= myBottomMsgSpace;
vlnParagraph lastBreak = paraBreak;
// PageBreakOnStepList contains steps where a page break needs to occur based on format, for example backgrounds require cautions/notes/HLS
// to have page breaks. As each of these are processed (after this code) the topmost item in PageBreakOnStepList is removed.
// The following checks if the entire step will fit for these types of steps and if so return the next break, i.e. [0], from the PageBreakOnStepList.
// The if was changed to fix B2017-161.
bool DidPreferredPageBreak = false;
if (PageBreakOnStepList.Count > 0 && (PageBreakOnStepList[0].YTop - (lastBreak == null ? ((TopMostChild != null) ? TopMostChild.YTop : 0) : lastBreak.YTop) <= ySpaceOnCurPage))
paraBreak = PageBreakOnStepList[0];
else
{
paraBreak = FindPageBreak(yStart, ySpaceOnCurPage - accountForCalvertAlarmConditionResponseFooter - yAccountForBottomMsg, yLowerLimit,
myList, lastBreak, yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace,
myBottomMsgSpace, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[40].ContinueOnly, yTop);
// B2020-032 put in for Barakah EOPs 1T4-OP-EOP-XX-0100 Attachement 32 step 1.2.2a where a table was printing on a page by itself.
// The following logic will walk up to each parent level to see try and get as many parent step levels on the same page
// as the Table.
// B2020-035 added a null reference check to fix printing crash
// B2020-101: Proms crashes when trying to keep table with parent when table is very large. Add format flag for Barakah,
// code was added for B2020-032 and only want it for Barakah
if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.PageBreakParentWithTable && paraBreak != null && paraBreak.MyItemInfo.IsTable && paraBreak.MyParent.YSize < (yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace))
{
vlnParagraph tparent = paraBreak.MyParent;
while (!tparent.MyItemInfo.IsHigh && tparent.MyParent.YSize < (yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace))
tparent = tparent.MyParent;
paraBreak = tparent;
}
// B2017-109: for supplemental information, if there is a preferred page break, account for it.
// B2018-033 VCS SAG-6 Steps 3 and 9 and SACRG1 Step 13
// Break after table if it's the only item left and there is enough space
if (paraBreak != null && paraBreak.MyGrid != null && ItemsLeft(myList) == 1 &&
((YSize - yTop) <= (paraBreak.MyGrid.SpaceAvailable + ySpaceOnCurPage - (accountForCalvertAlarmConditionResponseFooter + yEndMsg))))
break;
if (myPreferredBreaks != null && myPreferredBreaks.Count > 0 && myPreferredBreaks.Keys[0] < paraBreak.YOffset)
{
// B2017-122: don't use preferred break if the last break was before this break
vlnParagraph prefBreak = myPreferredBreaks[myPreferredBreaks.Keys[0]];
if (lastBreak == null || lastBreak.MyItemInfo.ShortPath.CompareTo(prefBreak.MyItemInfo.ShortPath) == -1)
paraBreak = prefBreak;
myPreferredBreaks.RemoveAt(0);
DidPreferredPageBreak = true;
}
}
// B2017-252 Pagination Fix - Break at title rather than title content
// B2017-261 - Make sure Parabreak is not null
if (paraBreak != null && paraBreak.MyItemInfo.ShortPath.EndsWith(".S1.") && (paraBreak.MyItemInfo.ActiveParent as ItemInfo).IsTitle)
paraBreak = paraBreak.MyParent;
yAccountForBottomMsg = 0;
// Do Not Remove: The following is used for debug - useful place to debug
//if (paraBreak.MyItemInfo.InList(207, 211, 214, 219, 221, 216, 197)) Console.WriteLine("BUILD2: Break at {0}", paraBreak.MyItemInfo.ShortPath);//Comment Out before release
//if (lastBreak != null && lastBreak.MyItemInfo.InList(80091, 1985))
// Console.WriteLine("After 80091 {0}",paraBreak.ToString());
//if (paraBreak.MyItemInfo.InList(981,996)) Console.WriteLine("Here");
if (paraBreak == null)
{
if (DebugPagination.IsOpen) DebugPagination.WriteLine("<<< ERROR >>> Cannot find a place to break ==>,{0},'{1}','{2}',{3},{4}"
, MyItemInfo.ItemID, MyItemInfo.MyDocVersion.MyFolder.Name, MyItemInfo.ShortPath, YSize - yTop, ySpaceOnCurPageSave);
_MyLog.ErrorFormat("<<< ERROR >>> Cannot find a place to break\r\n==>'Cannot Find Place to Break',{0},'{1}','{2}'"
, MyItemInfo.ItemID, MyItemInfo.MyDocVersion.MyFolder.Name, MyItemInfo.ShortPath);
//C2018-015 add debug pagination to meta file
if (BaselineMetaFile.IsOpen) BaselineMetaFile.WriteLine("!! <<< ERROR >>> Cannot find a place to break ==>,{0},'{1}','{2}',{3},{4}"
, MyItemInfo.ItemID, MyItemInfo.MyDocVersion.MyFolder.Name, MyItemInfo.ShortPath, YSize - yTop, ySpaceOnCurPageSave);
_MyLog.ErrorFormat("<<< ERROR >>> Cannot find a place to break\r\n==>'Cannot Find Place to Break',{0},'{1}','{2}'"
, MyItemInfo.ItemID, MyItemInfo.MyDocVersion.MyFolder.Name, MyItemInfo.ShortPath);
break;
}
//if (paraBreak.MyItemInfo.InList(54615, 54620) || MyItemInfo.InList(54573))
//{
// Console.WriteLine("{0}\t{1}", MyItemInfo.ItemID, paraBreak);
// Console.WriteLine("Here");
//}
// C2018-003 fixed use of getting the active section
if (paraBreak.MyItemInfo.IsStep && paraBreak.MyItemInfo.ActiveSection != null && ((paraBreak.MyItemInfo.ActiveSection.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListSpBckgrnd) == E_DocStructStyle.DSS_PageListSpBckgrnd) &&
paraBreak.MyItemInfo.FormatStepData != null && paraBreak.MyItemInfo.MyParent.MyPrevious != null && paraBreak.MyItemInfo.MyParent.IsStep && paraBreak.MyItemInfo.MyParent.MyPrevious.FormatStepData.Type == "TitleWithTextBelow")
{
if (lastBreak != null && lastBreak != paraBreak.MyParent) paraBreak = paraBreak.MyParent;
}
float yLoc = ySpaceOnCurPage - (paraBreak.YOffset - (YTopMost + yTop));
if (yLoc <= 0) // Check where it would break if the space on the page was one line shorter
{
vlnParagraph paraBreak2 = FindPageBreak(yStart, ySpaceOnCurPage - (SixLinesPerInch + accountForCalvertAlarmConditionResponseFooter), yLowerLimit,
myList, lastBreak, yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace,
myBottomMsgSpace, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[40].ContinueOnly, yTop);
if (paraBreak2 != null && paraBreak != paraBreak2)
{
yLoc = ySpaceOnCurPage - (paraBreak2.YOffset - (YTopMost + yTop - paraBreak2.Height));
if (paraBreak.YOffset == paraBreak2.YOffset + paraBreak2.Height)
{
//_MyLog.WarnFormat("Fix Break when no blank line {0},{1},{2}", paraBreak2.MyItemInfo.ShortPath, paraBreak2.MyItemInfo.ItemID,yLoc);
paraBreak = paraBreak2;
}
}
}
// If the page break is close to the lower limit and the paraBreak is bigger than the upper limit
// and increasing the lower limit by two lines
// Causes a significant increase (at least 2 inches) in the amount of text placed on the page and
// the StepLevel only increases by 1 then use the paraBreak3
else if (yLoc <= yLowerLimit + 24)
{
if (paraBreak.YSize > (yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace))
{
vlnParagraph paraBreak3 = FindPageBreak(yStart, ySpaceOnCurPage - accountForCalvertAlarmConditionResponseFooter, yLowerLimit + 144,
myList, lastBreak, yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace,
myBottomMsgSpace, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[40].ContinueOnly, yTop);
if (paraBreak3 != null)
{
float yLoc3 = ySpaceOnCurPage - (paraBreak3.YOffset - (YTopMost + yTop));
if (paraBreak.MyItemInfo.StepLevel + 1 >= paraBreak3.MyItemInfo.StepLevel && (yLoc - yLoc3) > 144)//144 is 2 inches
paraBreak = paraBreak3;
}
}
}
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.WolfcreekCKLFormat)
{
if (!paraBreak.MyItemInfo.IsHigh // not a high level step
&& paraBreak.MyParent.MyItemInfo.IsHigh // my parent is a hls
&& paraBreak.MyItemInfo.MyPrevious == null // first substep
&& paraBreak.MyParent.MyItemInfo.FormatStepData.UseSmartTemplate) // my parent has the checklist header
{
if (DebugPagination.IsOpen) DebugPagination.WriteLine("Breaking at parent of {0}", paraBreak.MyItemInfo.DisplayText);
if (BaselineMetaFile.IsOpen) BaselineMetaFile.WriteLine("!! Breaking at parent of {0}", paraBreak.MyItemInfo.DisplayText); //C2018-015 add debug pagination to meta file
paraBreak = paraBreak.MyParent;
}
}
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm) // only do the following for Calvert Alarms
{
//if (lastBreak != null && lastBreak.MyItemInfo.InList(42656,42923)) Console.WriteLine("here");
// Or Step whose parent fits on a page should break at the parent step
//if (MyItemInfo.InList(119826)) Console.WriteLine("here");
//if (paraBreak.MyItemInfo.InList(40339))
float ySpaceOnNextPage = yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace;
if (paraBreak.MyItemInfo.IsOr && paraBreak.MyParent.YSize < ySpaceOnNextPage)
{
vlnParagraph paraBreakParent = paraBreak.MyParent;
while (paraBreakParent.MyParent.YSize < ySpaceOnNextPage)
paraBreakParent = paraBreakParent.MyParent;
//_MyLog.WarnFormat("Or Step PageBreak '{0}','{1}','{2}'",paraBreak.MyItemInfo.ShortPath ,paraBreak.MyItemInfo.MyProcedure.DisplayNumber, paraBreak.MyItemInfo.MyHLS.DisplayText);
paraBreak = paraBreakParent;
}
if (!paraBreak.ParentHasCalvertMacro)
{
foreach (int lev in myList.Keys)
{
foreach (float y in myList[lev].Keys)
{
vlnParagraph p = myList[lev][y];
if (p.YOffset == paraBreak.YOffset && p.MyItemInfo.ItemID != paraBreak.MyItemInfo.ItemID)
paraBreak.AddAlternateBreak(p);
}
}
}
// if first condition/response and the parent has caution, notes or warnings then move the break to the caution, note or warning
if (!paraBreak.MyItemInfo.IsCautionPart && !paraBreak.MyItemInfo.IsNotePart && paraBreak.ParentHasCalvertMacro && paraBreak.MyParent.HasCalvertMacro && paraBreak.MyItemInfo.MyPrevious == null)
{
if (paraBreak.MyParent.ChildrenAbove.Count > 0)
paraBreak = paraBreak.MyParent.ChildrenAbove[0];
else
paraBreak = paraBreak.MyParent;
}
// If the lastbreak was part of a condition response and the location is part of a condition response account for the size of the footer.
else if (!paraBreak.MyItemInfo.IsCautionPart && !paraBreak.MyItemInfo.IsNotePart && paraBreak.ParentHasCalvertMacro && accountForCalvertAlarmConditionResponseFooter == 0)
{
paraBreak = FindPageBreak(yStart, ySpaceOnCurPage - vlnPrintObject.SixLinesPerInch * 4, yLowerLimit, myList, lastBreak, yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace,
myBottomMsgSpace, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[40].ContinueOnly, yTop);
if (paraBreak.MyItemInfo.MyPrevious == null)
if (paraBreak.MyParent.ChildrenAbove.Count > 0)
paraBreak = paraBreak.MyParent.ChildrenAbove[0];
else
paraBreak = paraBreak.MyParent;
//_MyLog.WarnFormat("Keep notes and cautions with CR text {0},'{1}','{2}','{3}'", paraBreak.MyItemInfo.ItemID, paraBreak.MyItemInfo.ShortPath, paraBreak.MyItemInfo.MyProcedure.DisplayNumber, paraBreak.MyParent.MyParent.MyItemInfo.DisplayText);
}
if (!paraBreak.MyItemInfo.IsCautionPart && !paraBreak.MyItemInfo.IsNotePart && paraBreak.ParentHasCalvertMacro)
{
vlnParagraph pTop = FirstCRParagraph(paraBreak);
if (pTop != null && paraBreak.YOffset > pTop.YOffset && paraBreak.YOffset <= pTop.YOffset + 2 * SixLinesPerInch && pTop.MyParent != lastBreak)
{
if (pTop.MyItemInfo.MyPrevious == null && pTop.MyParent.ChildrenAbove.Count > 0)
{
paraBreak = pTop.MyParent.ChildrenAbove[0];
//_MyLog.WarnFormat("Break at First CR Paragraph w/Notes {0},'{1}','{2}','{3}'", paraBreak.MyItemInfo.ItemID, paraBreak.MyItemInfo.ShortPath, paraBreak.MyItemInfo.MyProcedure.DisplayNumber, pTop.MyParent.MyParent.MyItemInfo.DisplayText);
}
else
{
paraBreak = pTop.MyParent;
//_MyLog.WarnFormat("Break at First CR Paragraph {0},'{1}','{2}','{3}'", paraBreak.MyItemInfo.ItemID, paraBreak.MyItemInfo.ShortPath, paraBreak.MyItemInfo.MyProcedure.DisplayNumber, pTop.MyParent.MyParent.MyItemInfo.DisplayText);
}
}
}
if (!paraBreak.MyItemInfo.IsCautionPart && !paraBreak.MyItemInfo.IsNotePart && paraBreak.ParentHasCalvertMacro)
accountForCalvertAlarmConditionResponseFooter = 5 * SixLinesPerInch;
else
accountForCalvertAlarmConditionResponseFooter = 0;
//if (lastBreak != null && paraBreak.MyItemInfo.Ordinal == 1 && !paraBreak.MyItemInfo.IsCautionOrNotePart)
//_MyLog.WarnFormat("'Strange Break',{0},'{1}','{2}','{3}',{4}", paraBreak.MyItemInfo.ItemID, paraBreak.MyItemInfo.ShortPath, paraBreak.MyItemInfo.MyProcedure.DisplayNumber, paraBreak.MyItemInfo.MyHLS.DisplayText,lastBreak.MyItemInfo.ItemID);
}
if (lastBreak == paraBreak)
{
throw (new Exception(string.Format("Pagination Infinite Loop {0}", lastBreak.MyItemInfo.ShortPath)));
}
// If the paraBreak is in an RNO and the location of the RNO is within the range of the AER parent, then break on the AER.
if (paraBreak.MyItemInfo.IsInRNO)
{
vlnParagraph aerParent = paraBreak.MyParent;
while (aerParent.MyItemInfo.IsInRNO) aerParent = aerParent.MyParent;
if (aerParent.YOffset + aerParent.Height > paraBreak.YOffset)
{
if (aerParent.ChildrenAbove != null && aerParent.ChildrenAbove.Count > 0) // If the aerParent has caution or note
aerParent = aerParent.ChildrenAbove[0];//, break on the caution or note.
if (aerParent != lastBreak) paraBreak = aerParent;
}
}
// MNS Pagination - Mike Weiner Case 1b to keep substeps together on one page
if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.PutOnPageByItself && !paraBreak.MyParent.MyItemInfo.IsHigh && !paraBreak.MyItemInfo.IsHigh)
{
vlnParagraph firstLevel = paraBreak.MyParent;
while (firstLevel.MyItemInfo.IsInRNO) firstLevel = firstLevel.MyParent;
if (!firstLevel.MyItemInfo.IsHigh)
{
while (!firstLevel.MyParent.MyItemInfo.IsHigh) firstLevel = firstLevel.MyParent;
if (firstLevel.MyParent.ChildrenBelow != null && firstLevel.MyParent.ChildrenBelow.Count > 0 && firstLevel.MyParent.ChildrenBelow[0] != firstLevel &&
firstLevel.YSize < yPageSize - (myTopMsgSpace + SixLinesPerInch))
{
vlnParagraph firstLevel1 = firstLevel;
if (firstLevel.ChildrenAbove != null && firstLevel.ChildrenAbove.Count > 0) // If the aerParent has caution or note
firstLevel = firstLevel.ChildrenAbove[0];//, break on the caution or note.
if (firstLevel != lastBreak && paraBreak != firstLevel)
{
//Console.WriteLine("'{0}','{1}','{2}'", firstLevel1.MyParent.MyItemInfo.ShortPath, firstLevel1.MyItemInfo.MyTab.Text, firstLevel1.MyItemInfo.ShortPath);
paraBreak = firstLevel;
}
}
}
}
// If the break is going to happen on a table, and the tables parent would fit on a page with the table
// and the text in the parent includes the word table, then break on the parent
//if (lastBreak != paraBreak.MyParent && paraBreak.MyItemInfo.IsTable && paraBreak.YSize < ySpaceOnCurPage && paraBreak.MyParent.MyItemInfo.DisplayText.ToUpper().Contains("TABLE"))
// paraBreak = paraBreak.MyParent;
//paraBreak.ShowPageBreak(999, paraBreak.MyItemInfo.ShortPath, "Yes",paraBreak.YTop, paraBreak.YSize, paraBreak.Height, false);
//_MyLog.InfoFormat("Place to break\r\n==>'Place to Break',{0},'{1}','{2}'"
//, paraBreak.MyItemInfo.ItemID, paraBreak.MyItemInfo.MyDocVersion.MyFolder.Name, paraBreak.MyItemInfo.ShortPath);
// yTopNew is y Location of this page break. YTopMost is top of HLS, including any Cautions/Notes/Boxes/etc
//float yTopNew = paraBreak.YVeryTop - YTopMost;
//float yTopNew = paraBreak.YTopMost - YTopMost;
if (JustATableThatWillFit(paraBreak, yPageSize - (myTopMsgSpace + yEndMsg)))
paraBreak = paraBreak.ChildrenBelow[0];
float ySpaceOnNextPage1 = yPageSize - (myTopMsgSpace + (yEndMsg == 0 ? SixLinesPerInch : 0)); // Allow for continue message and blank line.
ySpaceOnNextPage1 -= accountForSmartTemplateHeader;
// This fixes B2016-174:
// Added the check to not go into this code if on a step that needs to break. If the conditions were met, this
// code was not putting a page break on a step that needed to break, i.e. PageBreakOnStep = true.
// B2018-024: Added the 'DidPreferredPageBreak', don't do the compressed code if a preferred page break exists on the step.
if (!DidPreferredPageBreak && (MyItemInfo.IsStep && !MyItemInfo.FormatStepData.PageBreakOnStep) && MyItemInfo.ActiveFormat.MyStepSectionLayoutData.PartialStepCompression && onNewPage) // ySpaceOnNextPage1 == ySpaceOnCurPage+myBottomMsgSpace)
{
float ySpaceAt7LPI = ((ySpaceOnCurPage - accountForCalvertAlarmConditionResponseFooter) * SixLinesPerInch / _SevenLinesPerInch) - _SevenLinesPerInch;
vlnParagraph paraBreak7 = FindPageBreak(yStart, ySpaceAt7LPI, yLowerLimit,
myList, lastBreak, yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace,
myBottomMsgSpace, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[40].ContinueOnly, yTop);
if (paraBreak7 != null && paraBreak7.YOffset > paraBreak.YOffset && paraBreak.MyItemInfo.StepLevel >= paraBreak7.MyItemInfo.StepLevel)
{
paraBreak = paraBreak7;
// Compress Part of Step
// .oooooo. ooooooooo. .
// d8P' `Y8b `888 `Y88. .o8
// 888 .ooooo. ooo. .oo. .oo. oo.ooooo. oooo d8b .ooooo. .oooo.o .oooo.o 888 .d88' .oooo. oooo d8b .o888oo
// 888 d88' `88b `888P"Y88bP"Y88b 888' `88b `888""8P d88' `88b d88( "8 d88( "8 888ooo88P' `P )88b `888""8P 888
// 888 888 888 888 888 888 888 888 888 888ooo888 `"Y88b. `"Y88b. 888 .oP"888 888 888
// `88b ooo 888 888 888 888 888 888 888 888 888 .o o. )88b o. )88b 888 d8( 888 888 888 .
// `Y8bood8P' `Y8bod8P' o888o o888o o888o 888bod8P' d888b `Y8bod8P' 8""888P' 8""888P' o888o `Y888""8o d888b "888"
// 888
// o888o
//
// | Step over a Number of Pages |
// | First Page | Second Page | Third Page |
//--------------------------------------------------------------------------------------
// |paraBreak[0] |paraBreak[1]
// | |
// |CompressPartOfStep |CompressPartOfStep
// | Flags compression for 2nd page | Flags compression for 2nd page
// | of step starting at paraBreak[0] | of step starting at paraBreak[1]
// | | See code below for 'Compress Rest of Step'
// <==|CompressFirstPartOfStep |
// | Flags compression for 1st page |
// | (1st page doesn't use paraBreak) |
//
if (lastBreak != null) // not on first page of step
{
lastBreak.PageBreakReason = "More of Step at 7 LPI";
lastBreak.CompressPartOfStep = true;
}
else
{
paraBreak.CompressFirstPartOfStep = true;
}
}
}
onNewPage = true;
float yTopNew = Math.Min(paraBreak.YTopMost, paraBreak.YVeryTop) - YTopMost;
// B2020-120: for calvert alarms, consider the size of the condition response text/lines
if (paraBreak.HasCalvertMacro) yTopNew += (accountForCalvertAlarmConditionResponseFooter - SixLinesPerInch);
// B2017-161: unnecessary PageBreak for background documents: use the 'usedPageBreakOnStepList' flag when using the PageBreakOnStepList, don't adjust space on page to account
// for continue message, if there is not one.
bool usedPageBreakOnStepList = false;
// This is for formats that break on all HLS, Cautions & Notes (often backgrounds):
if (PageBreakOnStepList.Count > 0)
{
// If the next page break is beyond the next hls/caution/note, use the next
// hls/caution/note.
if (PageBreakOnStepList[0].YTop <= paraBreak.YTop)
{
PageBreakOnStepList[0].CompressFirstPartOfStep = paraBreak.CompressFirstPartOfStep;
// B2017-252 Robinson EOP Upgrade Basis Phase 1 Procedure set located in the Pre-Upgrade (Legacy) folder,
// EOP-FR-S.1-BD, WOG Step 13 no longer fits Deviations and References on the same page.
// Added the IF condition to fix the problem
// B2017-161: unnecessary PageBreak for background documents: use the 'usedPageBreakOnStepList' flag when using the PageBreakOnStepList, don't adjust space on page to account
// for continue message, if there is not one.
// B2017-252 Pagination Fix - WCN was not paginating correctly. Reverted to orginal code.
usedPageBreakOnStepList = true;
paraBreak = PageBreakOnStepList[0];
PageBreakOnStepList.RemoveAt(0);
yTopNew = paraBreak.YTop - YTopMost;
}
// The following code caused forced pagination for Catawba EOP BG - EP/1/A/5000/FR-C.1.SC..S16..N2..S4..S1.
//else if(PageBreakOnStepList[0].YSize - yTop <= ySpaceOnCurPage)
//{
// DebugPagination.WriteLine("======>>>>> Other Condition");
// paraBreak = PageBreakOnStepList[0];
// PageBreakOnStepList.RemoveAt(0);
// yTopNew = paraBreak.YTop - YTopMost;
//}
}
RemoveProcessedParagraphs(myList, yTopNew - yTop);
yTop = yTopNew;
MyPageHelper.ParaBreaks.Add(paraBreak);
ySpaceOnNextPage1 -= paraBreak.GetSectionTopMessageSize(); // B2016-134: Account for wcntraining section top continue on substep containers (notes/cautions)
SectionConfig sch = MyItemInfo.ActiveSection.MyConfig as SectionConfig;
// B2016-266 Only set SectionTitleContinued1 if the format supports section continue messages
bool doSectionTitleContinued1 = (sch == null || sch.Section_PrintHdr == "Y") && !MyItemInfo.MyDocStyle.CancelSectTitle && MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ContinueSectionHeader;
if (doSectionTitleContinued1 && MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert)
{ // B2017-036 BGE Unit 1 STP-073A-1 6.5.B.5 in the Approved Procedures did not print properly
string myMsg = MyItemInfo.MyDocStyle.Continue.Top.Message;
if (myMsg != null && myMsg != "")
doSectionTitleContinued1 = false;
}
if (doSectionTitleContinued1) ySpaceOnNextPage1 -= 2 * SixLinesPerInch; // B2016-195: Account for Section Continue Message
// B2017-161: unnecessary PageBreak for background documents: use the 'usedPageBreakOnStepList' flag when using the PageBreakOnStepList, don't adjust space on page to account
// for continue message, if there is not one.
// B2017-252 Pagination Fix - RNP was not paginating correctly. Added logic to set ySPaceOnCurPage if ySpaceOnNextPage was larger
if (!usedPageBreakOnStepList || ySpaceOnNextPage1 > ySpaceOnCurPage) ySpaceOnCurPage = ySpaceOnNextPage1;
//ySpaceOnCurPage = yPageSize - (myTopMsgSpace + SixLinesPerInch); // Allow for continue message and blank line.
//if (paraBreak.YTopMost != paraBreak.YVeryTop && MyPageHelper.TopMessage == null && MyPageHelper.BottomMessage == null)
// ySpaceOnCurPage = yPageSize;
//ySpaceOnCurPage = yPageSize; // Allow for continue message and blank line.
//DocStyle docstyle = MyItemInfo.MyDocStyle;
//string myMsg = docstyle.Continue.Bottom.Message;
//if ((myMsg ?? "") != "") ySpaceOnCurPage -= 2 * SixLinesPerInch; // Allow for continue message and blank line.
yLowerLimit = ySpaceOnCurPage / 2;
if (_Match16BitPagination) yLowerLimit -= 1.5F * SixLinesPerInch; // 276 for HLP
yStart = 0;
// This fixes B2016-174:
// Added the check to not go into this code if on a step that needs to break. If the conditions were met, this
// code was not putting a page break on a step that needed to break, i.e. PageBreakOnStep = true.
if ((MyItemInfo.IsStep && !MyItemInfo.FormatStepData.PageBreakOnStep) && MyItemInfo.ActiveFormat.MyStepSectionLayoutData.PartialStepCompression)
{
float adjustedCurPageYSpace = ySpaceOnCurPage;
if (MyPageHelper.PrintedSectionPage > 0 && MyItemInfo.ActiveSection != null && (MyItemInfo.ActiveSection.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PrintSectOnFirst) == E_DocStructStyle.DSS_PrintSectOnFirst)
{
ItemInfo ii = paraBreak.MyItemInfo;
while (!ii.IsHigh) ii = ii.MyParent;
if (ii == ii.LastSibling) //B2020-075 only adjust the Farley section page length to make room for END message if this is the last step of the section.
adjustedCurPageYSpace -= MyPageHelper.PrintedSectionPage; //B2020-064 FNP-1-ECP-0.0 Attachment 6 not enough room for end message
}
float ySpaceAt7LPI = (adjustedCurPageYSpace - (accountForCalvertAlarmConditionResponseFooter + yEndMsg)) * SixLinesPerInch / _SevenLinesPerInch;
if ((YSize - yTop) > (adjustedCurPageYSpace - (accountForCalvertAlarmConditionResponseFooter + yEndMsg))
&& (YSize - yTop) < ySpaceAt7LPI )
{
// Compress Rest of Step
// .oooooo. ooooooooo. .
// d8P' `Y8b `888 `Y88. .o8
// 888 .ooooo. ooo. .oo. .oo. oo.ooooo. oooo d8b .ooooo. .oooo.o .oooo.o 888 .d88' .ooooo. .oooo.o .o888oo
// 888 d88' `88b `888P"Y88bP"Y88b 888' `88b `888""8P d88' `88b d88( "8 d88( "8 888ooo88P' d88' `88b d88( "8 888
// 888 888 888 888 888 888 888 888 888 888ooo888 `"Y88b. `"Y88b. 888`88b. 888ooo888 `"Y88b. 888
// `88b ooo 888 888 888 888 888 888 888 888 888 .o o. )88b o. )88b 888 `88b. 888 .o o. )88b 888 .
// `Y8bood8P' `Y8bod8P' o888o o888o o888o 888bod8P' d888b `Y8bod8P' 8""888P' 8""888P' o888o o888o `Y8bod8P' 8""888P' "888"
// 888
// o888o
paraBreak.PageBreakReason = "Rest of Step fits at 7 LPI";
paraBreak.CompressPartOfStep = true;
break;
}
}
}
if (paraBreak != null && paraBreak.PageBreakReason == null)
paraBreak.PageBreakReason = "Rest of Step fits at 6 LPI";
ProfileTimer.Pop(profileDepth);
}
// B2018-033 VCS SAG-6 Steps 3 and 9 and SACRG1 Step 13
// Howany items are left to be printed.
private int ItemsLeft(StepLevelList myList)
{
int retval = 0;
foreach (int stepLevel in myList.Keys) // loop thru StepLevels, starting with lowest.
foreach (float yLocation in myList[stepLevel].Keys) // loop thru yLocation
retval++;
return retval;
}
// The following finds all of the preferred page breaks for this step & if found adds them to a
// list of the location & the paragraph it is on. This is used so that pagination calculations
// occur for steps following the preferred page break rather than starting on the page after
// substep with preferred page break (B2017-109)
private SortedList<float, vlnParagraph> GetMyPreferredBreaks(StepLevelList myList)
{
if (!MyItemInfo.MyDocStyle.SupplementalInformation) return null;
SortedList<float, vlnParagraph> sdpara = null;
foreach (int stepLevel in myList.Keys) // loop thru StepLevels, starting with lowest.
{
foreach (float yLocation in myList[stepLevel].Keys) // loop thru yLocation
{
vlnParagraph myPara = myList[stepLevel][yLocation];
StepConfig sci = myPara.MyItemInfo.MyConfig as StepConfig;
if (sci != null && sci.Step_PreferredPagebreak)
{
if (sdpara == null) sdpara = new SortedList<float, vlnParagraph>();
if (myPara.ChildrenAbove != null && myPara.ChildrenAbove.Count > 0) sdpara.Add(-yLocation, myPara.ChildrenAbove[0]);
else sdpara.Add(-yLocation, myPara);
}
}
}
return sdpara;
}
private float GetBottomContinueMessageSize(DocStyle docstyle)
{
float myBottomMsgSpace = 0;
docstyle = MyItemInfo.MyDocStyle;
string myBottomMsg = docstyle.Continue.Bottom.Message;
myBottomMsgSpace = ((myBottomMsg ?? "") != "") ? 2 * SixLinesPerInch : 0;
if (myBottomMsg != null && myBottomMsg.Contains("par")) myBottomMsgSpace += SixLinesPerInch;
return myBottomMsgSpace;
}
private bool JustATableThatWillFit(vlnParagraph paraBreak, float ypagesize)
{
if (paraBreak.MyItemInfo.MyContent.Text.Replace(" ", "").Replace(@"\u160?", "").Replace(@"\'A0", "") != "") return false;
if (paraBreak.YSize < ypagesize) return false;
if (paraBreak.ChildrenAbove.Count > 0) return false;
if (paraBreak.ChildrenLeft.Count > 0) return false;
if (paraBreak.ChildrenRight.Count > 0) return false;
if (paraBreak.ChildrenBelow.Count != 1) return false;
if (!paraBreak.ChildrenBelow[0].MyItemInfo.IsTable) return false;
vlnParagraph paraTable = paraBreak.ChildrenBelow[0];
if (paraTable.YSize < ypagesize)
return true;
return false;
}
// B2020-108: Original FindPageBreak was renamed to FindPageBreak1 so that an additional check can be made after
// the page break is found. Check if the location identified is a parent of a table that is too long to allow parent to fit
// on the same page, if so break at the table rather than the parent.
private static vlnParagraph FindPageBreak(float yStart, float yUpperLimit, float yLowerLimit, StepLevelList myList, vlnParagraph lastBreak, float fullPage,
float myBottomMsgSpace, bool RNOContinueOnly, float yTop)
{
vlnParagraph myPara = FindPageBreak1(yStart, yUpperLimit, yLowerLimit, myList, lastBreak, fullPage, myBottomMsgSpace, RNOContinueOnly, yTop);
float yLocation = GetYLocationFromMyList(myPara, myList);
float spaceOnPage = yUpperLimit + yLocation;
if (myPara.YSize > spaceOnPage && myPara.ChildrenBelow != null && myPara.ChildrenBelow.Count > 0
&& myPara.ChildrenBelow[0].MyItemInfo.IsTable && spaceOnPage > 0)
{
vlnParagraph tpara = myPara.ChildrenBelow[0] as vlnParagraph;
if (tpara.YSize + myPara.Height > yUpperLimit) return tpara;
}
return myPara;
}
private static float GetYLocationFromMyList(vlnParagraph myPara, StepLevelList myList)
{
foreach (int stepLevel in myList.Keys) // loop thru StepLevels, starting with lowest.
{
foreach (float yLocation in myList[stepLevel].Keys) // loop thru yLocation
{
vlnParagraph pg = myList[stepLevel][yLocation];
if (pg == myPara) return -yLocation;
}
}
return 0;
}
/// <summary>
/// Finds the highest StepLevel (lowest StepLevel number, 0 = HLS, 1 = first substep) that
/// fills the page sufficiently (more than half-full)
/// </summary>
/// <param name="yWithinMargins"></param>
/// <param name="yTop"></param>
/// <param name="myList"></param>
/// <returns></returns>
private static vlnParagraph FindPageBreak1(float yStart, float yUpperLimit, float yLowerLimit, StepLevelList myList, vlnParagraph lastBreak, float fullPage,
float myBottomMsgSpace,bool RNOContinueOnly, float yTop)
{
vlnParagraph minPara = null;
//StringBuilder minBuff = new StringBuilder();
float? yLocationMin=null;
vlnParagraph minPara2 = null;
float? yLocationMin2=null;
float yAddForBtmMsg = 0;
// useful for debugging pagination issues, lastbreak gets the paragraph at the top of the previous page, shows all
// of the locations within 'range' on the next page.
//if (lastBreak != null && lastBreak.MyItemInfo.InList(72481))
//{
// int range = 120;
// Console.WriteLine("lastBreak = {0}, {1}", yUpperLimit, lastBreak);
// foreach (int stepLevel in myList.Keys) // loop thru StepLevels, starting with lowest.
// {
// foreach (float yLocation in myList[stepLevel].Keys) // loop thru yLocation
// {
// if (-yLocation > yUpperLimit - range && -yLocation <= yUpperLimit + range)
// {
// vlnParagraph pg = myList[stepLevel][yLocation];
// if (pg.PartsAbove != null && pg.PartsAbove.Count > 0)
// Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t\"{5}\"", stepLevel, yUpperLimit + yLocation, (yUpperLimit + yLocation) - pg.Height, pg.YOffset, (pg.PartsAbove[0] as vlnPrintObject).YOffset, pg);
// else
// Console.WriteLine("{0}\t{1}\t{2}\t\"{3}\"", stepLevel, yUpperLimit + yLocation, (yUpperLimit + yLocation) - pg.Height, pg);
// }
// }
// }
//}
foreach (int stepLevel in myList.Keys) // loop thru StepLevels, starting with lowest.
{
foreach (float yLocation in myList[stepLevel].Keys) // loop thru yLocation
{
float spaceOnPage = yUpperLimit + yLocation;
vlnParagraph myPara = myList[stepLevel][yLocation];
bool IsIP3Format = myPara.MyItemInfo.ActiveFormat.Name.StartsWith("IP3");
int maxLev = stepLevel;
if (spaceOnPage > 0 && (maxLev = MaxBreakLevel(yLocation, myList, stepLevel, myPara)) > stepLevel)
{
//DebugPagination.WriteLine("'Adjust for Max StepLevel',{0},{1},{2},'{3}'",myPara.MyItemInfo.ItemID,stepLevel,maxLev, myPara.MyItemInfo.ShortPath);
//break;
}
else
{
if (RNOContinueOnly && !myPara.MyItemInfo.IsInRNO)
yAddForBtmMsg = myBottomMsgSpace;
else
yAddForBtmMsg = 0;
spaceOnPage += yAddForBtmMsg;
if (!IsIP3Format)
{
// The following lines were added for Comanche Peak ECA-TP-11-001A.SProcedure Steps.S17 (Printed as Step 12)
if (spaceOnPage > 0 && myPara.YSize > fullPage && myPara.ChildrenRight != null && myPara.ChildrenRight.Count > 0
&& myPara.ChildrenRight[0].YSize <= fullPage && myPara.ChildrenRight[0].YSize > spaceOnPage
// B2018-104: don't return if my parent is a high level - a top continue message was printing
// Was not complete, i.e. caused other pagination problems and was put back in: B2019-170: VCS page break causes printing of step on top of next page.
// Note that this bug fix for WCN was commented out. Harry Julian wanted this on 11/15/19. A new bug will be written for the WCN error.
// B2019-173 reintroduced this line:
&& !myPara.MyItemInfo.IsHigh)
{
//_MyLog.WarnFormat("\r\nMyParaBreak {0},{1},{2},{3},{4}", myPara, myPara.YSize, yUpperLimit, myPara.ChildrenRight[0].YSize, spaceOnPage);
if (myPara != lastBreak)
return myPara;
}
// The following lines were added for Comanche Peak ECA-0.1A.SProcedure Steps.S17 (Printed as Step 12)
vlnParagraph myParent = myPara.MyParent;
spaceOnPage = yAddForBtmMsg + yUpperLimit + myPara.YTop + yLocation - myParent.YTop;
if (spaceOnPage > 0 && myParent != lastBreak && myParent.YSize > fullPage && myParent.ChildrenRight != null && myParent.ChildrenRight.Count > 0
&& myParent.ChildrenRight[0].YSize <= fullPage && myParent.ChildrenRight[0].YSize > spaceOnPage
// Was not complete, i.e. caused other pagination problems and was put back in: B2019-170: VCS page break causes printing of step on top of next page.
// Note that this bug fix for WCN was commented out. Harry Julian wanted this on 11/15/19. A new bug will be written for the WCN error.
// B2019-173 reintroduced the 'IsHigh' portion and added IsRNOPart, the HLS & RNOPart print at same location on page so code needs
// to account for either. second iteration of this fix removed IsRNOPart (see code in Paginate)
&& !myParent.MyItemInfo.IsHigh) /*|| myPara.MyItemInfo.IsRNOPart)) */// B2018-104: don't return if my parent is a high level - a top continue message was printing
{
//_MyLog.WarnFormat("\r\nMyParentBreak {0},{1},{2},{3},{4}", myParent, myParent.YSize, yUpperLimit, myParent.ChildrenRight[0].YSize, spaceOnPage);
// Removed the following and moved logic to Paginate method for the second iteration of the bug fix. This code below AND the IsRNOPart above caused another
// pagination problem. The insert and subsequent removal of this code are both done under bug B22019-173.
// Initial code for B2019-173: make minPara2 the first step on next page
//if (minPara2 != null && minPara2.MyParent == myParent && minPara2 != lastBreak && minPara2.MyItemInfo.Ordinal == 1)
//{
// return minPara2;
//}
if (myParent != lastBreak)
return myParent;
}
}
// The top of this step will fit onto page (-yLocation < yWithinMargins)
float wcnChkLstBorder = myPara.MyItemInfo.MyHLS != null && myPara.MyItemInfo.MyHLS.FormatStepData.UseSmartTemplate &&
(myPara.MyItemInfo.MyHLS.FormatStepData.Suffix ?? "") != "" ? 2 * SixLinesPerInch : 0;
if (myPara != lastBreak)
{
if ((-yLocation + yStart) >= yLowerLimit) // More than the lower limit
{
if (yLocationMin == null) // No old location
{
//minBuff.AppendLine(string.Format("OLD1 >>>>> '{0}',{1},{2}", myPara.MyItemInfo.ShortPath, -yLocation, yUpperLimit));
yLocationMin = yLocation;
minPara = myPara;
}
else if (-yLocation < -yLocationMin && -yLocationMin >= yUpperLimit) // New location is smaller and old location excedes limit
{
//minBuff.AppendLine(string.Format("NEW1A >>>>> '{0}',{1},{2}", myPara.MyItemInfo.ShortPath, -yLocation, yUpperLimit));
yLocationMin = yLocation;
minPara = myPara;
}
else if (-yLocation > -yLocationMin && -yLocation <= yUpperLimit) // New location is larger and new location is less than limit
{
//minBuff.AppendLine(string.Format("NEWB1 >>>>> '{0}',{1},{2}", myPara.MyItemInfo.ShortPath, -yLocation, yUpperLimit));
yLocationMin = yLocation;
minPara = myPara;
}
}
else // Less than the lower limit
{
if (yLocationMin2 == null)
{
//minBuff.AppendLine(string.Format("OLD2 >>>>> '{0}',{1},{2}", myPara.MyItemInfo.ShortPath, -yLocation, yUpperLimit));
yLocationMin2 = yLocation;
minPara2 = myPara;
}
else if (-yLocation < -yLocationMin2 && -yLocationMin2 >= yUpperLimit) // New location is smaller and old location excedes limit
{
//minBuff.AppendLine(string.Format("NEW2A >>>>> '{0}',{1},{2}", myPara.MyItemInfo.ShortPath, -yLocation, yUpperLimit));
yLocationMin2 = yLocation;
minPara2 = myPara;
}
else if (-yLocation > -yLocationMin2 && -yLocation <= yUpperLimit) // New location is larger and new location is less than limit
{
//minBuff.AppendLine(string.Format("NEW2B >>>>> '{0}',{1},{2}", myPara.MyItemInfo.ShortPath, -yLocation, yUpperLimit));
// B2018-033 VCS SAG-6 Steps 3 and 9 and SACRG1 Step 13
// Break at next step if going to break at table and there is room for scrunched table
if (myPara.MyGrid != null && minPara != null && -yLocationMin <= (yUpperLimit + myPara.MyGrid.SpaceAvailable))
return minPara;
yLocationMin2 = yLocation;
minPara2 = myPara;
}
}
}
//while (myPara.MyParent.YTop == myPara.YTop) myPara = myPara.MyParent;
while (myPara.MyParent != null && myPara.MyParent.YTop == myPara.YTop) myPara = myPara.MyParent;
int everyNLines = myPara.MyItemInfo.MyPrevious != null && myPara.MyItemInfo.FormatStepData == null ? 1 : myPara.MyItemInfo.FormatStepData.StepLayoutData.EveryNLines ?? 1;
bool inSameBox = InSameBox(myPara, minPara2); // if this note/caution is in same box as the break, don't break within the notes/cautions in the same box
if (!inSameBox && myPara.ChildrenAbove.Count == 0 && wcnChkLstBorder - yLocation < yUpperLimit + yAddForBtmMsg || (everyNLines != 99 && (wcnChkLstBorder - yLocation == yUpperLimit + yAddForBtmMsg))) // Fix for OFN-RJ-23
//if (-yLocation < yUpperLimit) // Before
//if (-yLocation < yWithinMargins && myList[stepLevel][yLocation].MyItemInfo.MyPrevious != null)
{
//ItemInfo prev = myList[stepLevel][yLocation].MyItemInfo.MyPrevious;
//if (myList[stepLevel][yLocation].MyItemInfo.ItemID == 5609) Console.WriteLine("aer");
//if (myList[stepLevel][yLocation].MyItemInfo.ItemID == 4312) Console.WriteLine("rno");
// The top of this step is more than 1/2 way down the page
if ((-yLocation + yStart) >= yLowerLimit)
if (myPara != lastBreak)
// Second RNO check was added for the following:
// B2020-013 premature break in RNO column - Callaway OTO-AC-00002 step 2
// B2020-016 for Robinson AOP-010 step 27 was breaking too soon
// B2020-073 was not keeping all of RNO sub-step together - Comanche Peak FRC-0.1 (unit 1) Step 14
// B2020-081 was breaking on an AER substep that has an long RNO - should keep AER substep and part of RNO on the page = D.C. Cook "Current (Post FLEX) U1 NOP NOT [EOPs]" set, ES-0.1 step 1.
// B2020-085 was breaking first child of second RNO (if third IF in RNO) - should break on second child of second RNO - D.C. Cook AOP Unit 1 002-020 Step 15
if ((-yLocation + yStart) >= yLowerLimit)
{
vlnParagraph rnoChild = myPara.HasSecondRNOThatWillFit(yStart, yLowerLimit, yUpperLimit, myList, stepLevel, yTop); // Only if it is more than the lower limit
if (rnoChild != null)
return rnoChild;
}
// B2019-103, B2019-114 Break at a step if the step will fit on a page by itself and it will
// not fit in the current page
float yAdjustLastSubStep = 0;
if ((myPara.MyItemInfo.ActiveParent as ItemInfo).IsHigh && myPara.MyItemInfo.NextItem == null)
{
// B2020-059 Last Substep will fit on page by itself - add the bottom continue message length to the fullpage length.
// fullpage is passed in FindPageBreak() with the bottom continue message length subtracted from the full page length.
// if this is the last sub-step of the HLS then we will not need a continue message, thus we include fullpage by th length of the bottom continue message.
yAdjustLastSubStep = myBottomMsgSpace;
_MyLog.WarnFormat("Last Substep will fit on page by itself {0}", myPara.MyItemInfo.ShortPath); // add information in the error log
}
if (StepWillFitOnBlankPageButNotOnCurrentPage(myPara, yLocation, yStart, fullPage + yAdjustLastSubStep))
if (myPara != lastBreak)
return myPara;
// If this item will not fit on the current page, put a page break
if (myPara.YBottom - myPara.YTop > (yUpperLimit + yLocation))
if (myPara != lastBreak)
if ((-yLocation + yStart) >= yLowerLimit) // Only if it is more than the lower limit
return myPara;
// if is a caution or note & parent is a substep and entire substep doesn't fit, break.
if ((myPara.MyItemInfo.IsNote || myPara.MyItemInfo.IsCaution) &&
!myPara.MyParent.MyItemInfo.IsHigh &&
myPara.MyParent.YSize > (yUpperLimit + yLocation))
{
//McGuire Unit 1 AOPs - AP/1/A/5500/07.SEnclosure 7.S31..S1..C1
if ((-yLocation + yStart) >= yLowerLimit) // Only if it is more than the lower limit
return myPara;
}
}
}
}
}
//DebugPagination.Write(minBuff.ToString());
if (-yLocationMin > yUpperLimit && minPara2 != null) minPara = null;
// if breaking at a note/caution - don't break within the same box. Clear minPara (like code above)
// so that minPara2 is used.
if (minPara != null && minPara2 != null && ((minPara2.MyItemInfo.IsCautionPart && minPara.MyItemInfo.IsCaution) || (minPara2.MyItemInfo.IsNotePart && minPara.MyItemInfo.IsNote))
&& minPara.MyItemInfo.FirstSibling.ItemID == minPara2.MyItemInfo.ItemID) minPara = null;
//if (minPara != null) DebugPagination.WriteLine("### 111111 {0}", minPara);
//if(minPara2 != null) DebugPagination.WriteLine("### n222222 {0}", minPara2);
return minPara ?? minPara2;
}
// B2020-013 premature break in RNO column - Callaway OTO-AC-00002 step 2
// B2020-016 bad pagination on RNOs for Robinson AOP-010 step 27 , AOP-024 Step 10, EOP E-0 step 10, EOP ECA-2.1 step 28
// B2020-073 was not keeping all of RNO sub-step together - Comanche Peak FRC-0.1 (unit 1) Step 14
// B2020-081 was breaking on an AER substep that has an long RNO - should keep AER substep and part of RNO on the page = D.C. Cook "Current (Post FLEX) U1 NOP NOT [EOPs]" set, ES-0.1 step 1.
// B2020-085 was breaking first child of second RNO (if third IF in RNO) - should break on second child of second RNO - D.C. Cook AOP Unit 1 002-020 Step 15
// B2020-099 was breaking on last sub-step of previous RNO - Calvert Approved Procedures; Abnormal Procedures <20> Unit 2; AOP-2A; Section VII; Step 11.RNO.11.1.c
private vlnParagraph HasSecondRNOThatWillFit(float yStart, float yLowerLimit, float yUpperLimit, StepLevelList myList, int stepLevel, float yTop)
{
// B2020-120: for calvert alarms/condition response table, don't run code for second rno
if (this.ChildrenAbove != null && this.ChildrenAbove.Count > 0) if (HasCalvertMacro) return this;
// note: "this" is the myPara from where this method is called
if (!MyItemInfo.IsInRNO || MyItemInfo.GetMaxRNOLevels <= 1) // GetMaxRNOLevels will get the greatest (lowest) RNO level in the step
return this; // does not have second (more than one) RNO - break at the myPara
if (this.MyItemInfo.IsRNOPart && this.MyItemInfo.RNOs == null) // B2020-099 if on an RNO an there isn't another one to check, just return current break on RNO
return this;
// see if there is a second RNO then see if it will fit on the page
vlnParagraph tmp = this;
while (!tmp.MyItemInfo.IsRNOPart) tmp = tmp.MyParent; // if on a substep of an RNO, move up the substep's parent (RNO)
vlnParagraph parent = tmp;
while (parent.MyParent != null && !parent.MyParent.MyItemInfo.IsSection) parent = parent.MyParent; // this will take us to the High level step
float yTopParent = parent.YTopMost; // this is where the HLS starts printing
if (this.MyItemInfo.IsRNOPart && this.MyItemInfo.RNOLevel > 1)
if ((this.YTopMost - yTopParent + yStart - yTop + this.YSize) > yUpperLimit)
{
foreach (vlnParagraph chld in parent.ChildrenBelow)
if (YBottomMostExcludingRNO(chld) > this.YTopMost)
return null; // the AER text overlaps the RNO text - DON'T use the myPara and keep looking instead
return this; // myPara is an RNO and the entire RNO will fit
}
// check the children of the myPara and see if it has an RNO that will fit
foreach (vlnParagraph chld in tmp.ChildrenBelow)
if (chld.MyItemInfo.IsRNOPart)
if ((chld.YTopMost + yStart + yTop - yTopParent) > yLowerLimit)
if ((chld.YTopMost + yStart + yTop - yTopParent) < yUpperLimit)
return chld; // second RNO will fit, use this instead of myPara
// check to see if there is AER substep children that would be spit if we pagination on the RNO
foreach (vlnParagraph chld in parent.ChildrenBelow)
if (chld.YOffset < this.YOffset && YBottomMostExcludingRNO(chld) > this.YTopMost) // B2020-085 Does AER child start before myPara and length greater than myPara start
return null; // the AER text positioning overlaps the RNO text positioning (caused AER sub-steps to be split onto next page (i.e. RO step) have pagination logic keep looking for place to break
return this; // current myPara is good
}
// B2020-081 used in HasSecondRNOThatWillFit() get the size of the AER and its substeps
private float YBottomMostExcludingRNO(vlnParagraph chld)
{
float maxBottomMost = chld.YBottom;
foreach (vlnParagraph gChld in chld.ChildrenBelow)
if (gChld.MyItemInfo.IsRNOPart == false)
maxBottomMost = Math.Max(maxBottomMost, YBottomMostExcludingRNO(gChld));
return maxBottomMost;
}
private static bool StepWillFitOnBlankPageButNotOnCurrentPage(vlnParagraph myPara, float yLocation, float yStart,float fullPage)
{
// B2019-150 & B2019-151 Pagination Bugs Seen for Summer EOP4.1 Step 10 and
// SAG Step 9. Added format flag to limit when this logic would be used.
if (myPara.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PaginateOnStepThatWillFitOnBlankPage == false)
return false;
float spaceOnCurrentPage = fullPage - (-yLocation+yStart);
// B2019-124 - Pagination - if substep will fit on a blank page but will not fit on the current page
// And is not the first substep then break
// B2019-130 - in Calvert data (FSG-1 Appendix 1 Unit 1 Actions, step E.1.g) the THEN sub step was placed on the next page
// the THEN sub step is at the same level as the bullet items above it (is a bullet item changed to a paragraph)
// We added a check for this via current content type vs previous content type.
return (myPara.MyItemInfo.Ordinal > 1 && myPara.MyItemInfo.MyContent.Type == myPara.MyItemInfo.MyPrevious.MyContent.Type && myPara.YSize > spaceOnCurrentPage && myPara.YSize < fullPage);
}
private static bool InSameBox(vlnParagraph myPara, vlnParagraph minPara2)
{
// see if this paragraph is a note/caution or in a note/caution where its 1st sibling is the input minPara2 (this
// is the next best-case page break location. This was added for Calvert's OI3/OI-1A/Section 5/Step H.3. Without it
// the page break occurred in the middle of the list of notes.
if (minPara2 == null) return false;
if ((myPara.MyItemInfo.IsCaution || myPara.MyItemInfo.IsNote || myPara.MyItemInfo.MyParent.IsCaution || myPara.MyItemInfo.MyParent.IsNote) && minPara2 != null)
{
ItemInfo mync = (myPara.MyItemInfo.IsNote || myPara.MyItemInfo.IsCaution) ? myPara.MyItemInfo : myPara.MyItemInfo.MyParent;
if (mync == null) return false;
if (mync.FirstSibling.ItemID == minPara2.MyItemInfo.ItemID) return true;
}
return false;
}
private static int MaxBreakLevel(float yLocation, StepLevelList myList, int maxLevel, vlnParagraph myParaBreak)
{
foreach (int stepLevel in myList.Keys)
foreach (float yLoc in myList[stepLevel].Keys)
{
vlnParagraph myPara = myList[stepLevel][yLoc];
if (Overlap(myPara, myParaBreak))
if (stepLevel > maxLevel)
{
//DebugPagination.WriteLine("'MaxBreakLevel',{0},{1},'{2}'", myPara.MyItemInfo.ItemID, stepLevel, myPara.MyItemInfo.ShortPath);
//Console.WriteLine("'MaxBreakLevel',{0},{1},'{2}'", myPara.MyItemInfo.ItemID, stepLevel, myPara.MyItemInfo.ShortPath);
if (!myPara.HasAncestor(myParaBreak))
maxLevel = stepLevel;
}
}
return maxLevel;
}
private static bool Overlap(vlnParagraph myPara, vlnParagraph myParaBreak)
{
// Fix for B2016-166: Calvert pagination-splitting a Note in AER from its associated step
if (myPara.MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertPagination)
return (myPara.YOffset <= myParaBreak.YOffset &&
(myPara.YOffset + myPara.Height) >= myParaBreak.YOffset);
return(myPara.YOffset == myParaBreak.YOffset);
}
private bool HasAncestor(vlnParagraph myParaBreak)
{
if (myParaBreak == MyParent) return true;
if (MyParent == null || MyParent.MyItemInfo.IsHigh) return false;
return MyParent.HasAncestor(myParaBreak);
}
//private void WalkStepLevel(float yTopMost)
//{
// foreach (vlnParagraph child in ChildrenAbove)
// child.WalkStepLevel(yTopMost);
// foreach (vlnParagraph child in ChildrenLeft)
// child.WalkStepLevel(yTopMost);
// ShowStepLevel(yTopMost);
// foreach (vlnParagraph child in ChildrenRight)
// child.WalkStepLevel(yTopMost);
// foreach (vlnParagraph child in ChildrenBelow)
// child.WalkStepLevel(yTopMost);
//}
//private void ShowStepLevel(float yTopMost)
//{
// ItemInfo item = MyItemInfo;
// ItemInfo parent = item.ActiveParent as ItemInfo;
// //if (para.MyItemInfo.ItemID == 205)
// // Console.Write("");
// DebugPagination.WriteLine("'StepLevel',{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}", YVeryTop - yTopMost, YSize, YBottomMost - yTopMost, item.ItemID, item.DBSequence, item.StepLevel, item.MyContent.Type % 10000,
// parent.MyContent.Type % 10000, item.HasCautionOrNote ? 1 : 0, parent.Cautions == null ? 0 : 1);
//}
public float TableSpaceAvailable// RHM20150525 - Table Scrunch
{
get // B2019-111 Keep AER Table with parent when RNO extends past the end of the page.
{
float tsa = 0;
float tsaRight = 0;
float btm = YBottom;
float btmRight = 0;
if (_ChildrenRight != null && _ChildrenRight.Count > 0)
{
tsaRight = _ChildrenRight[0].TableSpaceAvailable;
btmRight = _ChildrenRight[0].YBottomPagination;
}
if (_ChildrenBelow != null && _ChildrenBelow.Count > 0)
{
foreach (vlnParagraph pgh in _ChildrenBelow)
tsa = pgh.TableSpaceAvailable;
vlnParagraph pLast = ChildrenBelow[ChildrenBelow.Count - 1];
btm = pLast.YBottomPagination;
}
if (MyGrid != null)
tsa = MyGrid.SpaceAvailable + MyGrid.LeadingSpaceAvailable;
if (btmRight != 0)
{
//_MyLog.WarnFormat("Item={00}, B={1} BR={2} T={3} TR={4}",MyItemInfo.ItemID , btm, btmRight, tsa, tsaRight);
if (btm < btmRight)
tsa = tsaRight;
}
return tsa;
}
}
}
public partial class VlnSvgPageHelper : SvgPageHelper
{
private bool _OriginalPageBreak; // use 16bit page breaks.
public bool OriginalPageBreak
{
get { return _OriginalPageBreak; }
set { _OriginalPageBreak = value; }
}
// This handles Page Breaks within a Step
private List<vlnParagraph> _ParaBreaks = new List<vlnParagraph>();
public List<vlnParagraph> ParaBreaks
{
get { return _ParaBreaks; }
set { _ParaBreaks = value; }
}
}
}
Reference in New Issue View Git Blame Copy Permalink