1394 lines
81 KiB
C#
1394 lines
81 KiB
C#
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;
|
|
if (MyItemInfo.MyPrevious != null) // add if statement to fix Westinghouse print issue 3-21-2014
|
|
return 1;
|
|
}
|
|
// 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.MyActiveSection as SectionInfo;
|
|
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;
|
|
|
|
// 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.
|
|
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.PrintPhoneList && MyPageHelper.PhoneListHeight != 0)
|
|
yEndMsg += (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.
|
|
if (MyPageHelper.ParaBreaks.Count > 0)
|
|
{
|
|
string reason = "Unknown";
|
|
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
|
|
}
|
|
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
|
|
}
|
|
else if (!MyPageHelper.ParaBreaks[0].PageBreakOnStep && this.YTopMost > MyPageHelper.ParaBreaks[0].YTopMost)
|
|
{
|
|
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
|
|
}
|
|
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)
|
|
{
|
|
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;
|
|
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
|
|
if (MyItemInfo.DisplayText.ToUpper().StartsWith("FOLDOUT")
|
|
&& 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.
|
|
if (MyItemInfo.IsHigh && mySize >= (2 * SixLinesPerInch) && MyItemInfo.MyDocStyle.Layout.FooterLength > 0 && (MyItemInfo.MyDocStyle.End.Message == null || MyItemInfo.MyDocStyle.End.Message == "") && MyItemInfo.NextItemCount == 0 && (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.MyActiveSection.MyDocStyle.StructureStyle.Where & E_DocStyleUse.UseOnAllButFirstPage) > 0)
|
|
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);
|
|
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
|
|
//&& (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
|
|
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
|
|
BuildPageBreakList(ySpaceOnFirstPage, yPageSize + yExtra2, KeepStepsOnPage, yEndMsg, doSectionTitleContinued & SectionShowTitles, false); // 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);
|
|
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");
|
|
}
|
|
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 = 792;
|
|
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);
|
|
retval = Rtf2Pdf.TextAt(cb, IParagraph, XOffset, yLocation, Width, 100, DebugInfo, yBottomMargin);
|
|
}
|
|
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
|
|
);
|
|
}
|
|
// 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;
|
|
//if(MyItemInfo.InList(41955)) Console.WriteLine("Here");
|
|
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);
|
|
// 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:
|
|
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.PrintPhoneList && MyPageHelper.PhoneListHeight != 0)
|
|
myBottomMsgSpace += (MyPageHelper.PhoneListHeight - vlnPrintObject.SixLinesPerInch);
|
|
|
|
string myTopMsg = docstyle.Continue.Top.Message;
|
|
float myTopMsgSpace = ((myTopMsg ?? "") != "") ? 2 * 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
|
|
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;
|
|
if (PageBreakOnStepList.Count > 0 && (PageBreakOnStepList[0].YTop - (lastBreak == null ? 0 : lastBreak.YTop) <= ySpaceOnCurPage))
|
|
paraBreak = PageBreakOnStepList[0];
|
|
else
|
|
paraBreak = FindPageBreak(yStart, ySpaceOnCurPage - accountForCalvertAlarmConditionResponseFooter, yLowerLimit,
|
|
myList, lastBreak, yPageSize - (myTopMsgSpace + SixLinesPerInch) - myBottomMsgSpace,
|
|
myBottomMsgSpace, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[40].ContinueOnly);
|
|
// 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);
|
|
break;
|
|
}
|
|
//if (paraBreak.MyItemInfo.InList(54615, 54620) || MyItemInfo.InList(54573))
|
|
//{
|
|
// Console.WriteLine("{0}\t{1}", MyItemInfo.ItemID, paraBreak);
|
|
// Console.WriteLine("Here");
|
|
//}
|
|
if (paraBreak.MyItemInfo.IsStep && ((paraBreak.MyItemInfo.MyActiveSection.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);
|
|
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);
|
|
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);
|
|
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);
|
|
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;
|
|
if (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);
|
|
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;
|
|
|
|
// 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;
|
|
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);
|
|
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;
|
|
if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.PartialStepCompression)
|
|
{
|
|
float ySpaceAt7LPI = (ySpaceOnCurPage - (accountForCalvertAlarmConditionResponseFooter + yEndMsg)) * SixLinesPerInch / _SevenLinesPerInch;
|
|
if ((YSize - yTop) > (ySpaceOnCurPage - (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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
/// <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 FindPageBreak(float yStart, float yUpperLimit, float yLowerLimit, StepLevelList myList, vlnParagraph lastBreak, float fullPage,
|
|
float myBottomMsgSpace,bool RNOContinueOnly)
|
|
{
|
|
vlnParagraph minPara = null;
|
|
//StringBuilder minBuff = new StringBuilder();
|
|
float? yLocationMin=null;
|
|
vlnParagraph minPara2 = null;
|
|
float? yLocationMin2=null;
|
|
float yAddForBtmMsg = 0;
|
|
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)
|
|
{
|
|
//_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)
|
|
{
|
|
//_MyLog.WarnFormat("\r\nMyParentBreak {0},{1},{2},{3},{4}", myParent, myParent.YSize, yUpperLimit, myParent.ChildrenRight[0].YSize, spaceOnPage);
|
|
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));
|
|
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)
|
|
if ((-yLocation + yStart) >= yLowerLimit) // Only if it is more than the lower limit
|
|
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;
|
|
}
|
|
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)
|
|
if (yLocation == yLoc)
|
|
if (stepLevel > maxLevel)
|
|
{
|
|
vlnParagraph myPara = myList[stepLevel][yLoc];
|
|
//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 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
|
|
{
|
|
float retval = 0;
|
|
if(_ChildrenBelow!= null)
|
|
foreach (vlnParagraph pgh in _ChildrenBelow)
|
|
retval += pgh.TableSpaceAvailable;
|
|
if (MyGrid != null)
|
|
retval += MyGrid.SpaceAvailable;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
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; }
|
|
}
|
|
}
|
|
}
|