John
82e0e37c3f
Added call to AddPlantSpecificOverrideAfterInheritance() when processing main formats and added changes for McGuire and Catawba
5761 lines
282 KiB
C#
5761 lines
282 KiB
C#
using System;
|
||
using System.Windows.Forms;
|
||
using System.IO;
|
||
using System.Text;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Text.RegularExpressions;
|
||
using System.Runtime.Serialization.Formatters.Binary;
|
||
using System.Xml.Xsl;
|
||
using System.Xml;
|
||
using System.Xml.Serialization;
|
||
using System.ComponentModel;
|
||
|
||
#region StructDefinitions
|
||
// top of the format.
|
||
|
||
// convert ALL rows & columns to points, i.e. a point = 1/72 inch
|
||
// the row is set based on 6 rows per inch, i.e. row = input * 72/6, row = input * 12
|
||
// the column is 12 char/inch, i.e. col = input * 72/12, col = input * 6
|
||
[Serializable]
|
||
public struct FormatData
|
||
{
|
||
public string Name;
|
||
public string PurchaseOptions;
|
||
public string TPL;
|
||
//public XtraFlgs XtraFlags;
|
||
public VE_Font FontData;
|
||
public Symbol[] Symbols;
|
||
public GeneralEditor EditData;
|
||
public GeneralPrint PrintData;
|
||
public Procedure ProcData;
|
||
public Section SectData;
|
||
public Step[] StepData;
|
||
public Box[] BoxData;
|
||
public Trans TransData;
|
||
public RO ROData;
|
||
}
|
||
[Flags]
|
||
public enum E_PurchaseOptions : uint
|
||
{
|
||
ApproveOne = 0x0001,
|
||
AccPagination = 0x0002,
|
||
LibMaint = 0x0004,
|
||
Transfer = 0x0008,
|
||
STrees = 0x0010,
|
||
DateChgSumRpt = 0x0020,
|
||
SetpointUsage = 0x0040,
|
||
Replace = 0x0080,
|
||
FloppyTransfer = 0x0100,
|
||
ApproveGenericBack = 0x0200,
|
||
DistributeApproved = 0x0400,
|
||
OutsideTransitions = 0x0800,
|
||
EnhancedBackgrounds = 0x1000,
|
||
EnhancedDeviations = 0x2000,
|
||
AutoTableOfContents = 0x4000,
|
||
AutoPlacekeeper = 0x8000
|
||
}
|
||
[Serializable]
|
||
public struct XtraFlgs
|
||
{
|
||
#region xtraflags0
|
||
public string DoubleRNOSpace; // from xtra_flag array 0
|
||
public string MixCautionsAndNotes;
|
||
// public string MULTILEVELCAUTION; // not migrated used by: ano/bge/sum
|
||
public string AlwaysUseExtralines;
|
||
public string AlwaysTabNote;
|
||
public string AlwaysTabCaution;
|
||
// public string CHECKOFFEQUIPMENT; // not used by any format
|
||
public string SpecialPageBreakFlag;
|
||
// public string INSYNC; // not migraged used by: genplan & scedev
|
||
public string DontPaginateOnFirstSubStep;
|
||
// public string PRINTONESTEPPERPAGE; // not migrated used by: anos & genplan
|
||
public string ImperfectStructure;
|
||
public string DontUseHalfLines;
|
||
public string FortranFormatNumbers;
|
||
public string AllUnits;
|
||
public string CapsTransitions;
|
||
#endregion
|
||
#region xtraflags1
|
||
public string CapTranStep; // from xtra_flag array 1
|
||
// public string BOLDTRANSITIONS; // not migraged used by: ano1 & sum
|
||
public string TSTepNoFlag;
|
||
public string LowerCaseTranNumber;
|
||
//public string UNDERLINESTEPNUMBER // not migraged used by: cpla
|
||
public string CondensedChangeBar;
|
||
public string DoRevDate;
|
||
public string SeparateBox;
|
||
public string NumberHighLevelRNO;
|
||
// public string STUPIDBLANKRNONUMBERING; //not migrated used by: lpl
|
||
// public string BULLETINSTEADOFNUMBERRNO //not migrated used by: sce
|
||
// public string BIZZAREINDENTSAVE //not migrated used by: sce
|
||
public string AlternateFoldoutPages;
|
||
// public string ONLYEXTERNALBOLD; // not migrated pac & sce
|
||
//public string DONTSPLITTHESTEPATIF // not migrated used by: sce, vnp, vpe
|
||
public string DontTryToFillHalfOfPage;
|
||
#endregion
|
||
#region xtraflags2
|
||
public string DontCapitalizeTitle; // from xtra_flag array 2
|
||
// public string MOVEPARENSTOTOKEN // not migrated used by: scedev
|
||
public string NoSpaceDoubleRNO;
|
||
//public string SECTIONTITLES; // not used
|
||
public string DontOffsetTab;
|
||
public string UpSetpntAftrDash;
|
||
public string LowerCaseRevnum;
|
||
public string DoNotCompressSteps;
|
||
public string ReduceLineAfterNoteAndCaut;
|
||
public string RNOSameLevel;
|
||
//public string USENOTECAUTIONSEPARATOR; // not migrated: used in genplan
|
||
//public string TRUNCATEPROCNMAFTER1STSPACE // not migrated: used in paca & sce
|
||
//public string EXTRALINEBEFOREANDAFTERCAUT1 // not migrated: used in mya
|
||
public string BoldHighLevelRNO;
|
||
public string OneLineBeforeNoteCautionTab;
|
||
public string ContinuousChangeBars;
|
||
#endregion
|
||
#region xtraflags3 // from xtra_flag array 3
|
||
// public string DONTDOLINEAFTERENDMESS // not migrated: used in ano1
|
||
// public string ENDAFTERBOXEDSTEP // not migrated: used in ano1
|
||
// public string CheckOffOnAllSteps; // not migrated - NOT USED
|
||
// public string SPECIALCHANGEBARID // not migrated: used in sce
|
||
// public string STEPTABBEFORENOTEANDSTEP // not migrated: used in ano1
|
||
public string DontBoxAC;
|
||
//public string OKTOSEPARATESTEPANDTABLE; // no supporting code
|
||
public string UseTopContinueMessageAtEnd;
|
||
// public string ONLYUSEONELINEFORTOPOFPAGE; // not used
|
||
// public string ARROWONTRANS; // not migrated: used in mya
|
||
// public string PROCEEDMESS; // not migrated: used in mya
|
||
// public string UP1INDENTFOROPTEQUIPLIST; // not migrated: used in mya
|
||
// public string UPCASETHETRANSITIONSUBSTEPONLY; // not migrated: used in ano1, ano2
|
||
public string UpcaseTranAnd;
|
||
public string UpcaseAllSetpointUnits;
|
||
// public string OBSERVENOTECAUTIONTRAN; // not used
|
||
#endregion
|
||
#region xtraflags4
|
||
public string Dev_Format; // from xtra_flag array 4
|
||
// public string UPURS; // not migrated: used in yae
|
||
public string DontDoSTExtraAtTop;
|
||
public string Xlines_StepFix;
|
||
public string ReBoxCautNote;
|
||
public string IMMStepSpcHdr;
|
||
// public string GENLESSONPLAN; // not migrated: used in genplan
|
||
public string FloatingContinueMessage;
|
||
// public string STATREESONACCPAGE; // not migrated: used in status tress (lots of formats)
|
||
public string AbsoluteFixedChangeColumn;
|
||
// public string QUESTIONTRANSSTEP; // not migrated: used in sce
|
||
public string LJBorderlessTable;
|
||
public string SuppressAndInTran;
|
||
public string CapHighSetpnt;
|
||
public string CapFirstLetterInHighSP; // used in fpl
|
||
public string CapsPIFLastLower;
|
||
#endregion
|
||
#region xtraflags5
|
||
public string AlternateFloatingFoldout; // from xtra_flag array 5
|
||
public string WrapSameAsEdit;
|
||
public string KeepStepsOnPage;
|
||
public string SpecifiedSubstepsOnly;
|
||
public string ThreeBlanksAboveNotesCautions;
|
||
// public string DONTADDUNITTOREV // not migrated: used in paca
|
||
public string ImperfectSubstep;
|
||
public string DontBreakOnSections;
|
||
public string NoStepNumIfOnlyOneStep;
|
||
public string ShowSectionTitles;
|
||
public string LJTabs;
|
||
public string DontNumberRNOSubs;
|
||
// public string ALIGNNOTECAUTWTAB // not used
|
||
// public string RNOCONTINUESTEP // not migrated: used in sum
|
||
public string DropCheckOff;
|
||
public string NoCheckOffsInRNO;
|
||
#endregion
|
||
#region xtraflags6
|
||
// from xtra_flag array 6
|
||
public string ChgBarMessageFromEdit;
|
||
public string ChangeBarToRNOSep;
|
||
// public string SMALLACBOX // not migrated: used in lpl
|
||
public string ChangeStyleForEverySection;
|
||
public string SectionLevelFoldouts;
|
||
public string BoxContinousActions;
|
||
public string DoSectionTrans;
|
||
// public string DONTUSESECNUMBERS // not used
|
||
public string UpSpIfPrevUpper;
|
||
public string ContinueSectionHeader;
|
||
public string GlobalProcInfo;
|
||
public string CompressHPSub;
|
||
public string BulletOnContinuous;
|
||
public string CancelSecTitlesOnS2;
|
||
public string NoEndForSingle;
|
||
public string UseMetaSections;
|
||
#endregion
|
||
#region xtraflags7
|
||
public string RNOContinueOnly; // from xtra_flag array 7
|
||
public string Cap1stCharTrans;
|
||
public string DontPaginateOnFirstSubstep3X;
|
||
public string RNOSepAfterAER;
|
||
public string RevDateWithForwardSlash;
|
||
// public string UPSETPNTAFTRCAPS // not migrated: used in sum
|
||
public string UseAlternateStepBox;
|
||
public string CancelSecTitlesOnS1;
|
||
public string SpecialStepsFoldout;
|
||
public string UnderlineAfterDashSpace;
|
||
public string NoSpaceInNoteOrCaution;
|
||
public string UseXtraRevNumber;
|
||
public string UnderlineSetpoints;
|
||
public string DoSectionTransTypeB;
|
||
public string PaginateOnLowerStepLevel;
|
||
public string UseTransitionModifier;
|
||
#endregion
|
||
#region xtraflags8
|
||
public string CustomSpacing; // from xtra_flag array 8
|
||
public string EnhancedShortFormDev;
|
||
// public string NOHIGHLEVELREADONLY; // no supporting code
|
||
// public string NORNOREADONLY // not used
|
||
public string PageBreakOnHighLevelStep;
|
||
// public string CHANGEONLYGROUPEDTYPES // not used
|
||
public string PageBreakOnCautions;
|
||
public string PageBreakOnNotes;
|
||
public string AlignNullTabWSectHead;
|
||
public string DontUseSecTitles;
|
||
public string TextSubFollowsTextStyle;
|
||
public string TranProcTitleInParen;
|
||
public string HardSpTranProcNumb;
|
||
public string TreatAndOrAsSequential;
|
||
public string DontSplitStepInPrntStep;
|
||
public string LineAboveUnderSection;
|
||
#endregion
|
||
#region xtraflags9
|
||
// public string REMOVEREDUNDANTSEPERATORS // from xtra_flag array 9 // not used
|
||
// public string UNINDENTTABSANDSEPERATORS // not migrated: used in bgeal bgealn bgevl
|
||
public string PicaIgnoreFiveSixths;
|
||
public string SpaceFoRNOSecNumb;
|
||
public string NonEditableSteps;
|
||
public string BoxedSubsteps;
|
||
public string DontNumberHighLevelSteps;
|
||
// public string ASTERISKONIMMEDIATE // not migrated: used in a number of bge fmts
|
||
// public string CONTINUEAFTERSTEPTEXT // not used
|
||
// public string FIXPAGELISTSPECIALCHARS // not migrated: used in a number of bge fmts
|
||
public string NoStepNumberForHighLevelRNO;
|
||
public string PromptForCautinType;
|
||
public string Caution1SameRowAsParent;
|
||
//public string DONTPAGINATEONCAUTION1; // no supporting code
|
||
public string WolfCreekBackgroundFormat;
|
||
public string EnhancedStepNumFromPrev;
|
||
#endregion
|
||
#region xtraflags10
|
||
public string ControlUnderlineStyle; // from xtra_flag array 10
|
||
// public string LANDSCAPEMODE // not used
|
||
// public string HORIZONTALSUBSTEPS // not migrated: used in ano2vlv & bgevl
|
||
public string MultipleChangeIds;
|
||
public string UseMultiLineSectionTitle;
|
||
// public string SECTIONNOTESCAUTIONS // not migrated: used in anono & various bge
|
||
public string PageBreakOnFirstBlankLine;
|
||
public string DontPrintNoTitle;
|
||
// public string PRINTCAUTION1CONTINUED // not migrated: used in bgeal
|
||
// public string USECHECKOFFSINS2 // not used
|
||
public string NotesToFootnotes; // used in ano2vlv, some bge, many rbnd, NSPF00.in
|
||
public string UndSpecialStepsFoldout;
|
||
// public string DONTAUTOENDFORMATTING // not migrated: used in various bge
|
||
// public string REMOVEBASISFROMTRANS // not migrated: used in various bge
|
||
public string PutOnPageByItself;
|
||
// public string USEPHONELIST // not migrated: used in bge
|
||
#endregion
|
||
#region xtraflags11
|
||
public string SecTitleContinue; // from xtra_flag array 11
|
||
public string CancelSecTitlesOnE0;
|
||
public string MetaSectEndMessage;
|
||
// public string RNONUMBERWITHLEVEL // not migrated: used in bgeeop
|
||
// public string FORCELETTEREDHLS // not migrated: used in bgestp
|
||
// public string CANCELSECTITLESONE1 // not migrated: used in bgeoid
|
||
public string CancelSecTitlesOnE2;
|
||
// public string USESECTITLECONTASIS // not used
|
||
// public string SMARTLETTEREDHLS // not migrated: used in various bge
|
||
// public string DOTWOMESSAGES // not migrated: used in bgeeop
|
||
// public string DONTBOLDINTABLES // not migrated: used in bgestp
|
||
// public string EXTRALINEAFTERSECTION // not migrated: used in bgestp
|
||
// public string BGESTPSPECIALFEAT // not migrated: used in bgestp
|
||
public string CompressHPSuper;
|
||
// public string PRETENDNOTPROPORTIONAL // not used
|
||
// public string DOINGPLACEKEEPERS // not used
|
||
#endregion
|
||
#region xtraflags12
|
||
public string MatchUpRNOCautNote; // from xtra_flag array 12
|
||
// public string NEWHLSTEPONENTER // not migrated: used in bgevl
|
||
// public string DONTSEPARATEMULTITEXT // not migrated: used in bgeop
|
||
public string PaginateAtHighestPaginLevel;
|
||
// public string DONTRESETINDENTONNEWLINE // not migrated: used in anonop & various bge
|
||
// public string CONTINUEMESSONNEXTLINE // not migrated: used in anoann
|
||
// public string CAP1STSECTIONTITLE // not migrated: used in anono
|
||
// public string DOUBLESPACEHLS // not migrated: used in anoann
|
||
public string UseLongProcTitles;
|
||
// public string INCLUDENOTEINPLACKEEP // not migrated: used in bgeeop
|
||
// public string OUTTRANTOSECTIONSTEP // not used
|
||
// public string ANOANNUNCIATORS // not migrated: used in anoann
|
||
public string SpecialLandscapeMode;
|
||
public string RNOInPagelist;
|
||
public string StpCautNoteTabInPagelist;
|
||
public string ReadOnlyTypeInContMsg;
|
||
#endregion
|
||
#region xtraflags13
|
||
public string CenterOneLineOnly; // from xtra_flag array 13
|
||
public string TieTabToLevel;
|
||
// public string LEFTJUSTIMMEDIATE // not migrated: used in anoann
|
||
public string AccessoryDocsInDuplex;
|
||
public string FoldoutsInDuplex;
|
||
// public string ABPAGE // not migrated: used in various ano
|
||
public string UseSTExtraRealValue;
|
||
public string SubTableGetSup1Level;
|
||
// public string DONTNUMBERNOTECAUT1 // not migrated: used in anonop
|
||
public string DontCountFoldoutPages;
|
||
// public string ANONOPHACKS // not migrated: used in anonop
|
||
// public string FLOATSECNUMPOS // not migrated: used in bgeoi bgestp
|
||
public string SearchAllReplaceWords;
|
||
// public string CALVERTCLIFFSFORMATS // not migrated: used in various bge
|
||
// public string NOSTUPIDSUBLOGIC // not migrated: used in anonop
|
||
// public string REMEMBERRNOSTEP // not migrated: used in bgeeop, rbndan, rbnd
|
||
#endregion
|
||
#region xtraflags14
|
||
public string RememberCautionsAndNotes; // from xtra_flag array 14
|
||
// public string PUTONPAGEAFTERHALFPAGE // not migrated: used in anonop
|
||
// public string FLOATINGSTEPS // not migrated: used in anonop
|
||
public string RtfAdjustments;
|
||
public string CenterOneLineAdjust;
|
||
public string CountAllSubLevels;
|
||
// public string AERCHGBARMSGRNOCHGBARNOMSG // not migrated: used in nae
|
||
public string DontReplaceWordsInROs;
|
||
public string HighLevelRNOBeforeAERSubStps;
|
||
public string UnderlineAllMetaTitles;
|
||
public string DontBreakCautionsOrNotes;
|
||
public string BoldOnlySectionZero;
|
||
public string DontBreakOnRNO;
|
||
public string RNOCheckOffSameAsParent;
|
||
public string UseStepTypeWidthOverride;
|
||
public string WolfcreekCKLFormat;
|
||
#endregion
|
||
#region xtraflags15
|
||
public string DontPaginateOnFirstSubStep2X; // from xtra_flag array 15
|
||
public string UseStepTypeWidthOverrideEditPrint;
|
||
public string PartialStepCompression;
|
||
public string UseSmartTemplate;
|
||
public string CheckoffOnHLSOnly;
|
||
// public string KEEPCHANGEIDFORCOPYSTEP // not migrated: used in various ANO
|
||
// public string RNOBELOWCHECKOFF // not migrated: used in various RBND
|
||
public string Caution2SameRowAsParent;
|
||
// public string DONTUNDERLINEMETATITLES // not migrated: used in various RBND
|
||
public string CenterTextWithinWidth;
|
||
public string DontBreakEquipmentList;
|
||
// public string USELOCALTEMPLATEFILE // not migrated: used in various RBND
|
||
public string AlwaysTabCaution2;
|
||
public string VirtualDotInHLSTab;
|
||
public string ImperfectStructurePlus4;
|
||
// public string RIVERBENDVALVESHEETS // not migrated: used in various RBND
|
||
#endregion
|
||
#region xtraflags16
|
||
// public string RIVERBENDPUMPDATASHEET // from xtra_flag array 16 -not migrated: used in various RBND
|
||
public string UseRNOTypeInActable;
|
||
public string AbsoluteTransitionUpdate;
|
||
public string SeparateBoxCautions;
|
||
// public string RIVERBENDALARMFORMAT // not migrated: used in RBNDAN
|
||
public string HLSTextInPagelist;
|
||
// public string HLSCAUT2INPAGELIST // not migrated: used in RBNDAN
|
||
public string LowerCaseStepInTran;
|
||
// public string DONTCHANGELOWERLIMIT // not migrated: used in BGEALN PAC
|
||
// public string UPPERCASESECTIONTITLE // not migrated: used in various RBND
|
||
//public string ALGNCOMPRESSSUPERTABLE; // not migrated: no supporting code.
|
||
// public string RIVERBENDLINEUPFORMAT // not migrated: used in various RBND
|
||
public string ChangeBarsOnLinkedText;
|
||
public string QuotedSubsteps;
|
||
// public string PROPOVERFLOWLETITHANG // not migrated: used in BGEEOP
|
||
// public string TURKEYPOINTBACKGNDFORMAT // not migrated: used in FPLBCK
|
||
#endregion
|
||
#region xtraflags17
|
||
// public string DRAWCENTERLINE // from xtra_flag array 17 -not migrated: used in BGEEOP
|
||
// public string DOVALVEDIVIDER // not migrated: used in ANO2VLV
|
||
// public string DOSECTIONOVERUNDERSTRING // not migrated: used in bgeeop, bgevl
|
||
public string OverrideEnhancedTabs;
|
||
// public string USEREALCOMPRESSED7LPI // not used
|
||
public string NoNewlineAfterRNO;
|
||
public string DoSectionSeparatorLine;
|
||
public string ParensOnExtPagenumTrans;
|
||
public string AtLeastTwoDigitsForHLS;
|
||
public string DontBreakOptEquipmentList;
|
||
public string PagelistChangeIDsWithCommas;
|
||
public string DontStartLineWithDash;
|
||
public string NoBlankLineBeforeSubstep;
|
||
public string DontBreakCautionsNotesOnSubstps;
|
||
public string DontConvertCaretToDelta; // handled in data migration
|
||
#endregion
|
||
#region xtraflags18
|
||
// this was original veairflag, but an extra array element was added to the xtraflags,
|
||
// xtraflags[18], since some of the flags were used in other formats.
|
||
// public string NOTEAFTERAPPLIEDTEXT // from xtra_flag array 18 -not migrated: used in ata
|
||
public string NoRNO;
|
||
// public string ALTWFORWARNINGS // not migrated: used in ata, some bge & some rbnd
|
||
public string OnlySingleColumn;
|
||
public string NullBox; // used in bgeeop and NSP
|
||
public string XChngTranSpForHard;
|
||
public string WolfcreekCKLBackgndFormat;
|
||
#endregion
|
||
}
|
||
[Serializable]
|
||
public struct Symbol
|
||
{
|
||
public string Unicode;
|
||
public string Desc;
|
||
}
|
||
[Serializable]
|
||
public struct GeneralEditor
|
||
{
|
||
public string EMode;
|
||
/* Format Flags */
|
||
public string PromptForCautionType;
|
||
/* End of format flags */
|
||
}
|
||
[Serializable]
|
||
public struct GeneralPrint
|
||
{
|
||
public Int16 DoPrnDrvrAdjusts;
|
||
public string TopOfPageThing;
|
||
/* Format flags moved to here.... */
|
||
public string DoRevDate;
|
||
public string AlternateFoldoutPages;
|
||
public string AlternateFloatingFoldout;
|
||
public string SectionLevelFoldouts;
|
||
public string RevDateWithForwardSlash;
|
||
//public string SpecialStepsFoldout;
|
||
// Added AllowDuplex to eliminate hardcoded check for WEP2 and WPB formats
|
||
// for the Disable Automatic Duplexing
|
||
public string AllowDuplex;
|
||
public string AccessoryDocsInDuplex;
|
||
public string FoldoutsInDuplex;
|
||
public string PagelistChangeIDsWithCommas;
|
||
/* end Format flags */
|
||
public ProcDescr [] ProcDescrList;
|
||
public string[] VersionIdText;
|
||
public string DuplexBGDirectory; // this may go away??
|
||
public string DuplexDDDirectory; // " "
|
||
}
|
||
[Serializable]
|
||
public struct ProcDescr
|
||
{
|
||
public string MatchProcNumber;
|
||
public string ProcDescr1;
|
||
public string ProcDescr2;
|
||
}
|
||
//[Serializable]
|
||
//public struct GeneralLayout // no data in this category. Comment out
|
||
//{ // in case later some data moves to here.
|
||
|
||
//}
|
||
[Serializable]
|
||
public struct Procedure
|
||
{
|
||
public Int16 TitleLength;
|
||
public Int16 CoverTitleLength;
|
||
public string ProcForeColor;
|
||
public string ProcBackColor;
|
||
public string ProcedureSuffixFlags;
|
||
/* Format flags moved to here.... */
|
||
public string CapitalizeTitle;
|
||
public string ChangeStyleForEverySection;
|
||
public string PrintNoTitle;
|
||
public string NotesToFootnotes;
|
||
public string CountFoldoutPages;
|
||
/* End of Format flags */
|
||
public string[] ProcedureSuffix;
|
||
public PSI Psi;
|
||
public ChangeBar ChangeBarData;
|
||
public CheckOffData CheckOffData;
|
||
}
|
||
[Serializable]
|
||
public struct PSI
|
||
{
|
||
public int x;
|
||
public int y;
|
||
public string Caption;
|
||
public string ButtonsOnBottom;
|
||
public string font;
|
||
public PsiBox[] Boxes;
|
||
public PsiLabel[] Labels;
|
||
public PsiField[] Fields;
|
||
}
|
||
[Serializable]
|
||
public struct PsiBox
|
||
{
|
||
public string style;
|
||
public int x;
|
||
public int y;
|
||
public int width;
|
||
public int height;
|
||
}
|
||
[Serializable]
|
||
public struct PsiLabel
|
||
{
|
||
public string text;
|
||
public string Justify;
|
||
public int x;
|
||
public int y;
|
||
public int width;
|
||
public int height;
|
||
}
|
||
[Serializable]
|
||
public struct PsiField
|
||
{
|
||
public string name;
|
||
public string type;
|
||
public string text;
|
||
public int Length;
|
||
public int x;
|
||
public int y;
|
||
public int width;
|
||
public int height;
|
||
}
|
||
[Serializable]
|
||
public struct CheckOffData
|
||
{
|
||
public string Menu;
|
||
public string AllowSectEdit;
|
||
public string AllowStepEdit;
|
||
public int UseCheckOffsIn;
|
||
public float CheckOffAdjustment;
|
||
public float XLocation;
|
||
//for VCSummer by jcb
|
||
public float RelXLocation;
|
||
//end for VCSummer by jcb
|
||
/* Format flags ... */
|
||
public string DropCheckOff;
|
||
public string CheckOffOnHLSOnly;
|
||
public string SkipSpaces;
|
||
/* end of format flags */
|
||
//public RightCheckOffBx [] RightCheckOffBoxList;
|
||
public Absolute [] LayoutList;
|
||
public CheckOffHeader[] CheckOffHeaderList;
|
||
public CheckOff [] CheckOffList;
|
||
}
|
||
//[Serializable]
|
||
//public struct RightCheckOffBx
|
||
//{
|
||
// public int Index;
|
||
// public int RightCheckOffBox;
|
||
//}
|
||
[Serializable]
|
||
public struct Absolute
|
||
{
|
||
public string RnoLevel;
|
||
public int Column;
|
||
}
|
||
[Serializable]
|
||
public struct CheckOffHeader
|
||
{
|
||
public int Index;
|
||
public string CheckOffHeading;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct CheckOff
|
||
{
|
||
public int Index;
|
||
public byte UIMark;
|
||
public string MenuItem;
|
||
public string ExcludeInSectMenu;
|
||
public string NotOnEmpty;
|
||
public string Macro;
|
||
public float CheckOffWidAdjust;
|
||
public int CheckOffXtraLines;
|
||
}
|
||
[Serializable]
|
||
public struct ChangeBar
|
||
{
|
||
public string DefaultCBLoc;
|
||
public string ChangeBarMessage;
|
||
public Int16 FixedChangeColumn; // really flags not columns (don't convert to points
|
||
public Int16 FixedAERChangeColumn;
|
||
public long ChangeSummaryStyle; // not really change bar - put here for now.
|
||
public long ChangeBarStyle;
|
||
public string SpecialChangeBar;
|
||
/* Format flags moved to here.... */
|
||
public string CondensedChangeBar;
|
||
public string AbsoluteFixedChangeColumn;
|
||
public string ContinuousChangeBars;
|
||
public string ChgBarMessageFromEdit;
|
||
public string MultipleChangeIds;
|
||
public string ChangeBarToRNOSep;
|
||
public string ChangeBarsOnLinkedText;
|
||
/* End of Format flags */
|
||
}
|
||
[Flags]
|
||
public enum E_ChangeBarMessage : uint
|
||
{
|
||
DateChgID = 0,
|
||
RevNum = 1,
|
||
ChgID = 2,
|
||
None = 3
|
||
}
|
||
[Flags]
|
||
public enum E_EMode : uint
|
||
{
|
||
Insert = 0,
|
||
Override = 1
|
||
}
|
||
[Serializable]
|
||
public struct Section
|
||
{
|
||
public Int16 SectionTitleLength;
|
||
public string SectForeColor;
|
||
public string SectBackColor;
|
||
/* Format Flags moved here... */
|
||
//public string CancelSecTitlesOnS1; // moved to docstyle
|
||
//public string CancelSecTitlesOnS2;
|
||
//public string CancelSecTitlesOnE0;
|
||
//public string CancelSecTitlesOnE2;
|
||
public string MetaSectEndMessage;
|
||
public string ReadOnlyTypeInContMsg;
|
||
public string ReplaceWordsInROs;
|
||
public string UseMetaSections;
|
||
public string NonEditableSteps;
|
||
public string SearchAllReplaceWords;
|
||
public string SecTitleContinue;
|
||
public string ConvertCaretToDelta;
|
||
public string TurnOffReplaceWords;
|
||
/* end of Format flags */
|
||
public SectionNum SectionNumber;
|
||
public SectionHead SectionHeader;
|
||
public StepSection StepSectionData;
|
||
public AccSection AccSectionData;
|
||
public MetaSection [] MetaSectionData;
|
||
public ReplaceStr[] ReplaceStrData;
|
||
|
||
}
|
||
[Serializable]
|
||
public struct SectionNum
|
||
{
|
||
public float Pos;
|
||
public string Just;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct SectionHead
|
||
{
|
||
public float Pos;
|
||
public string Just;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct StepSection
|
||
{
|
||
public Int16 TopRow;
|
||
public byte IndentToken;
|
||
public Int16 NumberOfHighLevelSteps;
|
||
public Int16 NumberOfSubStepTypes;
|
||
//public Int16[] TextTypeValue;
|
||
//public string[] TextType;
|
||
public string IdentB;
|
||
public string[] UnderlineTerminate;
|
||
public string [] ObserveNCString1;
|
||
public string[] ObserveNCString2;
|
||
/* Format flags moved to here.... */
|
||
public string WolfCreekBackgroundFormat;
|
||
public string WolfcreekCKLFormat;
|
||
public string WolfcreekCKLBackgndFormat;
|
||
public string FortranFormatNumbers;
|
||
public string UseTopContinueMessageAtEnd;
|
||
public string FloatingContinueMessage;
|
||
public string WrapSameAsEdit;
|
||
public string ContinueSectionHeader;
|
||
public string CompressHPSub;
|
||
public string CompressHPSuper;
|
||
//public string UndSpecialStepsFoldout;
|
||
public string UnderlineAllMetaTitles;
|
||
public string BoldOnlySectionZero;
|
||
public string ImperfectStructure;
|
||
public string ImperfectSubstep;
|
||
public string ImperfectStructurePlus4;
|
||
public string CountAllSubLevels;
|
||
public string UseMultiLineSectionTitle; // Need for data migration only
|
||
/* end of Format flags */
|
||
public StepSectionLayout StpSectLayData;
|
||
public StepSectionEdit StpSectEditData;
|
||
public StepSectionPrint StpSectPrtData;
|
||
public SeqTabFmt[] SequentialTabFormat;
|
||
}
|
||
[Serializable]
|
||
public struct AccSection
|
||
{
|
||
public int AutoContActSumSection;
|
||
public TOC TableOfContentsData;
|
||
}
|
||
[Serializable]
|
||
public struct TOC
|
||
{
|
||
public float TofCSecNumPos;
|
||
public float TofCSecTitlePos;
|
||
public byte TofCSecTitleLen;
|
||
public float TofCPageNumPos;
|
||
public string TofCSpaceChar;
|
||
public byte TofCLineSpacing;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct MetaSection
|
||
{
|
||
public int Index; // do I need this to order them or will SecNumPositionAdj work?
|
||
public float SecNumPositionAdj;
|
||
public float SecTitlePositionAdj;
|
||
public float ColSByLevel;
|
||
public float TofCPositionAdj;
|
||
public float WidSAdjByLevel;
|
||
}
|
||
[Serializable]
|
||
public struct StepSectionLayout
|
||
{
|
||
public float LastLineToStartStep;
|
||
public Int16 LineDrawingOption;
|
||
public float ColS;
|
||
public float ColT;
|
||
public float ColAbs;
|
||
public float WidT;
|
||
public Int16 PMode;
|
||
public Int16 MaxRNO;
|
||
public string MaxRNOTable;
|
||
public string ColRTable;
|
||
public string WidSTableEdit;
|
||
public string WidSTablePrint;
|
||
public float AdjRNOCol;
|
||
public Int16 EndMessagePos;
|
||
public string RNOWidthAlt;
|
||
public Int16 HLSWidthOVRD;
|
||
public Int16 SubPaginationWght;
|
||
public Int16 TextTitleAdjustment;
|
||
public string TableCenterPos; // string array with floats.
|
||
public string LowerLimitDivisor; // pagination - should it be in print? - 16bit: quoted float
|
||
public string NonLinkedStepNumber;
|
||
public string NonLinkedCautNoteNumber;
|
||
public string NonLinkedRNONumber;
|
||
//for VCSummer by jcb
|
||
public float SingleColumnRNOIndent;
|
||
public bool RNOWidthSameAsHighParent;
|
||
//end for VCSummer by jcb
|
||
|
||
/* Format flags moved to here.... */
|
||
public string Dev_Format;
|
||
public string EnhancedShortFormDev;
|
||
public string SpecialPageBreakFlag;
|
||
public string PaginateOnFirstSubstep;
|
||
public string PaginateOnFirstSubstep2X;
|
||
public string UseHalfLines;
|
||
public string TryToFillHalfOfPage;
|
||
public string CompressSteps;
|
||
public string DoSTExtraAtTop;
|
||
public string KeepStepsOnPage;
|
||
public string BreakOnSections;
|
||
public string ShowSectionTitles;
|
||
public string EndForSingle;
|
||
public string PaginateOnFirstSubstep3X;
|
||
public string PaginateOnLowerStepLevel;
|
||
public string CustomSpacing;
|
||
public string SplitStepInPrntStep;
|
||
public string LineAboveUnderSection;
|
||
public string PicaIgnoreFiveSixths;
|
||
public string SpaceForNoSecNumb;
|
||
public string PageBreakOnFirstBlankLine;
|
||
public string PutOnPageByItself;
|
||
public string PaginateAtHighestPaginLevel;
|
||
public string UseSTExtraRealValue;
|
||
public string DoSectionSeparatorLine;
|
||
public string TieTabToLevel;
|
||
public string HighLevelRNOBeforeAERSubsteps;
|
||
public string UseStepTypeWidthOverride;
|
||
public string UseStepTypeWidthOverrideEditPrint;
|
||
public string PartialStepCompression;
|
||
public string VirtualDotInHLSTab;
|
||
public string OverrideEnhancedTabs;
|
||
public string RNO;
|
||
public string OnlySingleColumn;
|
||
public string NullBox;
|
||
/* End of format flags */
|
||
public VE_Font VertStyle;
|
||
public TopOfPg TopOfPage;
|
||
public Separtr Separator;
|
||
}
|
||
[Serializable]
|
||
public struct TopOfPg
|
||
{
|
||
public float Row;
|
||
public float Col;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct Separtr
|
||
{
|
||
public Int16 SeparatorLocation;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct StepSectionEdit
|
||
{
|
||
public float ColSScreenAdj;
|
||
public float ScrnAdjRNOText;
|
||
public string ColRScreen;
|
||
}
|
||
[Serializable]
|
||
public struct SeqTabFmt
|
||
{
|
||
public int Index;
|
||
public string TabToken;
|
||
public string TabFormat;
|
||
public string PrintTabFormat;
|
||
}
|
||
[Serializable]
|
||
public struct StepSectionPrint
|
||
{
|
||
public float ImmStepHdrCol;
|
||
public Int16 SecColHdrforActPMode;
|
||
public string RNOSepString;
|
||
public float RNOSepLineLength;
|
||
public string HLStpSeparatorString;
|
||
public string HLRNOStpSeparatorString;
|
||
/* Format flags moved to here.... */
|
||
public string LowerCaseRevNum;
|
||
public string UseXtraRevNumber;
|
||
public string SpecialLandscapeMode;
|
||
/* End of format flags */
|
||
public VE_Font ModifiedTextStyle;
|
||
public VE_Font ImmStepHdrStyle;
|
||
public LeftJustify[] LeftJustifyList;
|
||
public string[] ImmStepHdr;
|
||
}
|
||
[Serializable]
|
||
public struct LeftJustify
|
||
{
|
||
public int Index;
|
||
public float Size;
|
||
}
|
||
[Serializable]
|
||
public struct ReplaceStr
|
||
{
|
||
public string Flag;
|
||
public string ReplaceWord;
|
||
public string ReplaceWith;
|
||
}
|
||
[Flags]
|
||
public enum E_ReplaceStr : uint
|
||
{
|
||
High =0x0001, // Do ReplaceWords in HIGH LEVEL STEPS
|
||
RNO =0x0002, // Do ReplaceWords in RNOS
|
||
Caution =0x0004, // Do ReplaceWords in CAUTIONS
|
||
Note =0x0008, // Do ReplaceWords in NOTES
|
||
Table =0x0010, // Do ReplaceWords in TABLES
|
||
Substep =0x0020, // Do ReplaceWords in SUBSTEPS
|
||
Attach =0x0040, // Do ReplaceWords in ATTACHMENTS
|
||
Bkgd =0x0080, // Do ReplaceWords in BACKGROUNDS
|
||
DiffUnit =0x0100, // Do ReplaceWords ONLY for different UNIT #
|
||
TOC =0x0200, // Do in auto table-of-contents
|
||
StatTree =0x0400,
|
||
HLSSetpnt =0x0800, // Do ReplaceWords in HighLevelStep SETPoiNTs
|
||
Trans =0x1000, // Do ReplaceWords in TRANSITIONS
|
||
Setpoint =0x2000, // Do ReplaceWords in SETPOINTS
|
||
|
||
// Case Sensitivity Flags - default is off (Case Sensitive Replace)
|
||
CaseInsens =0x0000C000, // Do ReplaceWords for all words thatmatch, regardless of case,
|
||
// and replace with the ReplaceWith string as is
|
||
CaseInsensFirst = 0x4000, // Do ReplaceWords for all words thatexactly match the ReplaceWord,
|
||
// except the case of the first character may be different
|
||
CaseInsensAll = 0x8000, // Do ReplaceWords for all words that match the ReplaceWord, regardless of case
|
||
|
||
Partials =0x10000, // Do replace even on partial matches
|
||
Plackeep =0x20000, // Do replace in PlaceKeepers
|
||
InSecTitle =0x40000 // replace words in section titles
|
||
}
|
||
// all Step variables are strings here so that inheritance check for step variables can be done.
|
||
// Some will have float/integer values and should be treated as such in format code in Proms code.
|
||
[Serializable]
|
||
public struct Step
|
||
{
|
||
public int Index;
|
||
public string Type;
|
||
public string ParentType;
|
||
public string ReadOnly;
|
||
public string Inactive;
|
||
public string ColOverride;
|
||
public string ColOverrideEdit;
|
||
public string WidthOverride;
|
||
public string WidthOverrideEdit;
|
||
public string Sep;
|
||
public string Prefix;
|
||
public string Suffix;
|
||
public string UnderlineTheseChar;
|
||
public string VertPos;
|
||
/* the following are xtraflags that have been moved, string is set to true if plant has flag */
|
||
/* Flag name is listed as comment after each if different than name (change is made if generically used. */
|
||
public string DoubleSpace; //DoubleRNOSpace
|
||
public string EnhancedStepNumFromPrev;
|
||
public string UseSmartTemplate;
|
||
public string AlwaysUseExtraLines;
|
||
public string SeparateBox;
|
||
public string SeparateBoxCautions;
|
||
public string SpaceDouble; // NoSpaceDoubleRNO
|
||
public string ReduceLineAfter; // ReduceLineAfterNoteAndCaut
|
||
public string SameLevel; // RNOSameLevel
|
||
public string BoldHighLevel; // BoldHighLevelRNO
|
||
public string OneLineBeforeTab; // OneLineBeforeNoteCautionTab
|
||
public string BoxIt; // DontBoxAC
|
||
public string Boxed; // BoxContinuousActions, BoxedSubsteps
|
||
public string XLines_StepFix;
|
||
public string Rebox; // ReboxCautNote
|
||
public string SpcHdr; // ImmStepSpcHdr
|
||
public string ContinueOnly; // RNOContinueOnly
|
||
public string SepAfterAER; // RNOSepAfterAER
|
||
public string UseAlternateStepBox;
|
||
public string UnderlineAfterDashSpace;
|
||
public string SpaceIn; // NoSpaceInNoteOrCaution
|
||
public string PageBreakOnStep; // PageBreakOnHighLevelStep, PageBreakOnCautions, PageBreakOnNotes
|
||
public string UseOldTemplate;
|
||
public string AlignNullTabWSectHead;
|
||
public string AlignHLSTabWithSectOvride;
|
||
public string TextSubFollowsTextStyle;
|
||
public string CautionOrNoteSubstepIndent;
|
||
public string TreatAsSequential; // TreatAND_ORasSequential
|
||
public string MatchUpRNO; // MatchUpRNOCautNote
|
||
public string InPageList; // RNOInPageList, StpCautNoteTabInPageList, HLSTextInPageList
|
||
public string CenterOneLineOnly;
|
||
public string SubTableGetsUp1Level;
|
||
public string Remember; // RememberCautionsAndNotes
|
||
public string CenterOneLineAdjust;
|
||
public string Break; // DontBreakCautionsOrNotes, DontBreakOnRNO, DontBreakOptEquiptmentList
|
||
public string BreakEquipmentList; // Need this one as separate from above because differentiate between DontBreakOptEquiptmentList
|
||
public string BreakCautionsNotesOnSubstps;
|
||
public string CenterTextWithinWidth;
|
||
public string NewlineAfter; // NoNewlineAfterRNO
|
||
public string StartLineWithDash;
|
||
public string BlankLineBeforeSubStep;
|
||
public string AlwaysTab; // AlwaysTabNote, AlwaysTabCaution, AlwaysTabCaution2
|
||
//for Comanche Peak by jcb
|
||
public bool NoSpaceMultipleRNOs;
|
||
//end for Comanche Peak by jcb
|
||
public string MixCautionsAndNotes;
|
||
public string NumberHighLevel; // NumberHighLevelRNO
|
||
public string OffsetTab;
|
||
public string AdjHighLevelTab; // Added for FNP - high level RNO
|
||
public string ChildIndent; // Added for Callaway Backgrounds
|
||
public string LeftJustifyBorderless; // LJBorderlessTable
|
||
public string StepNumIfOnlyOne; // NoStepNumIfOnlyOneStep
|
||
public string LJTabs;
|
||
public string NumberSubs; // DontNumberRNOSubs
|
||
public string BulletOnContinuous; // BulletOnContinuous
|
||
public string StepNumberForHighLevel; // NoStepNumberForHighLevelRNO
|
||
public string SameRowAsParent; // Caution1SameRowAsParent, Caution2SameRowAsParent
|
||
public string CheckoffSameAsParent; // RNOCheckoffSameAsParent
|
||
public string AtLeastTwoDigits; // AtLeastTwoDigitsForHLS
|
||
public string UseInAcTable; // UseRNOTypeInAcTable
|
||
public string Number; // DontNumberHighLevelSteps
|
||
public string ThreeBlanksAbove; // ThreeBlanksAboveNotesCautions
|
||
public string CheckOffs; // NoCheckOffsInRNO
|
||
public string Quoted; // QuotedSubSteps
|
||
/* end of xtraflags */
|
||
public VE_Font Font;
|
||
public Layout StepLayoutData;
|
||
public Edit StepEditData;
|
||
public Print StepPrintData;
|
||
public Tab TabData;
|
||
}
|
||
[Serializable]
|
||
public struct Edit
|
||
{
|
||
public string ForeColor; // Doesn't exist in old format - See StepLayoutData
|
||
public string BackColor; // Doesn't exist in old format - See StepLayoutData
|
||
public string AcTable;
|
||
public string Searchable;
|
||
public TypeMenu TypeMenu;
|
||
}
|
||
[Flags]
|
||
// acceptence list for adding Tables, Cautions, Notes, Substeps, Next, Previous and RNO
|
||
public enum E_AccStep : uint
|
||
{
|
||
AddingCaution = 1,
|
||
AddingNote = 2,
|
||
AddingRNO = 4,
|
||
AddingSub = 8,
|
||
AddingTable = 16,
|
||
AddingNext = 32,
|
||
AddingPrev = 64
|
||
}
|
||
[Serializable]
|
||
public struct TypeMenu
|
||
{
|
||
public string InMenu; // bool - list in menu if step is in Normal (Left-side) column
|
||
public string RnoInMenu; // bool - list in menu if step is in RNO (right-side) column
|
||
public string MenuItem; // for migration, if alternatename or rnoalternate name, use it, otherwise it's type
|
||
public string RnoMenuItem; // for migration, if alternatename or rnoalternate name, use it, otherwise it's type
|
||
public string NoChgReason; // if not in any menu, list reason for User Interface
|
||
public string AlternateNameList; // put indices of alternate types in a list (string)
|
||
//public AlternateName[] AlternateNames; // during migration from 16-bit, this is textype values
|
||
}
|
||
//[Serializable]
|
||
//public struct AlternateName
|
||
//{
|
||
// public string Type; // Step Types that can be included/mixed in the menu (caution/notes)
|
||
//}
|
||
[Serializable]
|
||
public struct Print
|
||
{
|
||
public string ForeColor; // Doesn't exist in old format - See StepLayoutData
|
||
public string BackColor; // Doesn't exist in old format - See StepLayoutData
|
||
public string PosAdjust;
|
||
public string Justify; // added for wolf creek checklist procedures.
|
||
}
|
||
[Serializable]
|
||
public struct Layout
|
||
{
|
||
public string ForeColor;
|
||
public string BackColor;
|
||
public string STExtraSpace;
|
||
public string STBoxindex;
|
||
public string EveryNLines;
|
||
public string SpaceBefore; // = 0
|
||
public string SpaceAfter; // 1 line (in points)
|
||
public string AlwaysUpperCase;
|
||
public string PageBreakAtTypeChange;
|
||
public string AlignWithParentTab;
|
||
}
|
||
[Serializable]
|
||
public struct Tab
|
||
{
|
||
//for VCSummer by jcb
|
||
public bool RNOExcludeMacros;
|
||
public bool IsTransition;
|
||
public float MacroTabAdjust;
|
||
//end for VCSummer by jcb
|
||
public float RNOAdjustTabSize; // added for SHE to align rno whose parent is AND
|
||
public string IdentEdit;
|
||
public string Ident;
|
||
public string IdentAltPrint;
|
||
public string RNOIdentEdit;
|
||
public string RNOIdent;
|
||
//public string IdentEditWid;
|
||
//public string IdentWid;
|
||
//public string RNOIdentEditWid;
|
||
//public string RNOIdentWid;
|
||
public string Justify; // from tbstyle - None, CENTER, LEFT, RIGHT
|
||
public string UsePreviousStyle;
|
||
public string NoTrim;
|
||
public COMacro[] MacroList;
|
||
public VE_Font Font;
|
||
public TabBullet Bullet;
|
||
}
|
||
[Serializable]
|
||
public struct COMacro
|
||
{
|
||
public string Name;
|
||
public string Macro;
|
||
public string Grouping;
|
||
public string NotInRNO;
|
||
public string LocWithXOff;
|
||
}
|
||
[Serializable]
|
||
public struct Box
|
||
{
|
||
public int Index;
|
||
public float Start;
|
||
public float End;
|
||
public float TxtStart;
|
||
public float TxtWidth;
|
||
public float Height;
|
||
public float TabPos;
|
||
public sbyte TxtRowAdj;
|
||
public string BXURC; // Upper Right Corner, etc.
|
||
public string BXHorz;
|
||
public string BXULC;
|
||
public string BXVert;
|
||
public string BXMLS;
|
||
public string BXMRS;
|
||
public string BXLRC;
|
||
public string BXLLC;
|
||
public string BXMID;
|
||
public string BXLHorz;
|
||
public string BXUMID;
|
||
public string BXLMID;
|
||
public VE_Font Font;
|
||
}
|
||
[Serializable]
|
||
public struct Trans
|
||
{
|
||
public string DelimiterForTransitionTitle;
|
||
public string StepSubstepDelimeter;
|
||
public string ThroughString;
|
||
/* Format flags moved to here.... */
|
||
public string SpecifiedSubstepsOnly;
|
||
public string CapsTransitions;
|
||
public string CapTranStep;
|
||
public string TStepNoFlag;
|
||
public string LowerCaseTranNumber;
|
||
public string UpcaseTranAnd;
|
||
public string SuppressAndInTran;
|
||
public string Cap1stCharTrans;
|
||
public string UseTransitionModifier;
|
||
public string UseSecTitles;
|
||
public string HardSpTranProcNumb;
|
||
public string XchngTranSpForHard;
|
||
public string AbsoluteTransitionUpdate;
|
||
public string LowerCaseStepInTran;
|
||
public string DoSectionTransitions;
|
||
public bool AdjustStepTransitionText;
|
||
public bool BoldTransitionExceptHLS;
|
||
/* End of Format flags */
|
||
public TransTypes[] TransTypeData;
|
||
}
|
||
[Serializable]
|
||
public struct TransTypes
|
||
{
|
||
public int Index;
|
||
public byte TransType;
|
||
public string TransFormat;
|
||
public string TransMenu;
|
||
public string TransUI;
|
||
}
|
||
[Serializable]
|
||
public struct RO
|
||
{
|
||
/* Format flags moved to here.... */
|
||
public string AllUnits;
|
||
public string UpRoAftrDash; //UpSetpntAftrDash;
|
||
public string UpcaseAllRoUnits; //UpcaseAllSetpointUnits;
|
||
public string CapHighRo; //CapHighSetpnt;
|
||
public string CapRoIfLastLower; //CapsPIFLastLower;
|
||
public string UpRoIfPrevUpper; //UpSpIfPrevUpper
|
||
public string UnderlineRo; //UnderlineSetpoints
|
||
public string CapFirstLetterInHighRO; //CAPFIRSTLETTERINHIGHSP
|
||
/* End of Format flags */
|
||
}
|
||
[Serializable]
|
||
public struct TabBullet
|
||
{
|
||
public string Separate;
|
||
public VE_Font Font;
|
||
}
|
||
|
||
[Flags]
|
||
public enum E_TransitionMenus : uint
|
||
{
|
||
None = 0,
|
||
ProcCur = 0x0001,
|
||
ProcMenu = 0x0002,
|
||
SectCur = 0x0004,
|
||
SectDefault = 0x0008,
|
||
SectMenuAny = 0x0010,
|
||
SectMenuStep = 0x0020,
|
||
StepAllowNone = 0x0040,
|
||
StepFirst = 0x0080,
|
||
StepLast = 0x0100
|
||
}
|
||
[Flags]
|
||
public enum E_TransFormatXlate : uint
|
||
{
|
||
None = 0,
|
||
Step = 1,
|
||
Range = 2,
|
||
Section = 4,
|
||
Procedure = 8,
|
||
Page = 16
|
||
}
|
||
|
||
#endregion
|
||
|
||
///////////////////////////
|
||
namespace fmtxml
|
||
{
|
||
public partial class FmtFileToXml
|
||
{
|
||
#region localdata
|
||
public XtraFlgs BaseXtraFlags; // used to set up all flags for the Base format.
|
||
public XtraFlgs SubXtraFlags;
|
||
public static int MAXSTEPS = 47;
|
||
public static int MAXBOXES = 12;
|
||
public static int MAXTABS = 20;
|
||
public static int MAXTRANS = 15;
|
||
public static int MAXCHECKOFFS = 18;
|
||
public static int MAXCHKHEADINGS = 5;
|
||
public static int MAXSEQ = 9;
|
||
public static int MAXREPLACE = 60;
|
||
#region XtraFlagBits
|
||
// XtraFlag translation fields...
|
||
//
|
||
// XtraFlag[0] from 16-bit...
|
||
public static int DOUBLERNOSPACE = 0x0001;
|
||
public static int MIXCAUTIONSANDNOTES = 0x0002;
|
||
public static int ALWAYSUSEEXTRALINES = 0x0008;
|
||
public static int ALWAYSTABNOTE = 0x0010;
|
||
public static int ALWAYSTABCAUTION = 0x0020;
|
||
public static int SPECIALPAGEBREAKFLAG = 0x0080;
|
||
public static int DONTPAGINATEONFIRSTSUBSTEP = 0x0200;
|
||
public static int IMPERFECTSTRUCTURE = 0x0800;
|
||
public static int DONTUSEHALFLINES = 0x1000;
|
||
public static int FORTRANFORMATNUMBERS = 0x2000;
|
||
public static int ALLUNITS = 0x4000;
|
||
public static int CAPSTRANSITIONS = 0x8000;
|
||
|
||
// XtraFlag[1] from 16-bit...
|
||
public static int CAPTRANSTEP = 0x0001;
|
||
public static int TSTEPNOFLAG = 0x0004;
|
||
public static int LOWERCASETRANNUMBER = 0x0008;
|
||
public static int CONDENSEDCHANGEBAR = 0x0020;
|
||
public static int DOREVDATE = 0x0040;
|
||
public static int SEPARATEBOX = 0x0080;
|
||
public static int NUMBERHIGHLEVELRNO = 0x0100;
|
||
public static int ALTERNATEFOLDOUTPAGES = 0x1000;
|
||
public static int DONTTRYTOFILLHALFOFPAGE = 0x8000;
|
||
|
||
// XtraFlag[2] from 16-bit...
|
||
public static int DONTCAPITALIZETITLE = 0x0001;
|
||
public static int NOSPACEDOUBLERNO = 0x0004;
|
||
public static int DONTOFFSETTAB = 0x0010;
|
||
public static int UPSETPNTAFTRDASH = 0x0020;
|
||
public static int LOWERCASEREVNUM = 0x0040;
|
||
public static int DONOTCOMPRESSSTEPS = 0x0080;
|
||
public static int REDUCELINEAFTERNOTEANDCAUT = 0x0100;
|
||
public static int RNOSAMELEVEL = 0x0200;
|
||
public static int BOLDHIGHLEVELRNO = 0x2000;
|
||
public static int ONELINEBEFORENOTECAUTIONTAB = 0x4000;
|
||
public static int CONTINUOUSCHANGEBARS = 0x8000;
|
||
|
||
// XtraFlag[3] from 16-bit...
|
||
//public static int CHECKOFFONALLSTEPS = 0x0004;
|
||
public static int DONTBOXAC = 0x0020;
|
||
public static int USETOPCONTINUEMESSAGEATEND = 0x0080;
|
||
public static int UPCASETRANAND = 0x2000;
|
||
public static int UPCASEALLSETPOINTUNITS = 0x4000;
|
||
|
||
// XtraFlag[4] from 16-bit...
|
||
public static int DEV_FORMAT = 0x0001;
|
||
public static int DONTDOSTEXTRAATTOP = 0x0004;
|
||
public static int XLINES_STEPFIX = 0x0008;
|
||
public static int REBOXCAUTNOTE = 0x0010;
|
||
public static int IMMSTEPSPCHDR = 0x0020;
|
||
public static int FLOATINGCONTINUEMESSAGE = 0x0080;
|
||
public static int ABSOLUTEFIXEDCHANGECOLUMN = 0x0200;
|
||
public static int LJBORDERLESSTABLE = 0x0800;
|
||
public static int SUPPRESSANDINTRAN = 0x1000;
|
||
public static int CAPHIGHSETPNT = 0x2000;
|
||
public static int CAPFIRSTLETTERINHIGHSP = 0x4000;
|
||
public static int CAPSPIFLASTLOWER = 0x8000;
|
||
|
||
// XtraFlag[5] from 16-bit...
|
||
public static int ALTERNATEFLOATINGFOLDOUT = 0x0001;
|
||
public static int WRAPSAMEASEDIT = 0x0002;
|
||
public static int KEEPSTEPSONPAGE = 0x0004;
|
||
public static int SPECIFIEDSUBSTEPSONLY = 0x0008;
|
||
public static int THREEBLANKSABOVENOTESCAUTIONS = 0x0010;
|
||
public static int IMPERFECTSUBSTEP = 0x0040;
|
||
public static int DONTBREAKONSECTIONS = 0x0080;
|
||
public static int NOSTEPNUMIFONLYONESTEP = 0x0100;
|
||
public static int SHOWSECTIONTITLES = 0x0200;
|
||
public static int LJTABS = 0x0400;
|
||
public static int DONTNUMBERRNOSUBS = 0x0800;
|
||
public static int DROPCHECKOFF = 0x4000;
|
||
public static int NOCHECKOFFSINRNO = 0x8000;
|
||
|
||
// XtraFlag[6] from 16-bit...
|
||
|
||
public static int CHGBARMESSAGEFROMEDIT = 0x0001;
|
||
public static int CHANGEBARTORNOSEP = 0X0002;
|
||
public static int CHGSTYLEPERSECTION = 0x0008;
|
||
public static int SECTIONLEVELFOLDOUTS = 0x0010;
|
||
public static int BOXCONTACTIONS = 0x0020;
|
||
public static int DOSECTIONTRANS = 0x0040;
|
||
public static int UPSPIFPREVUPPER = 0x0100;
|
||
public static int CONTINUESECTIONHEADER = 0x0200;
|
||
public static int GLOBALPROCINFO = 0x0400;
|
||
public static int COMPRESSHPSUB = 0x0800;
|
||
public static int BULLETONCONTINUOUS = 0x1000;
|
||
public static int CANCELSECTITLESONS2 = 0x2000;
|
||
public static int NOENDFORSINGLE = 0x4000;
|
||
public static int USEMETASECTIONS = 0x8000;
|
||
|
||
// XtraFlag[7] from 16-bit...
|
||
|
||
public static int RNOCONTINUEONLY = 0x0001;
|
||
public static int CAP1STCHARTRANS = 0x0002;
|
||
public static int DONTPAGINATEONFIRSTSUBSTEP3X = 0x0004;
|
||
public static int RNOSEPAFTERAER = 0x0008;
|
||
public static int REVDATEWITHFORWARDSLASH = 0x0010;
|
||
public static int USEALTERNATESTEPBOX = 0x0040;
|
||
public static int CANCELSECTITLESONS1 = 0x0080;
|
||
public static int SPECIALSTEPSFOLDOUT = 0x0100;
|
||
public static int UNDERLINEAFTERDASHSPACE = 0x0200;
|
||
public static int NOSPACEINNOTEORCAUTION = 0x0400;
|
||
public static int USEXTRAREVNUMBER = 0x0800;
|
||
public static int UNDERLINESETPOINTS = 0x1000;
|
||
public static int DOSECTIONTRANSTYPEB = 0x2000;
|
||
public static int PAGINATEONLOWERSTEPLEVEL = 0x4000;
|
||
public static int USETRANSITIONMODIFIER = 0x8000;
|
||
|
||
// XtraFlag[8] from 16-bit...
|
||
|
||
public static int CUSTOMSPACING = 0x0001;
|
||
public static int ENHANCEDSHORTFORMDEV = 0x0002;
|
||
public static int PAGEBREAKONHIGHLEVELSTEP = 0x0010;
|
||
public static int PAGEBREAKONCAUTIONS = 0X0040;
|
||
public static int PAGEBREAKONNOTES = 0X0080;
|
||
public static int ALIGNNULLTABWSECTHEAD = 0X0100;
|
||
public static int DONTUSESECTITLES = 0x0200;
|
||
public static int TEXTSUBFOLLOWSTEXTSTYLE = 0x0400;
|
||
public static int TRANSPROCTITLEINPAREN = 0x0800;
|
||
public static int HARDSPTRANPROCNUMB = 0x1000;
|
||
public static int TREATANDORASSEQUENTIAL = 0x2000;
|
||
public static int DONTSPLITSTEPINPRNTSTEP = 0x4000;
|
||
public static int LINEABOVEUNDERSECTION = 0x8000;
|
||
|
||
// XtraFlag[9] from 16-bit...
|
||
|
||
public static int PICAIGNOREFIVESIXTHS = 0x0004;
|
||
public static int SPACEFORNOSECNUMB = 0x0008;
|
||
public static int NONEDITABLESTEPS = 0x0010;
|
||
public static int BOXEDSUBSTEPS = 0x0020;
|
||
public static int DONTNUMBERHIGHLEVELSTEPS = 0x0040;
|
||
public static int NOSTEPNUMBERFORHIGHLEVELRNO = 0x0400;
|
||
public static int PROMPTFORCAUTINTYPE = 0x0800;
|
||
public static int CAUTION1SAMEROWASPARENT = 0x1000;
|
||
public static int WOLFCREEKBACKGROUNDFORMAT = 0x4000;
|
||
public static int ENHANCEDSTEPNUMFROMPREV = 0x8000;
|
||
|
||
// XtraFlag[10] from 16-bit...
|
||
|
||
public static int CONTROLUNDERLINESTYLE = 0x0001;
|
||
public static int MULTIPLECHANGEIDS = 0x0008;
|
||
public static int USEMULTILINESECTIONTITLE = 0x0010;
|
||
public static int PAGEBREAKONFIRSTBLANKLINE = 0x0040;
|
||
public static int DONTPRINTNOTITLE = 0x0080;
|
||
public static int NOTESTOFOOTNOTES = 0x0400;
|
||
public static int UNDSPECIALSTEPSFOLDOUT = 0x0800;
|
||
public static int PUTONPAGEBYITSELF = 0x4000;
|
||
|
||
// XtraFlag[11] from 16-bit...
|
||
|
||
public static int SECTITLECONTINUE = 0x0001;
|
||
public static int CANCELSECTITLESONE0 = 0x0002;
|
||
public static int METASECTENDMESSAGE = 0x0004;
|
||
public static int CANCELSECTITLESONE2 = 0x0040;
|
||
public static int COMPRESSHPSUPER = 0x2000;
|
||
|
||
// XtraFlag[12] from 16-bit...
|
||
|
||
public static int MATCHUPRNOCAUTNOTE = 0x0001;
|
||
public static int PAGINATEATHIGHESTPAGINLEVEL = 0x0008;
|
||
public static int USELONGPROCTITLES = 0x0100;
|
||
public static int SPECIALLANDSCAPEMODE = 0x1000;
|
||
public static int RNOINPAGELIST = 0x2000;
|
||
public static int STPCAUTNOTETABINPAGELIST = 0x4000;
|
||
public static int READONLYTYPEINCONTMSG = 0x8000;
|
||
|
||
// XtraFlag[13] from 16-bit...
|
||
|
||
public static int CENTERONELINEONLY = 0X0001;
|
||
public static int TIETABTOLEVEL = 0x0002;
|
||
public static int ACCESSORYDOCSINDUPLEX = 0x0008;
|
||
public static int FOLDOUTSINDUPLEX = 0x0010;
|
||
public static int USESTEXTRAREALVALUE = 0x0040;
|
||
public static int SUBTABLEGETSUP1LEVEL = 0x0080;
|
||
public static int DONTCOUNTFOLDOUTPAGES = 0x0200;
|
||
public static int SEARCHALLREPLACEWORDS = 0x1000;
|
||
|
||
// XtraFlag[14] from 16-bit...
|
||
|
||
public static int REMEMBERCAUTIONSANDNOTES = 0x0001;
|
||
public static int RTFADJUSTMENTS = 0x0008;
|
||
public static int CENTERONELINEADJUST = 0x0010;
|
||
public static int COUNTALLSUBLEVELS = 0x0020;
|
||
public static int DONTREPLACEWORDSINROS = 0x0080;
|
||
public static int HIGHLEVELRNOBEFOREAERSUBSTPS = 0x0100;
|
||
public static int UNDERLINEALLMETATITLES = 0x0200;
|
||
public static int DONTBREAKCAUTIONSORNOTES = 0x0400;
|
||
public static int BOLDONLYSECTIONZERO = 0x0800;
|
||
public static int DONTBREAKONRNO = 0x1000;
|
||
public static int RNOCHECKOFFSAMEASPARENT = 0x2000;
|
||
public static int USESTEPTYPEWIDTHOVERRRIDE = 0x4000;
|
||
public static int WOLFCREEKCKLFORMAT = 0x8000;
|
||
|
||
// XtraFlag[15] from 16-bit...
|
||
|
||
public static int DONTPAGINATEONFIRSTSUBSTEP2X = 0x0001;
|
||
public static int USESTEPTYPEWIDTHOVERRRIDEEDITPRINT = 0x0002;
|
||
public static int PARTIALSTEPCOMPRESSION = 0x0004;
|
||
public static int USESMARTTEMPLATE = 0x0008;
|
||
public static int CHECKOFFONHLSONLY = 0x0010;
|
||
public static int CAUTION2SAMEROWASPARENT = 0x0080;
|
||
public static int CENTERTEXTWITHINWIDTH = 0x0200;
|
||
public static int DONTBREAKEQUIPMENTLIST = 0x0400;
|
||
public static int ALWAYSTABCAUTION2 = 0x1000;
|
||
public static int VIRTUALDOTINHLSTAB = 0x2000;
|
||
public static int IMPERFECTSTRUCTUREPLUS4 = 0x4000;
|
||
|
||
// XtraFlag[16] from 16-bit...
|
||
|
||
public static int USERNOTYPEINACTABLE = 0x0002;
|
||
public static int ABSOLUTETRANSITIONUPDATE = 0x0004;
|
||
public static int SEPARATEBOXCAUTIONS = 0x0008;
|
||
public static int HLSTEXTINPAGELIST = 0x0020;
|
||
public static int LOWERCASESTEPINTRAN = 0x0080;
|
||
public static int CHANGEBARSONLINKEDTEXT = 0X1000;
|
||
public static int QUOTEDSUBSTEPS = 0x2000;
|
||
|
||
// XtraFlag[17] from 16-bit...
|
||
|
||
public static int OVERRIDEENHANCEDTABS = 0x0008;
|
||
public static int NONEWLINEAFTERRNO = 0x0020;
|
||
public static int DOSECTIONSEPARATORLINE = 0x0040;
|
||
public static int PARENSONEXTPAGENUMTRANS = 0x0080;
|
||
public static int ATLEASTTWODIGITSFORHLS = 0x0100;
|
||
public static int DONTBREAKOPTEQUIPMENTLIST = 0x0200;
|
||
public static int PAGELISTCHANGEIDSWITHCOMMAS = 0x0400;
|
||
public static int DONTSTARTLINEWITHDASH = 0x0800;
|
||
public static int NOBLANKLINEBEFORESUBSTEP = 0x1000;
|
||
public static int DONTBREAKCAUTIONSNOTESONSUBSTPS = 0x2000;
|
||
public static int DONTCONVERTCARETTODELTA = 0x4000;
|
||
|
||
// XtraFlag[18] (was VEAIRFLAG) from 16-bit...
|
||
public static int NORNO = 0x0002;
|
||
public static int ONLYSINGLECOLUMN = 0x0008;
|
||
public static int NULLBOX = 0x0010;
|
||
public static int XCHNGTRANSPFORHARD = 0x0020;
|
||
public static int WOLFCREEKCKLBACKGNDFORMAT = 0x0040;
|
||
#endregion
|
||
// use the following to define which step the AlternateStepType data is associated with.
|
||
// i.e. look in new.def to determine the #defines for the original step type associated
|
||
// with the name of the define. Note that all have been incremented by 1 since these are
|
||
// indices into the step list and we introduced 'Base' at index 0.
|
||
// (ALT_HIGH, ALT_CONTINUOUS, ALT_IMMEDIATE, ALT_LOSSOFAC, ALT_HIGH5)
|
||
private int[] altsteps = { 2, 9, 3, 18, 41 }; // before increment of 1: { 1, 8, 2, 17, 40 };
|
||
|
||
// use the following to define which step the AlternateSubType data is associated with.
|
||
// (see above) (ALT_STANDARD, ALT_AND, ALT_OR, ALT_EQUIPMENTLIST, ALT_EQUIPMENTWBLANK, ALT_EXPLICITAND
|
||
private int[] altsubsteps = {1, 4, 5, 11, 14, 19, // before increment of 1: {0, 3, 4, 10, 13, 18,
|
||
// ALT_IMPLICITOR, ALT_PARAGRAPH, ALT_EQUIPMENTOPT, ALT_EQUIPMENTOPTWBLANK, ALT_TITLEWITHTEXTRIGHT
|
||
35, 24, 30, 31, 42, // before increment of 1: 34, 23, 29, 30, 41,
|
||
// ALT_TITLEWITHTEXTBELOW, ALT_CONTACSEQUENTIAL, ALT_CONTACAND, ALT_CONTACOR, ALT_CONTACPARAGRAPH
|
||
43, 44, 45, 46, 47}; // before increment of 1: 42, 43, 44, 45, 46};
|
||
|
||
private string[] StepTypes = {
|
||
"Base", "Substep","High","Immediate","And","Or","Caution","Note","Table","Continuous",
|
||
"AERTable","EquipmentList","Title","PageNumber","EquipmentWBlank","ProcNumber",
|
||
"RevNumber","AccPages","LossOfAC","ExplicitAnd","Caution1","Caution2",
|
||
"Note1","Note2","Paragraph","Default","Note3","Caution3","Note4","Caution4",
|
||
"EquipmentOpt","EquipmentOptWBlank","Note5","BorderlessAERTable","BorderlessTable",
|
||
"ImplicitOr","Figure","AERFigure","BorderlessFigure","BorderlessAERFigure",
|
||
"RNOType","High5","TitleWithTextRight","TitleWithTextBelow",
|
||
"ContAcSequential","ContAcAnd","ContAcOr","ContAcParagraph"
|
||
};
|
||
private string[] ParentTypes = {
|
||
"", "Base","Base","High","Substep","Substep","Base","Base","Base","High",
|
||
"Table","Substep","Base","Title","EquipmentList","Title",
|
||
"Title","Base","High","And","Caution","Caution",
|
||
"Note","Note","Substep","Substep","Note","Caution","Note","Caution",
|
||
"EquipmentList","EquipmentWBlank","Note","AERTable","Table",
|
||
"Or","Base","Figure","Figure","AERFigure",
|
||
"High","High","Title","Title",
|
||
"Substep","And","Or","Paragraph"
|
||
};
|
||
private string[] Inactive = {
|
||
"False", "False","False","False","False","False","False","False","False","False",
|
||
"False","False","False","True","False","True","True","True","False","False","False","False",
|
||
"False","False","False","True","False","False","False","False","False","False","False","False","False",
|
||
"False","False","False","False","False","False","False","False","False","False","False","False","False"
|
||
};
|
||
private string[] Searchable = {
|
||
"False", "True", "True","True","True", "True", "True","True","True","True",
|
||
"True", "True", "False","False","True", "False","False","True","True","True","True","True",
|
||
"True","True","True","False","True","True","True","True","True","True","True","True","True",
|
||
"True","True","True","True","True","True","True","False","False","True","True","True","False"
|
||
};
|
||
private string[] TypeMenuItem = {
|
||
"Base", "Sequential Substep", "Standard High Level Step","Immediate Action Step","AND", "OR", "Caution","Note","Centered Table","Continuous Action Step",
|
||
"AER Table", "Equipment List", "Title","Page Number","Equipment Preceded by Blank Line", "Procedure Number",
|
||
"Rev Number","Acc Pages","Boxed High Level Step","Explicit AND","Caution 1","Caution 2",
|
||
"Note 1","Note 2","Paragraph","Default","Note 3","Caution 3","Note 4","Caution 4",
|
||
"Optional Equipment List","Optional Equipment with Blank Line","Note 5","AER Table Without Border","Centered Table Without Border",
|
||
"Implicit OR","Centered Figure","AER Figure","Centered Figure Without Border","AER Figure Without Border",
|
||
"RNO Type","Alternate High Level Step","Title With Text Right","Title With Text Below",
|
||
"Continuous Action Sequential","Continuous Action AND","Continuous Action OR","Continuous Action Paragraph"
|
||
};
|
||
private string[] NoChangeTypeReason = {
|
||
"Base Type - No change at this level", null, null,null,null, null, null,null,null,null,
|
||
null, null, null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
|
||
null,null,null,null,null,null,null,null,null,null,"RNO - No change allowed",null,null,null,
|
||
null,null,null,null
|
||
};
|
||
private string[] RnoInMenu = {
|
||
null, "True",null,null,"True","True",null,null,"True",null,"False","True",null,null,"True",null,
|
||
null,null,null,"True",null,null,null,null,"True",null,null,null,null,null,"True","True",null,"False","True",
|
||
"True","True","False","True","False","False",null,null,null,"True","True","True","True"
|
||
};
|
||
|
||
/*
|
||
* from the 16-bit code, the following step type attributes/strings were defined. This was found in \promnt\lib\edit\slectyp.c
|
||
* High level types:
|
||
* "High Level Step","Continuous Action Step","Immediate Action Step","Boxed High Level Step","Alternate High Level Step"
|
||
* int far HighTypeValue[]={HIGH,CONTINUOUS,IMMEDIATE,LOSSOFAC,HIGH5};
|
||
* Substep types:
|
||
* char *SubType[NBRSUB]={
|
||
* "Sequential",
|
||
* "AND",
|
||
* "OR",
|
||
* "Equipment List",
|
||
* "Equipment Preceded by Blank Line",
|
||
* "Explicit AND",
|
||
* "Implicit OR",
|
||
* "Paragraph",
|
||
* "Optional Equipment List",
|
||
* "Optional Equipment with Blank Line",
|
||
* "Continuous Action Sequential",
|
||
* "Continuous Action AND",
|
||
* "Continuous Action OR",
|
||
* "Continuous Action Paragraph",
|
||
* "Title With Text To The Right",
|
||
* "Title With Text Placed Below"
|
||
* int SubTypeValue[NBRSUB]={STANDARD,AND,OR,EQUIPMENTLIST,EQUIPMENTWBLANK,EXPLICITAND,IMPLICITOR,PARAGRAPH,
|
||
* EQUIPMENTOPT,EQUIPMENTOPTWBLANK,CONTACSEQUENTIAL,CONTACAND,CONTACOR,CONTACPARAGRAPH,TITLEWITHTEXTRIGHT,TITLEWITHTEXTBELOW
|
||
*
|
||
*/
|
||
|
||
private string[] WinColors =
|
||
{
|
||
"black","blue","green","cyan","red","magenta",
|
||
"brown","lightgray","darkgray","ligthblue",
|
||
"lightgreen","lightcyan","lightred","lightmagenta",
|
||
"yellow","white"
|
||
};
|
||
/*
|
||
* The ?. characters have been added to the DefaultTransStr. This string is used in the
|
||
* code to determine the text that gets resolved for a transition.
|
||
*
|
||
* ?. means the following (for !section transitions)
|
||
* for proc - if current, don't put out text, if !current, put out text
|
||
* for sect - if curproc: if cursect, don't put out text; if !cursect, put out text
|
||
* if !curproc: if default sect, don't put out text; if !default sect, put out text
|
||
*/
|
||
private string[] DefaultTransStr =
|
||
{
|
||
"{Proc Num}, {Proc Title}, Step {First Step}",
|
||
"{First Step}",
|
||
"{First Step}, {.}, {.}, {.} and {Last Step}",
|
||
"{First Step} thru {Last Step} of {?.Proc Num}, {?.Proc Title}, {?.Sect Hdr}",
|
||
// The section transition had <Section Title> for the following, but the 16-bit code
|
||
// put in the number & title, so 32-bit uses '{?.Sect Hdr}'. This will need to be
|
||
// tested for formats that actually use <Section Title>: AEP, BGE, FNP, NSP. OHLP did not.
|
||
"{?.Sect Hdr}, Step {First Step}",
|
||
"{Proc Num}, {Proc Title}, {?.Sect Hdr}, Step {First Step}"
|
||
};
|
||
|
||
#region SectionTransitionVariables
|
||
private string DefaultSectionTransStrTypeB = "{Sect Num}, {Sect Title}, {First Step}";
|
||
private string DefaultSectionTransStrTypeBNone = "{Sect Hdr}, Step {SectNum}{First Step}"; //original
|
||
private string[] DefaultSectionTransFormatStr =
|
||
{
|
||
"{Proc Num}, {Proc Title}, Step {Sect Num}{First Step}",
|
||
"{Sect Num}{First Step}",
|
||
"{Sect Num}{First Step}, {.}, {.}, {.} and {Sect Num}{Last Step}",
|
||
"{Sect Num}{First Step} thru {Sect Num}{Last Step}",
|
||
"{Sect Num}, Step {?.Sect Num}{First Step}",
|
||
"{Sect Hdr}, Step {SectNum}{First Step}"
|
||
};
|
||
// made up the following strings so that the token processing for setting
|
||
// up the menu enums would work as expected. These are only used in this migration
|
||
// code to set up the enums. The above (DefaultSectionTransFormatStr) is used for
|
||
// the actual formatting of the strings in the new code.
|
||
private string[] DefaultSectionTransTokenStr =
|
||
{
|
||
"{Proc Num}, {Proc Title}, Step {First Step}",
|
||
"{First Step} ( Within the current section )",
|
||
"{First Step}, {.}, {.}, {.} and {Last Step}",
|
||
"{Sect Num}{First Step} thru {Sect Num}.{Last Step}",
|
||
"{Sect Num}{First Step} ( To a different section )",
|
||
"{Sect Num}{First Step}, {Sect Title} ( To a different section )"
|
||
};
|
||
|
||
#endregion
|
||
|
||
private Int16[] Tabindx;
|
||
private BinaryReader brFmt;
|
||
private string fmtName;
|
||
|
||
private static Dictionary<int, int> dicChar;
|
||
#endregion
|
||
public FormatData BaseFormat;
|
||
public static List<Dictionary<string, Step>> StepParentList = new List<Dictionary<string,Step>>();
|
||
public static List<Dictionary<string, Step>> StepList = new List<Dictionary<string, Step>>();
|
||
public bool HasBase;
|
||
public FormatData MyFormat;
|
||
public string MyPath;
|
||
public FmtFileToXml(FmtFileToXml gendata, string alias, string nm, string path)
|
||
{
|
||
//DateTime tStart = DateTime.Now;
|
||
MyPath = path;
|
||
if (gendata == null)
|
||
HasBase = false;
|
||
else
|
||
{
|
||
HasBase = true;
|
||
BaseFormat = gendata.MyFormat;
|
||
|
||
}
|
||
BuildDictionaryText();
|
||
fmtName = alias;
|
||
//if (fmtName.ToUpper() != "WCN1" && fmtName.ToUpper() != "BASE") return;
|
||
//if (fmtName.ToUpper() != "OHLP" && fmtName.ToUpper() != "BASE" && fmtName.ToUpper() != "WCN2") return;
|
||
//if (fmtName.ToUpper() != "WCNCKL" && fmtName.ToUpper() != "BASE") return;
|
||
//if (fmtName.ToUpper() != "NSPARP" && fmtName.ToUpper() != "BASE") return;
|
||
//if (!fmtName.ToUpper().StartsWith("FNP") && fmtName.ToUpper() != "BASE") return;
|
||
try
|
||
{
|
||
LoadFormatFile(nm + ".fmt", ref SubXtraFlags);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show("Format name FAILED = " + nm, ex.Message);
|
||
}
|
||
//Console.WriteLine(" {0:0.000} seconds", TimeSpan.FromTicks(DateTime.Now.Ticks - tStart.Ticks).TotalSeconds);
|
||
}
|
||
#region GetBinaryReaderData
|
||
private byte[] GetByteArray(BinaryReader br, int len)
|
||
{
|
||
byte[] input; // = new byte[len + 1];
|
||
input = br.ReadBytes(len);
|
||
return input;
|
||
}
|
||
|
||
public static Regex Reg2;
|
||
public static void BuildDictionaryText()
|
||
{
|
||
#region ExtraUnicodeConvert
|
||
dicChar = new Dictionary<int, int>();
|
||
// note that the following characters needed adjusted, i.e. the
|
||
// default conversion to unicode did not result in the desired letter,
|
||
// so an extra conversion was needed.
|
||
dicChar[966] = 216; // dist zero
|
||
dicChar[201] = 274; // capital E with macron (line above)
|
||
dicChar[127] = 916; // delta
|
||
dicChar[964] = 947; // little gamma
|
||
dicChar[920] = 952; // little theta
|
||
dicChar[915] = 961; // little rho
|
||
dicChar[191] = 964; // little tau
|
||
dicChar[8801] = 8773; // approx. equal
|
||
dicChar[8734] = 8857; // circle w/ dot
|
||
dicChar[7] = 9679; // bullet
|
||
dicChar[8976] = 9830; // diamond
|
||
// dicChar[15] = 167; // grave 15=F; 167=xA7
|
||
#endregion
|
||
#region DefinedLineDrawChars
|
||
// do all of the box/line draw characters to unicode. These were part
|
||
// of the Volian Line Draw font.
|
||
dicChar[179] = 9474; // b3
|
||
dicChar[180] = 9508; // b4
|
||
dicChar[181] = 9569;
|
||
dicChar[182] = 9570;
|
||
dicChar[183] = 9558;
|
||
dicChar[184] = 9557;
|
||
dicChar[185] = 9571; // b9
|
||
dicChar[186] = 9553; // ba
|
||
dicChar[187] = 9559;
|
||
dicChar[188] = 9565;
|
||
dicChar[189] = 9564;
|
||
dicChar[190] = 9563;
|
||
dicChar[191] = 9488;
|
||
dicChar[192] = 9492; // c0
|
||
dicChar[193] = 9524;
|
||
dicChar[194] = 9516;
|
||
dicChar[195] = 9500;
|
||
dicChar[196] = 9472;
|
||
dicChar[197] = 9532; // C5
|
||
dicChar[198] = 9566;
|
||
dicChar[199] = 9567;
|
||
dicChar[200] = 9562;
|
||
dicChar[201] = 9556;
|
||
dicChar[202] = 9577; // ca
|
||
dicChar[203] = 9574;
|
||
dicChar[204] = 9568;
|
||
dicChar[205] = 9552;
|
||
dicChar[206] = 9580;
|
||
dicChar[207] = 9575;
|
||
dicChar[208] = 9576; // d0
|
||
dicChar[209] = 9572;
|
||
dicChar[210] = 9573;
|
||
dicChar[211] = 9561;
|
||
dicChar[212] = 9560;
|
||
dicChar[213] = 9554; // d5
|
||
dicChar[214] = 9555;
|
||
dicChar[215] = 9579;
|
||
dicChar[216] = 9578;
|
||
dicChar[217] = 9496;
|
||
dicChar[218] = 9484; // da
|
||
dicChar[219] = 9608;
|
||
dicChar[220] = 9604;
|
||
dicChar[221] = 9612;
|
||
dicChar[222] = 9616;
|
||
dicChar[223] = 9600;
|
||
#endregion
|
||
#region StyleTokens
|
||
|
||
/*
|
||
* char AttrOnList[7] = {0xd3,0xd5,0xae,0xb2,SUBSCRIPT_ON,SUPERSCRIPT_ON,0};
|
||
char AttrOffList[7] = {0xd4,0xd6,0xaf,0xdd,SUBSCRIPT_OFF,SUPERSCRIPT_OFF,0};
|
||
int AttrList[7] = {BUNDERLINE_WORD, BOLD_WORD, UNDERLINE_WORD,
|
||
ITALICS_WORD, SUBSCRIPT_WORD, SUPERSCRIPT_WORD,0};
|
||
|
||
dicChar[13] = 213; //bold on 13=D -> 213=xD5
|
||
//bold off ?? -> 214=xD6
|
||
dicChar[16] = 244; //underline on 16=x10 -> 244=xF4
|
||
//underline off ?? -> 246=xF6
|
||
//bold&uline on ?? -> 211=xD3
|
||
//bold/uline off ?? -> 212=xD4
|
||
dicChar[18] = 198; //superscript on 18=x12 -> 108=xC6
|
||
//superscript off ?? -> 109=xc7
|
||
dicChar[19] = 209; //subscript on 19=x13 -> 209=D9
|
||
//subscript off ?? -> 166->xA6
|
||
|
||
|
||
// see exe\edit\vestdstp.c for some of these....
|
||
dicChar[1] = 161; //Bold word or toggle
|
||
dicChar[2] = 162; //Underline word
|
||
// not used except in TRANSITIONS dicChar[3] = 164; //Bold/Uline word
|
||
// not used except in TRANSITIONS dicChar[4] = 165; //Italics word
|
||
dicChar[5] = 111; //Bold/Italics word
|
||
dicChar[6] = 111; //Bold/Uline word
|
||
//dicChar[7] = 111; //Bold/Uline/Italics word
|
||
dicChar[8] = 111; //super word
|
||
dicChar[9] = 111;
|
||
dicChar[10] = 111;
|
||
dicChar[11] = 111;
|
||
dicChar[12] = 111;
|
||
dicChar[14] = 111;
|
||
// ... 9-15
|
||
dicChar[16] = 111; //subscript word
|
||
dicChar[17] = 111;
|
||
// ... 17-31
|
||
dicChar[20] = 162;
|
||
dicChar[21] = 162;
|
||
dicChar[22] = 162; // toggle underline
|
||
dicChar[25] = 163; //subscript on 25=x19; 163=xA3
|
||
dicChar[24] = 122; //subscript off (0x18)
|
||
dicChar[23] = 123; // underline next word
|
||
dicChar[31] = 163;
|
||
dicChar[26] = 163;
|
||
dicChar[27] = 163;
|
||
dicChar[28] = 163;
|
||
dicChar[29] = 163;
|
||
dicChar[30] = 163;
|
||
* */
|
||
#endregion
|
||
|
||
char[] creg = new char[dicChar.Count];
|
||
int i = 0;
|
||
foreach (int ic in dicChar.Keys)
|
||
{
|
||
creg[i] = (char)ic;
|
||
i++;
|
||
}
|
||
Reg2 = new Regex("[" + new string(creg) + "]");
|
||
}
|
||
public static string ReplaceChars(Match m)
|
||
{
|
||
char[] cs = m.Value.ToCharArray();
|
||
for (int i = 0; i < cs.Length; i++)
|
||
{
|
||
if (dicChar.ContainsKey((int)(cs[i])))
|
||
{
|
||
int iKey = (int)cs[i];
|
||
int iValue = dicChar[iKey];
|
||
//if(iKey<32 && iKey!=7)Console.WriteLine(" {0} {1} {2} {3}", iKey, (char)iKey, iValue, (char)iValue);
|
||
cs[i] = (char)iValue;
|
||
}
|
||
}
|
||
return new string(cs);
|
||
}
|
||
public static string ConvertText(string s1)
|
||
{
|
||
string s2 = Reg2.Replace(s1, new MatchEvaluator(ReplaceChars));
|
||
return s2;
|
||
}
|
||
private string GetStringFromByteNoConvert(Byte[] barray, int offset)
|
||
{
|
||
offset--;
|
||
StringBuilder inpstr = new StringBuilder();
|
||
byte input = 0;
|
||
int cnt = 0;
|
||
bool stillread = true;
|
||
do
|
||
{
|
||
input = barray[offset++];
|
||
if (input == 0) stillread = false;
|
||
inpstr.Append(Convert.ToChar(input));
|
||
cnt++;
|
||
} while (stillread);
|
||
|
||
string retstr = inpstr.ToString();
|
||
retstr = retstr.Replace('<', '{');
|
||
retstr = retstr.Replace('>', '}');
|
||
//retstr = ConvertText(retstr);
|
||
if (retstr.Substring(retstr.Length - 1, 1) == "\0") return retstr.Substring(0, retstr.Length - 1);
|
||
return retstr;
|
||
}
|
||
private string GetStringFromByte(Byte[] barray, int offset)
|
||
{
|
||
offset--;
|
||
StringBuilder inpstr = new StringBuilder();
|
||
byte input = 0;
|
||
int cnt = 0;
|
||
bool stillread = true;
|
||
do
|
||
{
|
||
input = barray[offset++];
|
||
if (input == 0) stillread = false;
|
||
inpstr.Append(Convert.ToChar(input));
|
||
cnt++;
|
||
} while (stillread);
|
||
|
||
string retstr = inpstr.ToString();
|
||
retstr = retstr.Replace('<', '{');
|
||
retstr = retstr.Replace('>', '}');
|
||
retstr = ConvertText(retstr);
|
||
if (retstr.Substring(retstr.Length - 1, 1) == "\0") return retstr.Substring(0, retstr.Length - 1);
|
||
return retstr;
|
||
}
|
||
static public string GetStringUntilNull(BinaryReader br)
|
||
{
|
||
StringBuilder inpstr = new StringBuilder();
|
||
byte input = 0;
|
||
int cnt = 0;
|
||
bool stillread = true;
|
||
do
|
||
{
|
||
try
|
||
{
|
||
input = br.ReadByte();
|
||
if (input == 0) stillread = false;
|
||
inpstr.Append(Convert.ToChar(input));
|
||
}
|
||
catch (System.IO.EndOfStreamException)
|
||
{
|
||
stillread = false;
|
||
}
|
||
cnt++;
|
||
} while (stillread);
|
||
|
||
string retstr = inpstr.ToString();
|
||
retstr = retstr.Replace('<', '{');
|
||
retstr = retstr.Replace('>', '}');
|
||
if (retstr.Substring(retstr.Length - 1, 1) == "\0") return retstr.Substring(0, retstr.Length - 1);
|
||
return retstr;
|
||
}
|
||
private string GetString(BinaryReader br, int len)
|
||
{
|
||
StringBuilder inpstr = new StringBuilder();
|
||
byte input = 0;
|
||
int cnt = 0;
|
||
do
|
||
{
|
||
try
|
||
{
|
||
input = br.ReadByte();
|
||
inpstr.Append(Convert.ToChar(input));
|
||
}
|
||
catch (System.IO.EndOfStreamException)
|
||
{
|
||
input = 0;
|
||
while (cnt < len)
|
||
{
|
||
inpstr.Append(Convert.ToChar(input));
|
||
cnt++;
|
||
}
|
||
}
|
||
cnt++;
|
||
} while (cnt < len);
|
||
|
||
string retstr = inpstr.ToString();
|
||
retstr = retstr.Replace('<', '{');
|
||
retstr = retstr.Replace('>', '}');
|
||
if (retstr.Substring(retstr.Length - 1, 1) == "\0") return retstr.Substring(0, retstr.Length - 1);
|
||
return retstr;
|
||
}
|
||
#endregion
|
||
private VE_Font LoadVE_Font()
|
||
{
|
||
UInt32 ui = brFmt.ReadUInt32();
|
||
//if (ui > 0) - Always set the font, even if it is 0 (default)
|
||
//{
|
||
VE_Font retval = new VE_Font(ui);
|
||
return retval;
|
||
//}
|
||
//return null;
|
||
}
|
||
private VE_Font LoadVE_FontByte()
|
||
{
|
||
byte bt = brFmt.ReadByte();
|
||
if (bt > 0)
|
||
{
|
||
VE_Font retval = new VE_Font(Convert.ToUInt32(bt));
|
||
return retval;
|
||
}
|
||
return null;
|
||
}
|
||
#region XtraFlags
|
||
private void AddFlags(ref XtraFlgs XtraFlags, int i, Int16 flg)
|
||
{
|
||
if (i == 0)
|
||
{
|
||
if ((flg & DOUBLERNOSPACE) > 0) XtraFlags.DoubleRNOSpace = true.ToString();
|
||
if ((flg & MIXCAUTIONSANDNOTES) > 0) XtraFlags.MixCautionsAndNotes = true.ToString();
|
||
if ((flg & ALWAYSUSEEXTRALINES) > 0) XtraFlags.AlwaysUseExtralines = true.ToString();
|
||
if ((flg & ALWAYSTABNOTE) > 0) XtraFlags.AlwaysTabNote = true.ToString();
|
||
if ((flg & ALWAYSTABCAUTION) > 0) XtraFlags.AlwaysTabCaution = true.ToString();
|
||
if ((flg & SPECIALPAGEBREAKFLAG) > 0) XtraFlags.SpecialPageBreakFlag = true.ToString();
|
||
if ((flg & DONTPAGINATEONFIRSTSUBSTEP) > 0) XtraFlags.DontPaginateOnFirstSubStep = true.ToString();
|
||
if ((flg & IMPERFECTSTRUCTURE) > 0) XtraFlags.ImperfectStructure = true.ToString();
|
||
if ((flg & DONTUSEHALFLINES) > 0) XtraFlags.DontUseHalfLines = true.ToString();
|
||
if ((flg & FORTRANFORMATNUMBERS) > 0) XtraFlags.FortranFormatNumbers = true.ToString();
|
||
if ((flg & ALLUNITS) > 0) XtraFlags.AllUnits = true.ToString();
|
||
if ((flg & CAPSTRANSITIONS) > 0) XtraFlags.CapsTransitions = true.ToString();
|
||
}
|
||
else if (i == 1)
|
||
{
|
||
if ((flg & CAPTRANSTEP) > 0) XtraFlags.CapTranStep = true.ToString();
|
||
if ((flg & TSTEPNOFLAG) > 0) XtraFlags.TSTepNoFlag = true.ToString();
|
||
if ((flg & LOWERCASETRANNUMBER) > 0) XtraFlags.LowerCaseTranNumber = true.ToString();
|
||
if ((flg & CONDENSEDCHANGEBAR) > 0) XtraFlags.CondensedChangeBar = true.ToString();
|
||
if ((flg & DOREVDATE) > 0) XtraFlags.DoRevDate = true.ToString();
|
||
if ((flg & SEPARATEBOX) > 0) XtraFlags.SeparateBox = true.ToString();
|
||
if ((flg & NUMBERHIGHLEVELRNO) > 0) XtraFlags.NumberHighLevelRNO = true.ToString();
|
||
if ((flg & ALTERNATEFOLDOUTPAGES) > 0) XtraFlags.AlternateFoldoutPages = true.ToString();
|
||
if ((flg & DONTTRYTOFILLHALFOFPAGE) > 0) XtraFlags.DontTryToFillHalfOfPage = true.ToString();
|
||
}
|
||
else if (i == 2)
|
||
{
|
||
if ((flg & DONTCAPITALIZETITLE) > 0) XtraFlags.DontCapitalizeTitle = true.ToString();
|
||
if ((flg & NOSPACEDOUBLERNO) > 0) XtraFlags.NoSpaceDoubleRNO = true.ToString();
|
||
if ((flg & DONTOFFSETTAB) > 0) XtraFlags.DontOffsetTab = true.ToString();
|
||
if ((flg & UPSETPNTAFTRDASH) > 0) XtraFlags.UpSetpntAftrDash = true.ToString();
|
||
if ((flg & LOWERCASEREVNUM) > 0) XtraFlags.LowerCaseRevnum = true.ToString();
|
||
if ((flg & DONOTCOMPRESSSTEPS) > 0) XtraFlags.DoNotCompressSteps = true.ToString();
|
||
if ((flg & REDUCELINEAFTERNOTEANDCAUT) > 0) XtraFlags.ReduceLineAfterNoteAndCaut = true.ToString();
|
||
if ((flg & RNOSAMELEVEL) > 0) XtraFlags.RNOSameLevel = true.ToString();
|
||
if ((flg & BOLDHIGHLEVELRNO) > 0) XtraFlags.BoldHighLevelRNO = true.ToString();
|
||
if ((flg & ONELINEBEFORENOTECAUTIONTAB) > 0) XtraFlags.OneLineBeforeNoteCautionTab = true.ToString();
|
||
if ((flg & CONTINUOUSCHANGEBARS) > 0) XtraFlags.ContinuousChangeBars = true.ToString();
|
||
}
|
||
else if (i == 3)
|
||
{
|
||
if ((flg & DONTBOXAC) > 0) XtraFlags.DontBoxAC = true.ToString();
|
||
if ((flg & USETOPCONTINUEMESSAGEATEND) > 0) XtraFlags.UseTopContinueMessageAtEnd = true.ToString();
|
||
if ((flg & UPCASETRANAND) > 0) XtraFlags.UpcaseTranAnd = true.ToString();
|
||
if ((flg & UPCASEALLSETPOINTUNITS) > 0) XtraFlags.UpcaseAllSetpointUnits = true.ToString();
|
||
}
|
||
else if (i == 4)
|
||
{
|
||
if ((flg & DEV_FORMAT) > 0) XtraFlags.Dev_Format = true.ToString();
|
||
if ((flg & DONTDOSTEXTRAATTOP) > 0) XtraFlags.DontDoSTExtraAtTop = true.ToString();
|
||
if ((flg & XLINES_STEPFIX) > 0) XtraFlags.Xlines_StepFix = true.ToString();
|
||
if ((flg & REBOXCAUTNOTE) > 0) XtraFlags.ReBoxCautNote = true.ToString();
|
||
if ((flg & IMMSTEPSPCHDR) > 0) XtraFlags.IMMStepSpcHdr = true.ToString();
|
||
if ((flg & FLOATINGCONTINUEMESSAGE) > 0) XtraFlags.FloatingContinueMessage = true.ToString();
|
||
if ((flg & ABSOLUTEFIXEDCHANGECOLUMN) > 0) XtraFlags.AbsoluteFixedChangeColumn = true.ToString();
|
||
if ((flg & LJBORDERLESSTABLE) > 0) XtraFlags.LJBorderlessTable = true.ToString();
|
||
if ((flg & SUPPRESSANDINTRAN) > 0) XtraFlags.SuppressAndInTran = true.ToString();
|
||
if ((flg & CAPHIGHSETPNT) > 0) XtraFlags.CapHighSetpnt = true.ToString();
|
||
if ((flg & CAPSPIFLASTLOWER) > 0) XtraFlags.CapsPIFLastLower = true.ToString();
|
||
if ((flg & CAPFIRSTLETTERINHIGHSP) > 0) XtraFlags.CapFirstLetterInHighSP = true.ToString();
|
||
}
|
||
else if (i == 5)
|
||
{
|
||
if ((flg & ALTERNATEFLOATINGFOLDOUT) > 0) XtraFlags.AlternateFloatingFoldout = true.ToString();
|
||
if ((flg & WRAPSAMEASEDIT) > 0) XtraFlags.WrapSameAsEdit = true.ToString();
|
||
if ((flg & KEEPSTEPSONPAGE) > 0) XtraFlags.KeepStepsOnPage = true.ToString();
|
||
if ((flg & SPECIFIEDSUBSTEPSONLY) > 0) XtraFlags.SpecifiedSubstepsOnly = true.ToString();
|
||
if ((flg & THREEBLANKSABOVENOTESCAUTIONS) > 0) XtraFlags.ThreeBlanksAboveNotesCautions = true.ToString();
|
||
if ((flg & IMPERFECTSUBSTEP) > 0) XtraFlags.ImperfectSubstep = true.ToString();
|
||
if ((flg & DONTBREAKONSECTIONS) > 0) XtraFlags.DontBreakOnSections = true.ToString();
|
||
if ((flg & NOSTEPNUMIFONLYONESTEP) > 0) XtraFlags.NoStepNumIfOnlyOneStep = true.ToString();
|
||
if ((flg & SHOWSECTIONTITLES) > 0) XtraFlags.ShowSectionTitles = true.ToString();
|
||
if ((flg & LJTABS) > 0) XtraFlags.LJTabs = true.ToString();
|
||
if ((flg & DONTNUMBERRNOSUBS) > 0) XtraFlags.DontNumberRNOSubs = true.ToString();
|
||
if ((flg & DROPCHECKOFF) > 0) XtraFlags.DropCheckOff = true.ToString();
|
||
if ((flg & NOCHECKOFFSINRNO) > 0) XtraFlags.NoCheckOffsInRNO = true.ToString();
|
||
}
|
||
else if (i == 6)
|
||
{
|
||
if ((flg & CHGBARMESSAGEFROMEDIT) > 0) XtraFlags.ChgBarMessageFromEdit = true.ToString();
|
||
if ((flg & CHANGEBARTORNOSEP) > 0) XtraFlags.ChangeBarToRNOSep = true.ToString();
|
||
if ((flg & CHGSTYLEPERSECTION) > 0) XtraFlags.ChangeStyleForEverySection = true.ToString();
|
||
if ((flg & SECTIONLEVELFOLDOUTS) > 0) XtraFlags.SectionLevelFoldouts = true.ToString();
|
||
if ((flg & BOXCONTACTIONS) > 0) XtraFlags.BoxContinousActions = true.ToString();
|
||
if ((flg & DOSECTIONTRANS) > 0) XtraFlags.DoSectionTrans = true.ToString();
|
||
if ((flg & UPSPIFPREVUPPER) > 0) XtraFlags.UpSpIfPrevUpper = true.ToString();
|
||
if ((flg & CONTINUESECTIONHEADER) > 0) XtraFlags.ContinueSectionHeader = true.ToString();
|
||
if ((flg & GLOBALPROCINFO) > 0) XtraFlags.GlobalProcInfo = true.ToString();
|
||
if ((flg & COMPRESSHPSUB) > 0) XtraFlags.CompressHPSub = true.ToString();
|
||
if ((flg & BULLETONCONTINUOUS) > 0) XtraFlags.BulletOnContinuous = true.ToString();
|
||
if ((flg & CANCELSECTITLESONS2) > 0) XtraFlags.CancelSecTitlesOnS2 = true.ToString();
|
||
if ((flg & NOENDFORSINGLE) > 0) XtraFlags.NoEndForSingle = true.ToString();
|
||
if ((flg & USEMETASECTIONS) > 0) XtraFlags.UseMetaSections = true.ToString();
|
||
}
|
||
else if (i == 7)
|
||
{
|
||
if ((flg & RNOCONTINUEONLY) > 0) XtraFlags.RNOContinueOnly = true.ToString();
|
||
if ((flg & CAP1STCHARTRANS) > 0) XtraFlags.Cap1stCharTrans = true.ToString();
|
||
if ((flg & DONTPAGINATEONFIRSTSUBSTEP3X) > 0) XtraFlags.DontPaginateOnFirstSubstep3X = true.ToString();
|
||
if ((flg & RNOSEPAFTERAER) > 0) XtraFlags.RNOSepAfterAER = true.ToString();
|
||
if ((flg & REVDATEWITHFORWARDSLASH) > 0) XtraFlags.RevDateWithForwardSlash = true.ToString();
|
||
if ((flg & USEALTERNATESTEPBOX) > 0) XtraFlags.UseAlternateStepBox = true.ToString();
|
||
if ((flg & CANCELSECTITLESONS1) > 0) XtraFlags.CancelSecTitlesOnS1 = true.ToString();
|
||
if ((flg & SPECIALSTEPSFOLDOUT) > 0) XtraFlags.SpecialStepsFoldout = true.ToString();
|
||
if ((flg & UNDERLINEAFTERDASHSPACE) > 0) XtraFlags.UnderlineAfterDashSpace = true.ToString();
|
||
if ((flg & NOSPACEINNOTEORCAUTION) > 0) XtraFlags.NoSpaceInNoteOrCaution = true.ToString();
|
||
if ((flg & USEXTRAREVNUMBER) > 0) XtraFlags.UseXtraRevNumber = true.ToString();
|
||
if ((flg & UNDERLINESETPOINTS) > 0) XtraFlags.UnderlineSetpoints = true.ToString();
|
||
if ((flg & DOSECTIONTRANSTYPEB) > 0) XtraFlags.DoSectionTransTypeB = true.ToString();
|
||
if ((flg & PAGINATEONLOWERSTEPLEVEL) > 0) XtraFlags.PaginateOnLowerStepLevel = true.ToString();
|
||
if ((flg & USETRANSITIONMODIFIER) > 0) XtraFlags.UseTransitionModifier = true.ToString();
|
||
}
|
||
else if (i == 8)
|
||
{
|
||
if ((flg & CUSTOMSPACING) > 0) XtraFlags.CustomSpacing = true.ToString();
|
||
if ((flg & ENHANCEDSHORTFORMDEV) > 0) XtraFlags.EnhancedShortFormDev = true.ToString();
|
||
if ((flg & PAGEBREAKONHIGHLEVELSTEP) > 0) XtraFlags.PageBreakOnHighLevelStep = true.ToString();
|
||
if ((flg & PAGEBREAKONCAUTIONS) > 0) XtraFlags.PageBreakOnCautions = true.ToString();
|
||
if ((flg & PAGEBREAKONNOTES) > 0) XtraFlags.PageBreakOnNotes = true.ToString();
|
||
if ((flg & ALIGNNULLTABWSECTHEAD) > 0) XtraFlags.AlignNullTabWSectHead = true.ToString();
|
||
if ((flg & DONTUSESECTITLES) > 0) XtraFlags.DontUseSecTitles = true.ToString();
|
||
if ((flg & TEXTSUBFOLLOWSTEXTSTYLE) > 0) XtraFlags.TextSubFollowsTextStyle = true.ToString();
|
||
if ((flg & TRANSPROCTITLEINPAREN) > 0) XtraFlags.TranProcTitleInParen = true.ToString();
|
||
if ((flg & HARDSPTRANPROCNUMB) > 0) XtraFlags.HardSpTranProcNumb = true.ToString();
|
||
if ((flg & TREATANDORASSEQUENTIAL) > 0) XtraFlags.TreatAndOrAsSequential = true.ToString();
|
||
if ((flg & DONTSPLITSTEPINPRNTSTEP) > 0) XtraFlags.DontSplitStepInPrntStep = true.ToString();
|
||
if ((flg & LINEABOVEUNDERSECTION) > 0) XtraFlags.LineAboveUnderSection = true.ToString();
|
||
}
|
||
else if (i == 9)
|
||
{
|
||
if ((flg & PICAIGNOREFIVESIXTHS) > 0) XtraFlags.PicaIgnoreFiveSixths = true.ToString();
|
||
if ((flg & SPACEFORNOSECNUMB) > 0) XtraFlags.SpaceFoRNOSecNumb = true.ToString();
|
||
if ((flg & NONEDITABLESTEPS) > 0) XtraFlags.NonEditableSteps = true.ToString();
|
||
if ((flg & BOXEDSUBSTEPS) > 0) XtraFlags.BoxedSubsteps = true.ToString();
|
||
if ((flg & DONTNUMBERHIGHLEVELSTEPS) > 0) XtraFlags.DontNumberHighLevelSteps = true.ToString();
|
||
if ((flg & NOSTEPNUMBERFORHIGHLEVELRNO) > 0) XtraFlags.NoStepNumberForHighLevelRNO = true.ToString();
|
||
if ((flg & PROMPTFORCAUTINTYPE) > 0) XtraFlags.PromptForCautinType = true.ToString();
|
||
if ((flg & CAUTION1SAMEROWASPARENT) > 0) XtraFlags.Caution1SameRowAsParent = true.ToString();
|
||
if ((flg & WOLFCREEKBACKGROUNDFORMAT) > 0) XtraFlags.WolfCreekBackgroundFormat = true.ToString();
|
||
if ((flg & ENHANCEDSTEPNUMFROMPREV) > 0) XtraFlags.EnhancedStepNumFromPrev = true.ToString();
|
||
}
|
||
else if (i == 10)
|
||
{
|
||
if ((flg & CONTROLUNDERLINESTYLE) > 0) XtraFlags.ControlUnderlineStyle = true.ToString();
|
||
if ((flg & MULTIPLECHANGEIDS) > 0) XtraFlags.MultipleChangeIds = true.ToString();
|
||
if ((flg & USEMULTILINESECTIONTITLE) > 0) XtraFlags.UseMultiLineSectionTitle = true.ToString();
|
||
if ((flg & PAGEBREAKONFIRSTBLANKLINE) > 0) XtraFlags.PageBreakOnFirstBlankLine = true.ToString();
|
||
if ((flg & DONTPRINTNOTITLE) > 0) XtraFlags.DontPrintNoTitle = true.ToString();
|
||
if ((flg & NOTESTOFOOTNOTES) > 0) XtraFlags.NotesToFootnotes = true.ToString();
|
||
if ((flg & UNDSPECIALSTEPSFOLDOUT) > 0) XtraFlags.UndSpecialStepsFoldout = true.ToString();
|
||
if ((flg & PUTONPAGEBYITSELF) > 0) XtraFlags.PutOnPageByItself = true.ToString();
|
||
}
|
||
else if (i == 11)
|
||
{
|
||
if ((flg & SECTITLECONTINUE) > 0) XtraFlags.SecTitleContinue = true.ToString();
|
||
if ((flg & CANCELSECTITLESONE0) > 0) XtraFlags.CancelSecTitlesOnE0 = true.ToString();
|
||
if ((flg & METASECTENDMESSAGE) > 0) XtraFlags.MetaSectEndMessage = true.ToString();
|
||
if ((flg & CANCELSECTITLESONE2) > 0) XtraFlags.CancelSecTitlesOnE2 = true.ToString();
|
||
if ((flg & COMPRESSHPSUPER) > 0) XtraFlags.CompressHPSuper = true.ToString();
|
||
}
|
||
else if (i == 12)
|
||
{
|
||
if ((flg & MATCHUPRNOCAUTNOTE) > 0) XtraFlags.MatchUpRNOCautNote = true.ToString();
|
||
if ((flg & PAGINATEATHIGHESTPAGINLEVEL) > 0) XtraFlags.PaginateAtHighestPaginLevel = true.ToString();
|
||
if ((flg & USELONGPROCTITLES) > 0) XtraFlags.UseLongProcTitles = true.ToString();
|
||
if ((flg & SPECIALLANDSCAPEMODE) > 0) XtraFlags.SpecialLandscapeMode = true.ToString();
|
||
if ((flg & RNOINPAGELIST) > 0) XtraFlags.RNOInPagelist = true.ToString();
|
||
if ((flg & STPCAUTNOTETABINPAGELIST) > 0) XtraFlags.StpCautNoteTabInPagelist = true.ToString();
|
||
if ((flg & READONLYTYPEINCONTMSG) > 0) XtraFlags.ReadOnlyTypeInContMsg = true.ToString();
|
||
}
|
||
else if (i == 13)
|
||
{
|
||
if ((flg & CENTERONELINEONLY) > 0) XtraFlags.CenterOneLineOnly = true.ToString();
|
||
if ((flg & TIETABTOLEVEL) > 0) XtraFlags.TieTabToLevel = true.ToString();
|
||
if ((flg & ACCESSORYDOCSINDUPLEX) > 0) XtraFlags.AccessoryDocsInDuplex = true.ToString();
|
||
if ((flg & FOLDOUTSINDUPLEX) > 0) XtraFlags.FoldoutsInDuplex = true.ToString();
|
||
if ((flg & USESTEXTRAREALVALUE) > 0) XtraFlags.UseSTExtraRealValue = true.ToString();
|
||
if ((flg & SUBTABLEGETSUP1LEVEL) > 0) XtraFlags.SubTableGetSup1Level = true.ToString();
|
||
if ((flg & DONTCOUNTFOLDOUTPAGES) > 0) XtraFlags.DontCountFoldoutPages = true.ToString();
|
||
if ((flg & SEARCHALLREPLACEWORDS) > 0) XtraFlags.SearchAllReplaceWords = true.ToString();
|
||
}
|
||
else if (i == 14)
|
||
{
|
||
if ((flg & REMEMBERCAUTIONSANDNOTES) > 0) XtraFlags.RememberCautionsAndNotes = true.ToString();
|
||
if ((flg & RTFADJUSTMENTS) > 0) XtraFlags.RtfAdjustments = true.ToString();
|
||
if ((flg & CENTERONELINEADJUST) > 0) XtraFlags.CenterOneLineAdjust = true.ToString();
|
||
if ((flg & COUNTALLSUBLEVELS) > 0) XtraFlags.CountAllSubLevels = true.ToString();
|
||
if ((flg & DONTREPLACEWORDSINROS) > 0) XtraFlags.DontReplaceWordsInROs = true.ToString();
|
||
if ((flg & HIGHLEVELRNOBEFOREAERSUBSTPS) > 0) XtraFlags.HighLevelRNOBeforeAERSubStps = true.ToString();
|
||
if ((flg & UNDERLINEALLMETATITLES) > 0) XtraFlags.UnderlineAllMetaTitles = true.ToString();
|
||
if ((flg & DONTBREAKCAUTIONSORNOTES) > 0) XtraFlags.DontBreakCautionsOrNotes = true.ToString();
|
||
if ((flg & BOLDONLYSECTIONZERO) > 0) XtraFlags.BoldOnlySectionZero = true.ToString();
|
||
if ((flg & DONTBREAKONRNO) > 0) XtraFlags.DontBreakOnRNO = true.ToString();
|
||
if ((flg & RNOCHECKOFFSAMEASPARENT) > 0) XtraFlags.RNOCheckOffSameAsParent = true.ToString();
|
||
if ((flg & USESTEPTYPEWIDTHOVERRRIDE) > 0) XtraFlags.UseStepTypeWidthOverride = true.ToString();
|
||
if ((flg & WOLFCREEKCKLFORMAT) > 0) XtraFlags.WolfcreekCKLFormat = true.ToString();
|
||
}
|
||
else if (i == 15)
|
||
{
|
||
if ((flg & DONTPAGINATEONFIRSTSUBSTEP2X) > 0) XtraFlags.DontPaginateOnFirstSubStep2X = true.ToString();
|
||
if ((flg & USESTEPTYPEWIDTHOVERRRIDEEDITPRINT) > 0) XtraFlags.UseStepTypeWidthOverrideEditPrint = true.ToString();
|
||
if ((flg & PARTIALSTEPCOMPRESSION) > 0) XtraFlags.PartialStepCompression = true.ToString();
|
||
if ((flg & USESMARTTEMPLATE) > 0) XtraFlags.UseSmartTemplate = true.ToString();
|
||
if ((flg & CHECKOFFONHLSONLY) > 0) XtraFlags.CheckoffOnHLSOnly = true.ToString();
|
||
if ((flg & CAUTION2SAMEROWASPARENT) > 0) XtraFlags.Caution2SameRowAsParent = true.ToString();
|
||
if ((flg & CENTERTEXTWITHINWIDTH) > 0) XtraFlags.CenterTextWithinWidth = true.ToString();
|
||
if ((flg & DONTBREAKEQUIPMENTLIST) > 0) XtraFlags.DontBreakEquipmentList = true.ToString();
|
||
if ((flg & ALWAYSTABCAUTION2) > 0) XtraFlags.AlwaysTabCaution2 = true.ToString();
|
||
if ((flg & VIRTUALDOTINHLSTAB) > 0) XtraFlags.VirtualDotInHLSTab = true.ToString();
|
||
if ((flg & IMPERFECTSTRUCTUREPLUS4) > 0) XtraFlags.ImperfectStructurePlus4 = true.ToString();
|
||
}
|
||
else if (i == 16)
|
||
{
|
||
if ((flg & USERNOTYPEINACTABLE) > 0) XtraFlags.UseRNOTypeInActable = true.ToString();
|
||
if ((flg & ABSOLUTETRANSITIONUPDATE) > 0) XtraFlags.AbsoluteTransitionUpdate = true.ToString();
|
||
if ((flg & SEPARATEBOXCAUTIONS) > 0) XtraFlags.SeparateBoxCautions = true.ToString();
|
||
if ((flg & HLSTEXTINPAGELIST) > 0) XtraFlags.HLSTextInPagelist = true.ToString();
|
||
if ((flg & LOWERCASESTEPINTRAN) > 0) XtraFlags.LowerCaseStepInTran = true.ToString();
|
||
if ((flg & CHANGEBARSONLINKEDTEXT) > 0) XtraFlags.ChangeBarsOnLinkedText = true.ToString();
|
||
if ((flg & QUOTEDSUBSTEPS) > 0) XtraFlags.QuotedSubsteps = true.ToString();
|
||
}
|
||
else if (i == 17)
|
||
{
|
||
if ((flg & OVERRIDEENHANCEDTABS) > 0) XtraFlags.OverrideEnhancedTabs = true.ToString();
|
||
if ((flg & NONEWLINEAFTERRNO) > 0) XtraFlags.NoNewlineAfterRNO = true.ToString();
|
||
if ((flg & DOSECTIONSEPARATORLINE) > 0) XtraFlags.DoSectionSeparatorLine = true.ToString();
|
||
if ((flg & PARENSONEXTPAGENUMTRANS) > 0) XtraFlags.ParensOnExtPagenumTrans = true.ToString();
|
||
if ((flg & ATLEASTTWODIGITSFORHLS) > 0) XtraFlags.AtLeastTwoDigitsForHLS = true.ToString();
|
||
if ((flg & DONTBREAKOPTEQUIPMENTLIST) > 0)
|
||
XtraFlags.DontBreakOptEquipmentList = true.ToString();
|
||
if ((flg & PAGELISTCHANGEIDSWITHCOMMAS) > 0) XtraFlags.PagelistChangeIDsWithCommas = true.ToString();
|
||
if ((flg & DONTSTARTLINEWITHDASH) > 0) XtraFlags.DontStartLineWithDash = true.ToString();
|
||
if ((flg & NOBLANKLINEBEFORESUBSTEP) > 0) XtraFlags.NoBlankLineBeforeSubstep = true.ToString();
|
||
if ((flg & DONTBREAKCAUTIONSNOTESONSUBSTPS) > 0) XtraFlags.DontBreakCautionsNotesOnSubstps = true.ToString();
|
||
if ((flg & DONTCONVERTCARETTODELTA) > 0) XtraFlags.DontConvertCaretToDelta = true.ToString();
|
||
}
|
||
else if (i == 18)
|
||
{
|
||
if ((flg & NORNO) > 0) XtraFlags.NoRNO = true.ToString();
|
||
if ((flg & ONLYSINGLECOLUMN) > 0) XtraFlags.OnlySingleColumn = true.ToString();
|
||
if ((flg & NULLBOX) > 0) XtraFlags.NullBox = true.ToString();
|
||
if ((flg & XCHNGTRANSPFORHARD) > 0) XtraFlags.XChngTranSpForHard = true.ToString();
|
||
if ((flg & WOLFCREEKCKLBACKGNDFORMAT) > 0) XtraFlags.WolfcreekCKLBackgndFormat = true.ToString();
|
||
}
|
||
}
|
||
#endregion
|
||
#region ReadInFile
|
||
private float RowToPoints(int i)
|
||
{
|
||
return (i * 12); // row_in_points = input * 72/6, row = input * 12
|
||
}
|
||
private float ColToPoints(float f, uint style)
|
||
{
|
||
return 72 * (f / CvtFont.CvtFont.GetPrintPitch(style));
|
||
}
|
||
string _AlternateIndex = null;
|
||
int[] rtCheckOffGroups = new int[MAXSTEPS + 1];
|
||
private string _fmtFileName;
|
||
private uint _PlantDefaultFontStyle;
|
||
public bool ReadInFmtFile(ref FormatData fmtdata, ref XtraFlgs XtraFlags, string fname)
|
||
{
|
||
_fmtFileName = fname;
|
||
int[] tmpshort3 = new int[3];
|
||
ArrayList stringoffsets = new ArrayList();
|
||
byte tmpbyte;
|
||
Int16 tmpshort;
|
||
string tmpstr;
|
||
try
|
||
{
|
||
tmpshort = brFmt.ReadInt16();
|
||
fmtdata.Name = GetStringUntilNull(brFmt);
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
tmpshort = brFmt.ReadInt16();
|
||
tmpstr = GetStringUntilNull(brFmt);
|
||
}
|
||
|
||
short vnum = brFmt.ReadInt16(); // number of ints, etc.
|
||
long posatints = brFmt.BaseStream.Position;
|
||
long tstloc = vnum + posatints;
|
||
fmtdata.FontData = new VE_Font(0);
|
||
#region LoadInts
|
||
tmpbyte = brFmt.ReadByte(); // FirstChar
|
||
|
||
// NOTE 16bit had xtraflag as 18 & had a VEAIRFlag. VEAIRFlag actually
|
||
// had some flags used in other formats besides it, so these were rolled
|
||
// into the xtraflag array just to make conversion easier.
|
||
Int16[] xtraflag = new Int16[19];
|
||
for (int i = 0; i < 19; i++)
|
||
{
|
||
xtraflag[i] = brFmt.ReadInt16();
|
||
AddFlags(ref XtraFlags, i, xtraflag[i]);
|
||
}
|
||
// if this format has an associated PSI or TPL file, just read in the string & save
|
||
// it.
|
||
string otherfile = MyPath + @"\" + fname.Substring(0, fname.LastIndexOf(".")) + @".tpl";
|
||
// if this is subformat, the tpl file will be name FNP00.TPL for fnp.x00, using 'fnp' as
|
||
// an example. check for this too.
|
||
bool issub = (fname.ToUpper().Substring(fname.LastIndexOf(".") + 1, 1) == "X");
|
||
if (File.Exists(otherfile) && !issub)
|
||
fmtdata.TPL = FixXmlString(File.ReadAllText(otherfile));
|
||
else
|
||
{
|
||
if (issub)
|
||
{
|
||
string subtpl = fname.Substring(0, fname.LastIndexOf(".")) + fname.Substring(fname.Length - 2, 2);
|
||
otherfile = MyPath + @"\" + subtpl + @".tpl";
|
||
if (File.Exists(otherfile))
|
||
fmtdata.TPL = FixXmlString(File.ReadAllText(otherfile));
|
||
}
|
||
}
|
||
// http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char
|
||
otherfile = MyPath + @"\" + fname.Substring(0, fname.LastIndexOf(".")) + @".ini";
|
||
if (File.Exists(otherfile)) PsiIniToXml(ref fmtdata, otherfile);
|
||
fmtdata.PurchaseOptions = ((E_PurchaseOptions)brFmt.ReadInt16()).ToString();
|
||
fmtdata.ProcData.ProcForeColor = "Black";
|
||
fmtdata.ProcData.ProcBackColor = "White";
|
||
fmtdata.EditData = new GeneralEditor();
|
||
fmtdata.EditData.EMode = ((E_EMode)brFmt.ReadInt16()).ToString();
|
||
fmtdata.SectData = new Section();
|
||
fmtdata.SectData.SectForeColor = "Black";
|
||
fmtdata.SectData.SectBackColor = "White";
|
||
fmtdata.SectData.StepSectionData = new StepSection();
|
||
fmtdata.SectData.StepSectionData.TopRow = (Int16)(RowToPoints(brFmt.ReadInt16()));
|
||
tmpshort = brFmt.ReadInt16(); // Appendlines - not used.
|
||
fmtdata.PrintData = new GeneralPrint();
|
||
fmtdata.PrintData.DoPrnDrvrAdjusts = brFmt.ReadInt16();
|
||
fmtdata.StepData = new Step[MAXSTEPS + 1]; // add 1 for the 'BASE'
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
fmtdata.StepData[i].Type = StepTypes[i];
|
||
fmtdata.StepData[i].ParentType = ParentTypes[i];
|
||
if (i == 1)
|
||
{
|
||
_PlantDefaultFontStyle = brFmt.ReadUInt32();
|
||
fmtdata.StepData[0].Font = new VE_Font(_PlantDefaultFontStyle);
|
||
fmtdata.FontData = fmtdata.StepData[0].Font.Copy();
|
||
//fmtdata.StepData[1].Font will inherit the Base Font
|
||
}
|
||
if (i > 1)
|
||
{
|
||
uint tmpuint = brFmt.ReadUInt32();
|
||
if (i == 40 && tmpuint == 0) // check if RNOtype's font = 0, if so use the plant default
|
||
{
|
||
fmtdata.StepData[i].Font = new VE_Font(_PlantDefaultFontStyle);
|
||
}
|
||
else
|
||
fmtdata.StepData[i].Font = new VE_Font(tmpuint);
|
||
}
|
||
}
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
Int16 tmpcoli = brFmt.ReadInt16();
|
||
int tmpcol = (tmpcoli & 0x0F00) >> 8;
|
||
if (tmpcol > 0 && tmpcol < WinColors.Length)
|
||
fmtdata.StepData[i].StepLayoutData.ForeColor = WinColors[tmpcol];
|
||
else
|
||
fmtdata.StepData[i].StepLayoutData.ForeColor = "Black";
|
||
tmpcol = (tmpcoli & 0xF);
|
||
if (tmpcol > 0 && tmpcol < WinColors.Length)
|
||
fmtdata.StepData[i].StepLayoutData.BackColor = WinColors[tmpcol];
|
||
else
|
||
fmtdata.StepData[i].StepLayoutData.BackColor = "White";
|
||
}
|
||
fmtdata.StepData[0].StepLayoutData.ForeColor = "Black";
|
||
fmtdata.StepData[0].StepLayoutData.BackColor = "White";
|
||
for (int i = 1; i < MAXSTEPS + 1; i++) fmtdata.StepData[i].StepLayoutData.STExtraSpace = (RowToPoints(brFmt.ReadInt16())).ToString();
|
||
fmtdata.StepData[0].StepLayoutData.STExtraSpace = fmtdata.StepData[1].StepLayoutData.STExtraSpace;
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
Int16 itmp = brFmt.ReadInt16();
|
||
if (fmtdata.StepData[i].Font != null && fmtdata.StepData[i].Font.IsBoxed) fmtdata.StepData[i].StepLayoutData.STBoxindex = (itmp + 1).ToString();
|
||
}
|
||
|
||
// Read the tab indexes into a temporary array. Once the tab strings are read
|
||
// in the structure's data will be added.
|
||
Tabindx = new Int16[MAXSTEPS];
|
||
for (int i = 0; i < MAXSTEPS; i++) Tabindx[i] = brFmt.ReadInt16();
|
||
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
fmtdata.StepData[i].StepPrintData = new Print();
|
||
fmtdata.StepData[i].StepPrintData.PosAdjust = ((Int16)(ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle))).ToString();
|
||
}
|
||
|
||
// NOTE a default is added for boxes for the default box for tables, if
|
||
// they are boxed.
|
||
fmtdata.BoxData = new Box[MAXBOXES + 1];
|
||
// convert these to points. Also, each set of data had 24, not 12 box fields, the
|
||
// second twelve for RTF. For now, I'm going to just skip these. They can be added in
|
||
// later
|
||
// Note that the box start (we think) and the box end locations used ELITE, at 12 characters per inch,
|
||
// for locating the line draw/box drawing.
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].Start = ColToPoints(brFmt.ReadInt16(), CvtFont.CvtFont.ELITE);
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadInt16();
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].End = ColToPoints(brFmt.ReadInt16(), CvtFont.CvtFont.ELITE);
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadInt16();
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].TxtStart = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadInt16();
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].TxtWidth = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadInt16();
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].Height = RowToPoints(brFmt.ReadInt16());
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadInt16();
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].TabPos = RowToPoints(brFmt.ReadInt16());
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadInt16();
|
||
tmpshort = brFmt.ReadInt16(); // TransitionCautionOffset
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].Font = LoadVE_Font();
|
||
int tmpint;
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpint = brFmt.ReadInt32();
|
||
for (int i = 0; i < MAXTABS; i++)
|
||
{
|
||
VE_Font st = LoadVE_Font();
|
||
if (i == 0)
|
||
{
|
||
fmtdata.StepData[0].TabData.Font = st == null ? null : st.Copy();
|
||
fmtdata.StepData[0].TabData.Justify = st == null ? "None" : st.FontJustify;
|
||
if (st != null && st.FontCheckOff != "None")
|
||
{
|
||
if (fmtdata.StepData[0].TabData.MacroList == null) fmtdata.StepData[0].TabData.MacroList = new COMacro[1];
|
||
fmtdata.StepData[0].TabData.MacroList[0].Name = "CHECKOFF";
|
||
fmtdata.StepData[0].TabData.MacroList[0].Macro = "C22";
|
||
if (rtCheckOffGroups[0] != 0) fmtdata.StepData[0].TabData.MacroList[0].Grouping = rtCheckOffGroups[0].ToString();
|
||
}
|
||
for (int j = 0; j < MAXSTEPS; j++)
|
||
{
|
||
if (Tabindx[j] == -1)
|
||
{
|
||
fmtdata.StepData[j + 1].TabData.UsePreviousStyle = "True";
|
||
fmtdata.StepData[j + 1].TabData.Font = st == null ? null : st.Copy();
|
||
fmtdata.StepData[j + 1].TabData.Justify = st == null ? "None" : st.FontJustify;
|
||
|
||
if (st != null && st.FontCheckOff != "None")
|
||
{
|
||
fmtdata.StepData[j + 1].TabData.MacroList = new COMacro[1];
|
||
fmtdata.StepData[j + 1].TabData.MacroList[0].Name = "CHECKOFF";
|
||
fmtdata.StepData[j + 1].TabData.MacroList[0].Macro = st.FontCheckOff == "Right" ? "C22" : "M20";
|
||
if (rtCheckOffGroups[j + 1] != 0) fmtdata.StepData[j + 1].TabData.MacroList[0].Grouping = rtCheckOffGroups[j + 1].ToString();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (int j = 0; j < MAXSTEPS; j++)
|
||
{
|
||
if (Tabindx[j] == i)
|
||
{
|
||
fmtdata.StepData[j + 1].TabData.Font = st == null ? null : st.Copy();
|
||
fmtdata.StepData[j + 1].TabData.Justify = st == null ? "None" : st.FontJustify;
|
||
if (st != null && st.FontCheckOff != "None")
|
||
{
|
||
fmtdata.StepData[j + 1].TabData.MacroList = new COMacro[1];
|
||
fmtdata.StepData[j + 1].TabData.MacroList[0].Name = "CHECKOFF";
|
||
fmtdata.StepData[j + 1].TabData.MacroList[0].Macro = st.FontCheckOff == "Right" ? "C22" : "M20";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
fmtdata.StepData[i].StepEditData.AcTable = ((E_AccStep)brFmt.ReadInt16()).ToString();
|
||
if (fmtdata.StepData[i].StepEditData.AcTable == "0")
|
||
fmtdata.StepData[i].StepEditData.AcTable = null;
|
||
}
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
tmpint = brFmt.ReadInt16();
|
||
if (tmpint == 0) tmpint = 1; // everynlines default value should be 1.
|
||
fmtdata.StepData[i].StepLayoutData.EveryNLines = tmpint.ToString();
|
||
}
|
||
for (int i = 1; i < MAXSTEPS + 1; i++) fmtdata.StepData[i].StepLayoutData.SpaceBefore = "0";
|
||
for (int i = 1; i < MAXSTEPS + 1; i++) fmtdata.StepData[i].StepLayoutData.SpaceAfter = RowToPoints(1).ToString();
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
tmpint = brFmt.ReadInt16();
|
||
fmtdata.StepData[i].StepLayoutData.AlwaysUpperCase = tmpint==1?true.ToString():false.ToString();
|
||
}
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectLayData = new StepSectionLayout();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.TopOfPage = new TopOfPg();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.TopOfPage.Font = LoadVE_Font();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.TopOfPage.Row = RowToPoints(brFmt.ReadInt16());
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.TopOfPage.Col = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData = new StepSectionPrint();
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData.ModifiedTextStyle = LoadVE_Font();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.Separator = new Separtr();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.Separator.Font = LoadVE_Font();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.Separator.SeparatorLocation = brFmt.ReadInt16();
|
||
|
||
for (int i = 1; i < MAXSTEPS + 1; i++) fmtdata.StepData[i].StepLayoutData.PageBreakAtTypeChange = (brFmt.ReadInt16()).ToString();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.LastLineToStartStep = RowToPoints(brFmt.ReadInt16());
|
||
|
||
/* To do TextTypeValue - not sure how this is used & where to store it, so temporarily read it in */
|
||
//fmtdata.SectData.StepSectionData.TextTypeValue = new Int16[10];
|
||
//for (int i = 0; i < 10; i++) fmtdata.SectData.StepSectionData.TextTypeValue[i] = brFmt.ReadInt16();
|
||
|
||
Int16[] TextTypeValue = new Int16[10];
|
||
for (int i = 0; i < 10; i++) TextTypeValue[i] = brFmt.ReadInt16();
|
||
|
||
for (int i = 0; i < 10; i++) tmpint = brFmt.ReadInt32(); // DontPrintInSection - not used.
|
||
|
||
tmpshort = brFmt.ReadInt16(); // LeftMarginReset - not used.
|
||
tmpshort = brFmt.ReadInt16(); // OmitErgEopUsage - not used.
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.LineDrawingOption = brFmt.ReadInt16();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.ColS = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectEditData = new StepSectionEdit();
|
||
fmtdata.SectData.StepSectionData.StpSectEditData.ColSScreenAdj = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
fmtdata.SectData.StepSectionData.StpSectEditData.ScrnAdjRNOText = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.ColT = ColToPoints(brFmt.ReadInt16(), 0);
|
||
tmpshort = brFmt.ReadInt16(); // Coltincr - not used
|
||
tmpshort = brFmt.ReadInt16(); // ColTab - not used
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.ColAbs = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.WidT = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
tmpshort = brFmt.ReadInt16(); // WidTab - not used.
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.PMode = brFmt.ReadInt16();
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.MaxRNO = brFmt.ReadInt16();
|
||
|
||
// maxrnotable, colrtable, widstable, and colrscreen all have three values.
|
||
for (int i = 0; i < 3; i++) tmpshort3[i] = brFmt.ReadInt16();
|
||
tmpstr = string.Format("{0},{1},{2}", tmpshort3[0], tmpshort3[1], tmpshort3[2]);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.MaxRNOTable = tmpstr;
|
||
|
||
float[] tmpfloat = new float[3];
|
||
for (int i = 0; i < 3; i++) tmpfloat[i] = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
tmpstr = string.Format("{0},{1},{2}", tmpfloat[0], tmpfloat[1], tmpfloat[2]);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.ColRTable = tmpstr;
|
||
|
||
float[] tmpfloata = new float[3];
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
tmpfloat[i] = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
tmpfloata[i] = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
}
|
||
tmpstr = string.Format("{0},{1},{2}", tmpfloat[0], tmpfloat[1], tmpfloat[2]);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.WidSTableEdit = tmpstr;
|
||
tmpstr = string.Format("{0},{1},{2}", tmpfloata[0], tmpfloata[1], tmpfloata[2]);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.WidSTablePrint = tmpstr;
|
||
|
||
for (int i = 0; i < 3; i++) tmpfloat[i] = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
tmpstr = string.Format("{0},{1},{2}", tmpfloat[0], tmpfloat[1], tmpfloat[2]);
|
||
fmtdata.SectData.StepSectionData.StpSectEditData.ColRScreen = tmpstr;
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.AdjRNOCol = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
|
||
ChangeBar cb = new ChangeBar();
|
||
|
||
cb.ChangeBarMessage = ((E_ChangeBarMessage)brFmt.ReadUInt16()).ToString();
|
||
|
||
cb.FixedChangeColumn = brFmt.ReadInt16();
|
||
cb.FixedAERChangeColumn = brFmt.ReadByte();
|
||
|
||
//read in a number of format items that are not supported...
|
||
for (int i = 0; i < 3; i++) tmpshort3[i] = brFmt.ReadInt16(); // BD_PageNumOnCover - not used.
|
||
|
||
tmpshort = brFmt.ReadInt16(); // VESearchLeftMargin - not used (same for rest that list varname.
|
||
tmpshort = brFmt.ReadInt16(); // VEStdPrtLeftMarE
|
||
tmpshort = brFmt.ReadInt16(); // VEStdPrtLeftMarP
|
||
|
||
int tmplong = brFmt.ReadInt32(); // ImperfectSTructureSepStyle
|
||
tmpshort = brFmt.ReadInt16(); // FormsLPI
|
||
tmplong = brFmt.ReadInt32(); // FormsStyle
|
||
tmplong = brFmt.ReadInt32(); // FormsBoxStyle
|
||
tmpshort = brFmt.ReadInt16(); // FormsMargin
|
||
tmpshort = brFmt.ReadInt16(); // ChangeSummaryLPI
|
||
|
||
cb.ChangeSummaryStyle = brFmt.ReadInt32(); // this may be moved into a different struct
|
||
cb.ChangeBarStyle = brFmt.ReadInt32();
|
||
fmtdata.ProcData.ChangeBarData = cb;
|
||
|
||
for (int i = 0; i < 30; i++) tmpshort = brFmt.ReadInt16(); // XPosition
|
||
|
||
fmtdata.ProcData.TitleLength = brFmt.ReadInt16();
|
||
fmtdata.ProcData.CoverTitleLength = brFmt.ReadInt16();
|
||
|
||
fmtdata.ProcData.CheckOffData = new CheckOffData();
|
||
// for the Base format, set the Default Change bar locations from hardcoded
|
||
// data in the 16-bit program: (ovrchgbr.c)
|
||
if (!HasBase) fmtdata.ProcData.ChangeBarData.DefaultCBLoc = "0,85,-85,-3";
|
||
int[] rightCheckOffBox = new int[4];
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
rightCheckOffBox[i] = brFmt.ReadInt16();
|
||
}
|
||
int DefaultCheckOffType = (rightCheckOffBox[2] > 0) ? rightCheckOffBox[2] : rightCheckOffBox[3] >> 8;
|
||
fmtdata.ProcData.CheckOffData.AllowSectEdit = DefaultCheckOffType == 1 || (rightCheckOffBox[0] > 0 || rightCheckOffBox[1] > 0) ? "True" : "False";
|
||
fmtdata.ProcData.CheckOffData.AllowStepEdit = DefaultCheckOffType >= 1 ? "True" : "False";
|
||
tmpshort = brFmt.ReadInt16(); // TwoCheckOffs
|
||
fmtdata.ProcData.CheckOffData.CheckOffList = new CheckOff[MAXCHECKOFFS];
|
||
for (int i = 0; i < MAXCHECKOFFS; i++) fmtdata.ProcData.CheckOffData.CheckOffList[i].Index = i;
|
||
for (int i = 0; i < MAXCHECKOFFS; i++) fmtdata.ProcData.CheckOffData.CheckOffList[i].UIMark = brFmt.ReadByte();
|
||
for (int i = 0; i < MAXCHECKOFFS; i++) fmtdata.ProcData.CheckOffData.CheckOffList[i].CheckOffXtraLines = brFmt.ReadByte(); // CheckOffXtraLines
|
||
for (int i = 0; i < MAXCHECKOFFS; i++) fmtdata.ProcData.CheckOffData.CheckOffList[i].CheckOffWidAdjust = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
for (int i = 0; i < MAXCHECKOFFS; i++) tmpbyte = brFmt.ReadByte(); // CheckOffFeatures
|
||
fmtdata.ProcData.CheckOffData.CheckOffHeaderList = new CheckOffHeader[MAXCHKHEADINGS];
|
||
for (int i = 0; i < MAXCHKHEADINGS; i++) fmtdata.ProcData.CheckOffData.CheckOffHeaderList[i].Index = i;
|
||
for (int i = 0; i < MAXCHKHEADINGS; i++) fmtdata.ProcData.CheckOffData.CheckOffHeaderList[i].Font = LoadVE_Font();
|
||
fmtdata.ProcData.CheckOffData.UseCheckOffsIn = brFmt.ReadInt32();
|
||
// 16 bit code was defaulting to Elite when calculating the starting location of the check off line.
|
||
// so use elite: 72 points per inch, 12 chars per inch
|
||
int tmpcolco = (rightCheckOffBox[3] & 0xFF) * 72/12;
|
||
if (tmpcolco > 0) fmtdata.ProcData.CheckOffData.XLocation = (float)tmpcolco; // ColToPoints((float)tmpcolco, _PlantDefaultFontStyle);
|
||
tmplong = (int)brFmt.ReadUInt32();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.EndMessagePos = brFmt.ReadInt16();
|
||
tmpshort = brFmt.ReadInt16(); // CenterTableAdjustment
|
||
tmpshort = brFmt.ReadInt16(); // NumberOfLinesForNoteOrCaution
|
||
|
||
//for (int i = 0; i < MAXSEQ; i++) fmtdata.SectData.StepSectionData.SeqStart[i] = brFmt.ReadByte();
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat = new SeqTabFmt[MAXSEQ];
|
||
for (int i = 0; i < MAXSEQ; i++)
|
||
{
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken = ConvertSeqStart(brFmt.ReadByte());
|
||
}
|
||
|
||
//fmtdata.SectData.StepSectionData.HighSeqStart = brFmt.ReadByte();
|
||
tmpbyte = brFmt.ReadByte(); // HighSeqStart
|
||
fmtdata.SectData.StepSectionData.IndentToken = brFmt.ReadByte();
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData.ImmStepHdrCol = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData.ImmStepHdrStyle = LoadVE_Font();
|
||
|
||
ReplaceStr[] repstr = new ReplaceStr[MAXREPLACE];
|
||
fmtdata.SectData.ReplaceStrData = repstr;
|
||
for (int i = 0; i < 60; i++) repstr[i].Flag = ((E_ReplaceStr)brFmt.ReadUInt32()).ToString();
|
||
|
||
//for (int i = 0; i < 2; i++) tmpshort3[i] = brFmt.ReadInt16();
|
||
//tmpstr = string.Format("{0},{1}", tmpshort3[0], tmpshort3[1]);
|
||
tmpstr = "";
|
||
for (int i = 0; i < 2; i++)
|
||
{
|
||
tmpstr += ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle).ToString();
|
||
//tmpstr += ((float)(brFmt.ReadInt16() * 7.2)).ToString();
|
||
if (i == 0) tmpstr += ",";
|
||
}
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.RNOWidthAlt = tmpstr;
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.HLSWidthOVRD = brFmt.ReadInt16();
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData.SecColHdrforActPMode = brFmt.ReadInt16();
|
||
|
||
for (int i = 0; i < MAXSTEPS + 1; i++) fmtdata.StepData[i].Index = i;
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
tmpbyte = brFmt.ReadByte();
|
||
fmtdata.StepData[i].StepLayoutData.AlignWithParentTab = tmpbyte == 1 ? true.ToString() : false.ToString();
|
||
}
|
||
|
||
fmtdata.SectData.SectionNumber = new SectionNum();
|
||
fmtdata.SectData.SectionHeader = new SectionHead();
|
||
fmtdata.SectData.SectionNumber.Font = LoadVE_Font();
|
||
fmtdata.SectData.SectionHeader.Font = LoadVE_Font();
|
||
fmtdata.SectData.SectionNumber.Pos = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
fmtdata.SectData.SectionNumber.Just = ((E_PageStructMod)brFmt.ReadByte()).ToString();
|
||
fmtdata.SectData.SectionHeader.Pos = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle);
|
||
fmtdata.SectData.SectionHeader.Just = ((E_PageStructMod)brFmt.ReadByte()).ToString();
|
||
|
||
for (int i = 0; i < 10; i++) tmpbyte = brFmt.ReadByte(); // SecLevelDelta
|
||
fmtdata.SectData.SectionTitleLength = brFmt.ReadInt16();
|
||
tmpshort = brFmt.ReadInt16();
|
||
|
||
rtCheckOffGroups[0] = 0;
|
||
for (int i = 1; i < MAXSTEPS + 1; i++) rtCheckOffGroups[i] = (brFmt.ReadInt16());
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
// if the grouping is > 0, then use the 'right check off' macro WHEN there
|
||
// are more than rtCheckOffGroups[i] of the step type.
|
||
if (rtCheckOffGroups[i] != 0)
|
||
{
|
||
if (fmtdata.StepData[i].TabData.MacroList == null)
|
||
{
|
||
fmtdata.StepData[i].TabData.MacroList = new COMacro[1];
|
||
fmtdata.StepData[i].TabData.MacroList[0].Name = "CHECKOFF";
|
||
fmtdata.StepData[i].TabData.MacroList[0].Macro = "C22";
|
||
}
|
||
fmtdata.StepData[i].TabData.MacroList[0].Grouping = rtCheckOffGroups[i].ToString();
|
||
}
|
||
}
|
||
for (int i = 0; i < 100; i++) tmpshort = brFmt.ReadInt16(); // TypeGroups
|
||
for (int i = 0; i < 20; i++) tmpshort = brFmt.ReadInt16(); // EnhancedSubTypes;
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.SubPaginationWght = brFmt.ReadInt16();
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.TextTitleAdjustment = brFmt.ReadInt16();
|
||
|
||
for (int i = 1; i < MAXSTEPS + 1; i++) tmpshort = brFmt.ReadInt16(); // STAfterLines
|
||
|
||
fmtdata.TransData.TransTypeData = new TransTypes[MAXTRANS];
|
||
for (int i = 0; i < MAXTRANS; i++)
|
||
{
|
||
fmtdata.TransData.TransTypeData[i].TransType = brFmt.ReadByte();
|
||
if (i < 6 && fmtdata.TransData.TransTypeData[i].TransType == 0) fmtdata.TransData.TransTypeData[i].TransType = (byte)i;
|
||
}
|
||
for (int i = 0; i < MAXTRANS; i++) tmpbyte = brFmt.ReadByte(); // TransMode
|
||
for (int i = 0; i < MAXTRANS; i++) tmpbyte = brFmt.ReadByte(); // OutsideTransType
|
||
|
||
for (int i = 1; i < MAXSTEPS+1; i++)
|
||
{
|
||
tmpshort = brFmt.ReadInt16();
|
||
fmtdata.StepData[i].WidthOverride = (ColToPoints((tmpshort & 0x00FF), _PlantDefaultFontStyle)).ToString();
|
||
fmtdata.StepData[i].WidthOverrideEdit = (ColToPoints(((tmpshort & 0xFF00) >> 8), _PlantDefaultFontStyle)).ToString();
|
||
}
|
||
|
||
// auto table of contents data
|
||
AccSection accsec = new AccSection();
|
||
|
||
TOC toc = new TOC();
|
||
// the toc position values are all 12 CPI regardless of font used (according to a comment in
|
||
// the wcn1 format files.
|
||
float tmpfloat1 = Convert.ToInt16(brFmt.ReadSByte());
|
||
toc.TofCSecNumPos = 72 * (tmpfloat1 / 12); // 12cpi
|
||
tmpfloat1 = Convert.ToInt16(brFmt.ReadSByte());
|
||
toc.TofCSecTitlePos = 72 * (tmpfloat1 / 12); // 12cpi
|
||
tmpbyte = brFmt.ReadByte(); // TofCSecTitlePos2
|
||
toc.TofCSecTitleLen = brFmt.ReadByte();
|
||
tmpfloat1 = Convert.ToInt16(brFmt.ReadSByte());
|
||
toc.TofCPageNumPos = 72 * (tmpfloat1 / 12);
|
||
byte tofCSpaceChar = brFmt.ReadByte();
|
||
toc.TofCSpaceChar = tofCSpaceChar == 0 ? null : Convert.ToString(Convert.ToChar(tofCSpaceChar));
|
||
toc.TofCLineSpacing = brFmt.ReadByte();
|
||
toc.Font = LoadVE_FontByte(); ;
|
||
accsec.TableOfContentsData = toc;
|
||
for (int i = 0; i < MAXSTEPS; i++) tmpbyte = brFmt.ReadByte();
|
||
|
||
fmtdata.ProcData.CheckOffData.CheckOffAdjustment = ColToPoints(Convert.ToInt16(brFmt.ReadSByte()), _PlantDefaultFontStyle);
|
||
|
||
tmpshort = brFmt.ReadInt16(); // ColsAdjustInS2
|
||
tmpbyte = brFmt.ReadByte(); // SeriesTitleLength;
|
||
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
sbyte[] vp = new sbyte[15];
|
||
for (int j = 0; j < 15; j++) vp[j] = brFmt.ReadSByte();
|
||
bool hasdata = false;
|
||
for (int j = 0; j < 15; j++)
|
||
{
|
||
if (vp[j] != '\0')
|
||
{
|
||
hasdata = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!hasdata)
|
||
fmtdata.StepData[i].VertPos = null;
|
||
else
|
||
{
|
||
fmtdata.StepData[i].VertPos = null;
|
||
for (int j = 0; j < 15; j++)
|
||
fmtdata.StepData[i].VertPos = fmtdata.StepData[i].VertPos + string.Format("{0},", ColToPoints(vp[j], _PlantDefaultFontStyle));
|
||
fmtdata.StepData[i].VertPos = fmtdata.StepData[i].VertPos.Substring(0, fmtdata.StepData[i].VertPos.Length - 1); // remove last ","
|
||
}
|
||
}
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.VertStyle = LoadVE_Font();
|
||
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
tmpfloat[i] = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
}
|
||
tmpstr = string.Format("{0},{1},{2}", tmpfloat[0], tmpfloat[1], tmpfloat[2]);
|
||
fmtdata.SectData.StepSectionData.StpSectLayData.TableCenterPos = tmpstr;
|
||
for (int i = 0; i < MAXSEQ; i++) fmtdata.SectData.StepSectionData.SequentialTabFormat[i].Index = i;
|
||
LeftJustify[] lftjust = new LeftJustify[MAXSEQ];
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData.LeftJustifyList = lftjust;
|
||
for (int i = 0; i < MAXSEQ; i++)
|
||
{
|
||
lftjust[i].Index = i;
|
||
lftjust[i].Size = ColToPoints(brFmt.ReadInt16(), _PlantDefaultFontStyle); //brFmt.ReadInt16();
|
||
}
|
||
MetaSection[] metsects = new MetaSection[10];
|
||
fmtdata.SectData.MetaSectionData = metsects;
|
||
for (int i = 0; i < 10; i++) metsects[i].Index = i;
|
||
for (int i = 0; i < 10; i++) metsects[i].SecNumPositionAdj = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
for (int i = 0; i < 10; i++) metsects[i].SecTitlePositionAdj = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
for (int i = 0; i < 10; i++) metsects[i].ColSByLevel = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
for (int i = 0; i < 10; i++) metsects[i].TofCPositionAdj = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
for (int i = 0; i < 10; i++) metsects[i].WidSAdjByLevel = ColToPoints(brFmt.ReadSByte(), _PlantDefaultFontStyle);
|
||
|
||
fmtdata.SectData.StepSectionData.NumberOfHighLevelSteps = brFmt.ReadByte();
|
||
|
||
for (int i = 0; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].Index = i;
|
||
for (int i = 1; i < MAXBOXES + 1; i++) fmtdata.BoxData[i].TxtRowAdj = brFmt.ReadSByte();
|
||
for (int i = 1; i < MAXBOXES + 1; i++) tmpshort = brFmt.ReadByte();
|
||
|
||
for (int i = 1; i < MAXSTEPS+1; i++)
|
||
{
|
||
tmpshort = brFmt.ReadInt16();
|
||
fmtdata.StepData[i].ColOverride = (ColToPoints((tmpshort & 0x00FF), _PlantDefaultFontStyle)).ToString();
|
||
fmtdata.StepData[i].ColOverrideEdit = (ColToPoints(((tmpshort & 0xFF00)>>8), _PlantDefaultFontStyle)).ToString();
|
||
}
|
||
|
||
fmtdata.SectData.StepSectionData.NumberOfSubStepTypes = brFmt.ReadByte();
|
||
|
||
accsec.AutoContActSumSection = brFmt.ReadInt32();
|
||
fmtdata.SectData.AccSectionData = accsec;
|
||
#endregion
|
||
#region LoadStrings
|
||
long floc = brFmt.BaseStream.Position;
|
||
//////////////////
|
||
// STRINGS NOW
|
||
/////////////////
|
||
|
||
brFmt.BaseStream.Seek(tstloc, SeekOrigin.Begin);
|
||
short numstr = brFmt.ReadInt16();
|
||
short len = brFmt.ReadInt16();
|
||
byte[] input = GetByteArray(brFmt, len);
|
||
|
||
// now load in the offset info for data.
|
||
// read in the offsets from the begining of tmpstr
|
||
// this allows us to conserve on memory because duplicate strings
|
||
// will only be held once
|
||
//
|
||
Int16[] offset = new Int16[numstr];
|
||
int indx;
|
||
for (int i = 0; i < numstr; i++) offset[i] = brFmt.ReadInt16();
|
||
|
||
// Add the default box characters to be used.
|
||
fmtdata.BoxData[0].BXULC = ConvertText("\x0DA");
|
||
fmtdata.BoxData[0].BXHorz = ConvertText("\x0C4");
|
||
fmtdata.BoxData[0].BXURC = ConvertText("\x0BF");
|
||
fmtdata.BoxData[0].BXVert = ConvertText("\x0B3");
|
||
fmtdata.BoxData[0].BXMLS = ConvertText("\x0C3");
|
||
fmtdata.BoxData[0].BXMRS = ConvertText("\x0B4");
|
||
fmtdata.BoxData[0].BXLLC = ConvertText("\x0C0");
|
||
fmtdata.BoxData[0].BXLRC = ConvertText("\x0D9");
|
||
fmtdata.BoxData[0].BXMID = ConvertText("\x0C5");
|
||
fmtdata.BoxData[0].BXUMID = ConvertText("\x0C2");
|
||
fmtdata.BoxData[0].BXLMID = ConvertText("\x0C1");
|
||
|
||
// using offsets, get data & put into fields.
|
||
int arcnt = 1; // use this to count into offset array for data.
|
||
for (int i = 1; i < MAXBOXES + 1; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXURC = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXHorz = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXULC = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXVert = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXMLS = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXMRS = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXLRC = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXLLC = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXMID = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXLHorz = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXUMID = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.BoxData[i].BXLMID = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
// increment arcnt by 144 because there were 24 box possibilities in the
|
||
// 16bit the second 12 were rtf
|
||
arcnt = arcnt + 144;
|
||
|
||
//tabs
|
||
string[,] tabstrings = new string[MAXTABS, 2];
|
||
for (int i = 0; i < MAXTABS; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) tabstrings[i, 0] = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) tabstrings[i, 1] = GetStringFromByte(input, indx);
|
||
}
|
||
NBRSub = fmtdata.SectData.StepSectionData.NumberOfSubStepTypes != 0 ? fmtdata.SectData.StepSectionData.NumberOfSubStepTypes : NBRSub;
|
||
for (int i = 0; i < MAXSTEPS; i++)
|
||
{
|
||
for (int j = 0; j < MAXTABS; j++)
|
||
{
|
||
if (Tabindx[i] == j)
|
||
{
|
||
fmtdata.StepData[i + 1].TabData.IdentEdit = DoTabs(fmtdata.StepData[i].TabData.Font, fmtdata.PurchaseOptions, i, tabstrings[j, 0], true);
|
||
//fmtdata.StepData[i + 1].TabData.IdentEditWid = CalculateTabWid(tabstrings[j, 0]).ToString();
|
||
fmtdata.StepData[i + 1].TabData.Ident = DoTabs(fmtdata.StepData[i].TabData.Font, fmtdata.PurchaseOptions, i, tabstrings[j, 1], true);
|
||
//fmtdata.StepData[i + 1].TabData.IdentWid = CalculateTabWid(tabstrings[j, 1]).ToString();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// separators
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
// differentiate between an empty string and null. An empty string is used to put out
|
||
// blank lines. A null string means there is not any separator, thus use the string "{Null}"
|
||
// so that inheritance tests can show a difference between having a separator and not having one.
|
||
if (indx > 0) fmtdata.StepData[i].Sep = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
else fmtdata.StepData[i].Sep = "{Null}";
|
||
}
|
||
|
||
// Step prefix & suffix
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.StepData[i].Prefix = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
}
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.StepData[i].Suffix = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
}
|
||
|
||
// IdentB & SeqTab
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.IdentB = GetStringFromByte(input, indx);
|
||
for (int i = 0; i < MAXSEQ; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0)
|
||
{
|
||
string p = GetStringFromByte(input, indx); // seqtab.
|
||
if (p != null)
|
||
{
|
||
if (p[0] == '+')
|
||
{
|
||
string tmp = null;
|
||
if (fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken.IndexOf("{numeric}") > -1)
|
||
{
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken = fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken.Replace("{numeric}", "{numericWpar}");
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = p.Replace("+", "{seq}");
|
||
}
|
||
else if (fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken.IndexOf("{alpha}") > -1)
|
||
{
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken = fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken.Replace("{alpha}", "{alphaWpar}");
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = p.Replace("+", "{seq}");
|
||
}
|
||
else if (fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken.IndexOf("{ALPHA}") > -1)
|
||
{
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken = fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabToken.Replace("{ALPHA}", "{ALPHAWpar}");
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = p.Replace("+", "{seq}");
|
||
}
|
||
else
|
||
tmp = p.Replace("+", "{UNKNOWNWpar}");
|
||
}
|
||
else
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = "{seq}" + p;
|
||
}
|
||
else
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = null;
|
||
}
|
||
else
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = null;
|
||
//if (indx > 0) fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat + GetStringFromByte(input, indx);
|
||
}
|
||
// replace word strings
|
||
for (int i = 0; i < MAXREPLACE; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) repstr[i].ReplaceWord = DoReplaceTokens(GetStringFromByteNoConvert(input, indx));
|
||
}
|
||
for (int i = 0; i < MAXREPLACE; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) repstr[i].ReplaceWith = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
}
|
||
|
||
// various proc matching/data
|
||
ProcDescr[] pd = new ProcDescr[10];
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) pd[i].MatchProcNumber = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) pd[i].ProcDescr1 = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) pd[i].ProcDescr2 = GetStringFromByte(input, indx);
|
||
}
|
||
fmtdata.PrintData.ProcDescrList = pd;
|
||
|
||
string[] Versid = new string[5];
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) Versid[i] = GetStringFromByte(input, indx);
|
||
}
|
||
fmtdata.PrintData.VersionIdText = Versid;
|
||
|
||
// a few transition strings
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.TransData.DelimiterForTransitionTitle = GetStringFromByte(input, indx);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.TransData.StepSubstepDelimeter = GetStringFromByte(input, indx);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
// Replace the <20> with a blank, one of the formats (cpla - robinson) used this to flag
|
||
// an underline for step numbers in transitions, but this format is no longer used.
|
||
if (indx > 0) fmtdata.TransData.ThroughString = GetStringFromByte(input, indx).Replace('<27>', ' ');
|
||
|
||
// procedure suffix data
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.ProcData.ProcedureSuffixFlags = GetStringFromByte(input, indx);
|
||
|
||
fmtdata.ProcData.ProcedureSuffix = new string[10];
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.ProcData.ProcedureSuffix[i] = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
// PlantDnLoad not used - skip it.
|
||
arcnt++;
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.PrintData.TopOfPageThing = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
|
||
// not used: xtitle[3][10] - skip 30
|
||
arcnt = arcnt + 30;
|
||
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
fmtdata.StepData[i].Inactive = Inactive[i];
|
||
fmtdata.StepData[i].StepEditData.Searchable = Searchable[i];
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.MenuItem = TypeMenuItem[i];
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.InMenu = (fmtdata.StepData[i].Type == "RNOType" || fmtdata.StepData[i].Type == "Base") ? false.ToString() : true.ToString();
|
||
|
||
// Set all caution/note 'InMenu' to false except basic caution/note, types 6 & 7. Use the AlternateNameList to set them to true.
|
||
if (i == 20 || i == 21 || i == 22 || i == 23 || i == 26 || i == 27 || i == 28 || i == 29 || i == 32) fmtdata.StepData[i].StepEditData.TypeMenu.InMenu = false.ToString();
|
||
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.NoChgReason = NoChangeTypeReason[i];
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.RnoInMenu = RnoInMenu[i];
|
||
if (fmtdata.StepData[i].Type == "Figure")
|
||
//{
|
||
//fmtdata.StepData[i].StepEditData.TypeMenu.RnoInMenu = true.ToString();
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.RnoMenuItem = "With Border";
|
||
//}
|
||
else if (fmtdata.StepData[i].Type == "Table")
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.RnoMenuItem = "Table";
|
||
else if (fmtdata.StepData[i].Type == "BorderlessTable" || fmtdata.StepData[i].Type == "BorderlessFigure")
|
||
//{
|
||
//fmtdata.StepData[i].StepEditData.TypeMenu.RnoInMenu = true.ToString();
|
||
fmtdata.StepData[i].StepEditData.TypeMenu.RnoMenuItem = "Without Border";
|
||
|
||
//}
|
||
//else if (fmtdata.StepData[i].Type == "AERTable" || fmtdata.StepData[i].Type == "BorderlessAERTable" || fmtdata.StepData[i].Type == "AERFigure" || fmtdata.StepData[i].Type == "BorderlessAERFigure")
|
||
// fmtdata.StepData[i].StepEditData.TypeMenu.RnoInMenu = false.ToString();
|
||
if (fmtdata.StepData[i].Type.Contains("Borderless") && fmtdata.StepData[i].Type.Contains("Table")) fmtdata.StepData[i].Inactive = true.ToString();
|
||
}
|
||
// fmtdata.SectData.StepSectionData.TextType = new string[10];
|
||
// Set up the text type fields - these are used to define what types of steps the current step
|
||
// can be changed to..
|
||
_AlternateIndex = null;
|
||
int[] tmparray ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0)
|
||
{
|
||
string tmpstring = GetStringFromByte(input, indx);
|
||
// put this in the step data alternatename field. If there already is one. stop
|
||
// here for now to see this!.
|
||
//if (fmtdata.StepData[TextTypeValue[i] + 1].StepEditData.TypeMenu.MenuItem != null && fmtdata.StepData[TextTypeValue[i] + 1].StepEditData.TypeMenu.MenuItem != tmpstring)
|
||
// Console.WriteLine("different name, " + fmtdata.StepData[TextTypeValue[i] + 1].StepEditData.TypeMenu.MenuItem + ", " + tmpstring);
|
||
fmtdata.StepData[TextTypeValue[i] + 1].StepEditData.TypeMenu.MenuItem = tmpstring;
|
||
|
||
_AlternateIndex = (_AlternateIndex == null) ? fmtdata.StepData[TextTypeValue[i] + 1].Type : _AlternateIndex + "," + fmtdata.StepData[TextTypeValue[i] + 1].Type;
|
||
//fmtdata.SectData.StepSectionData.TextType[i] = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
}
|
||
if (_AlternateIndex != null)
|
||
{
|
||
// For any step types in the texttypevalue list, add the alternatename list:
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
// this was only used for cautions/notes - so only add if texttypevalue isn't 0, 0 was substep and it
|
||
// was getting set for substeps, that can never have an alternate type - at least from
|
||
// format->xml migration.
|
||
if (TextTypeValue[i] != 0)
|
||
{
|
||
fmtdata.StepData[TextTypeValue[i] + 1].StepEditData.TypeMenu.AlternateNameList = _AlternateIndex;
|
||
fmtdata.StepData[TextTypeValue[i] + 1].StepEditData.TypeMenu.InMenu = true.ToString();
|
||
}
|
||
}
|
||
}
|
||
// not used, SectionsToPrint - 10; SectionNumberMask - 10; SectionsToPrintTitle - 10;
|
||
// DocumentTitleExtensions - 10; DocumentFixFileExtensions - 10;
|
||
|
||
arcnt = arcnt + 50;
|
||
|
||
// some seqtab data.
|
||
string[] tmpSeqStrings = new string[MAXSEQ];
|
||
for (int i = 0; i < MAXSEQ; i++)
|
||
{
|
||
tmpSeqStrings[i] = fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat;
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) // PreSeqTab - Edit
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat = GetStringFromByte(input, indx) + tmpSeqStrings[i];
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) // PreSeqTab - Print
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].PrintTabFormat = GetStringFromByte(input, indx).Replace("\x08", "{0x08}") + tmpSeqStrings[i];
|
||
else
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].PrintTabFormat = tmpSeqStrings[i];
|
||
//tmpstr = GetStringFromByte(input, indx).Replace("\x08", "");
|
||
}
|
||
for (int i = 0; i < MAXSEQ; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) // PostSeqTab - Edit
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].TabFormat += GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) // PostSeqTab - Print
|
||
fmtdata.SectData.StepSectionData.SequentialTabFormat[i].PrintTabFormat += GetStringFromByte(input, indx);
|
||
}
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectPrtData.RNOSepString = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
|
||
fmtdata.SectData.StepSectionData.UnderlineTerminate = new string[10];
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.UnderlineTerminate[i] = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
fmtdata.SectData.StepSectionData.StpSectPrtData.ImmStepHdr = new string[2];
|
||
for (int i = 0; i < 2; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectPrtData.ImmStepHdr[i] = GetStringFromByte(input, indx);
|
||
}
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.StepData[this.altsteps[i]].StepEditData.TypeMenu.MenuItem = GetStringFromByte(input, indx);
|
||
//if (indx > 0) fmtdata.StepData[TextTypeValue[i]].StepEditData.TypeMenu.MenuItem = GetStringFromByte(input, indx);
|
||
}
|
||
string mytmp = null;
|
||
for (int i = 0; i < 16; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.StepData[this.altsubsteps[i]].StepEditData.TypeMenu.MenuItem = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.ProcData.ChangeBarData.SpecialChangeBar = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
|
||
// not used - ImperfectStructureSeparator
|
||
arcnt++;
|
||
|
||
fmtdata.SectData.StepSectionData.ObserveNCString1 = new string[4];
|
||
fmtdata.SectData.StepSectionData.ObserveNCString2 = new string[4];
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.ObserveNCString1[i] = DoReplaceTokens(GetStringFromByteNoConvert(input, indx));
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.ObserveNCString2[i] = DoReplaceTokens(GetStringFromByteNoConvert(input, indx));
|
||
}
|
||
|
||
for (int i = 1; i < MAXSTEPS + 1; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0)
|
||
fmtdata.StepData[i].UnderlineTheseChar = GetStringFromByte(input, indx);
|
||
}
|
||
|
||
// not used - SubScriptTheseChar
|
||
arcnt++;
|
||
|
||
bool hasMenuItem = false;
|
||
for (int i = 0; i < MAXCHECKOFFS; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0)
|
||
{
|
||
fmtdata.ProcData.CheckOffData.CheckOffList[i].MenuItem = GetStringFromByte(input, indx);
|
||
hasMenuItem = true;
|
||
}
|
||
}
|
||
|
||
if (hasMenuItem)
|
||
{
|
||
fmtdata.ProcData.CheckOffData.Menu = "Checkoff";
|
||
for (int i = 0; i < MAXCHECKOFFS; i++)
|
||
if (i > 1) fmtdata.ProcData.CheckOffData.CheckOffList[i].Macro = "C" + i.ToString();
|
||
}
|
||
// add signoff menuitems which are Endabled/Disabled & also Menu
|
||
if (rightCheckOffBox[0] != 0 && rightCheckOffBox[1] != 0)
|
||
{
|
||
fmtdata.ProcData.CheckOffData.Menu = "Signoff";
|
||
fmtdata.ProcData.CheckOffData.CheckOffList[0].Index = 0;
|
||
fmtdata.ProcData.CheckOffData.CheckOffList[0].MenuItem = "Enabled";
|
||
fmtdata.ProcData.CheckOffData.CheckOffList[0].Macro = "C1";
|
||
fmtdata.ProcData.CheckOffData.CheckOffList[1].Index = 1;
|
||
fmtdata.ProcData.CheckOffData.CheckOffList[1].MenuItem = "Disabled";
|
||
if (rightCheckOffBox[0] == -2 && rightCheckOffBox[1] == -2) fmtdata.ProcData.CheckOffData.SkipSpaces = "true";
|
||
else
|
||
{
|
||
if (fmtdata.ProcData.CheckOffData.LayoutList == null)
|
||
fmtdata.ProcData.CheckOffData.LayoutList = new Absolute [2];
|
||
fmtdata.ProcData.CheckOffData.LayoutList[0].RnoLevel = "0";
|
||
fmtdata.ProcData.CheckOffData.LayoutList[0].Column = rightCheckOffBox[0];
|
||
fmtdata.ProcData.CheckOffData.LayoutList[1].RnoLevel = "1";
|
||
fmtdata.ProcData.CheckOffData.LayoutList[1].Column = rightCheckOffBox[1];
|
||
}
|
||
}
|
||
for (int i = 0; i < MAXCHKHEADINGS; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.ProcData.CheckOffData.CheckOffHeaderList[i].CheckOffHeading = DoReplaceTokens(GetStringFromByte(input, indx));
|
||
}
|
||
|
||
// not used - WindEditFile
|
||
arcnt++;
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) tmpstr = GetStringFromByte(input, indx);
|
||
|
||
// not used - RNOPreSeqTab[9][2]
|
||
arcnt = arcnt + 18;
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectPrtData.HLStpSeparatorString = GetStringFromByte(input, indx);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectPrtData.HLRNOStpSeparatorString = GetStringFromByte(input, indx);
|
||
|
||
for (int i = 0; i < MAXTABS; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) tabstrings[i, 0] = GetStringFromByte(input, indx);
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) tabstrings[i, 1] = GetStringFromByte(input, indx);
|
||
}
|
||
for (int i = 0; i < MAXSTEPS; i++)
|
||
{
|
||
for (int j = 0; j < MAXTABS; j++)
|
||
{
|
||
if (Tabindx[i] == j)
|
||
{
|
||
fmtdata.StepData[i + 1].TabData.RNOIdentEdit = DoTabs(fmtdata.StepData[i].TabData.Font, fmtdata.PurchaseOptions, i, tabstrings[j, 0], fmtdata.StepData[i].StepNumberForHighLevel == "True");
|
||
//fmtdata.StepData[i + 1].TabData.RNOIdentEditWid = CalculateTabWid(tabstrings[j, 0]).ToString();
|
||
fmtdata.StepData[i + 1].TabData.RNOIdent = DoTabs(fmtdata.StepData[i].TabData.Font, fmtdata.PurchaseOptions, i, tabstrings[j, 1], fmtdata.StepData[i].StepNumberForHighLevel == "True");
|
||
//fmtdata.StepData[i + 1].TabData.RNOIdentWid = CalculateTabWid(tabstrings[j, 1]).ToString();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectLayData.LowerLimitDivisor = GetStringFromByte(input, indx);
|
||
|
||
// If the DoSectionTrans flag is set, use DefaultSectionTransStr for defaults,
|
||
// otherwise use the DefaultTransStr. The DoSectionTransTypeB flags just
|
||
// replaces the [5] item in the DefaultSectionTransStr array. I'll reset
|
||
// if this flag isn't used since formats are processed in a loop and only want
|
||
// the change to the default for the current format if the flag is set in it.
|
||
if (XtraFlags.DoSectionTransTypeB == "True")
|
||
{
|
||
DefaultSectionTransTokenStr[5] = DefaultSectionTransStrTypeB;
|
||
DefaultSectionTransFormatStr[5] = DefaultSectionTransStrTypeB;
|
||
}
|
||
else // if flag not set, just reset default in case used in one of next formats.
|
||
{
|
||
DefaultSectionTransTokenStr[5] = DefaultSectionTransStrTypeBNone;
|
||
DefaultSectionTransFormatStr[5] = DefaultSectionTransStrTypeBNone;
|
||
}
|
||
|
||
// If the plant uses the TransProcTitleInParen flag, then place parens
|
||
// around the proc & section titles.
|
||
if (XtraFlags.TranProcTitleInParen == "True")
|
||
{
|
||
DefaultTransStr[0] = "{Proc Num} ({Proc Title}) Step {First Step}";
|
||
DefaultTransStr[3] = "{First Step} thru {Last Step} of {Proc Num} ({Proc Title}) ({Sect Hdr})";
|
||
DefaultTransStr[4] = "({Sect Title}), Step {First Step}";
|
||
DefaultTransStr[5] = "{Proc Num}, ({Proc Title}) ({Sect Hdr}), Step {First Step}";
|
||
}
|
||
if (fmtdata.TransData.ThroughString != null && fmtdata.TransData.ThroughString != "")
|
||
{
|
||
DefaultTransStr[3] = DefaultTransStr[3].Replace(" thru ", fmtdata.TransData.ThroughString);
|
||
DefaultSectionTransTokenStr[3] = DefaultSectionTransTokenStr[3].Replace(" thru ", fmtdata.TransData.ThroughString);
|
||
DefaultSectionTransFormatStr[3] = DefaultSectionTransFormatStr[3].Replace(" thru ", fmtdata.TransData.ThroughString);
|
||
}
|
||
for (int i = 0; i < MAXTRANS; i++)
|
||
{
|
||
fmtdata.TransData.TransTypeData[i].Index = i;
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.TransData.TransTypeData[i].TransFormat = ConvertTransFormat(GetStringFromByteNoConvert(input, indx));
|
||
else if (i < 6)
|
||
{
|
||
fmtdata.TransData.TransTypeData[i].TransFormat = XtraFlags.DoSectionTrans == "True" ? DefaultSectionTransFormatStr[i] : DefaultTransStr[i];
|
||
fmtdata.TransData.TransTypeData[i].TransType = (byte)i; // reset type
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < MAXTRANS; i++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.TransData.TransTypeData[i].TransMenu = ConvertTransFormat(GetStringFromByteNoConvert(input, indx));
|
||
else if (i < 6)
|
||
{
|
||
fmtdata.TransData.TransTypeData[i].TransMenu = XtraFlags.DoSectionTrans == "True" ? DefaultSectionTransTokenStr[i] : DefaultTransStr[i];
|
||
fmtdata.TransData.TransTypeData[i].TransType = (byte)i; // reset type
|
||
}
|
||
}
|
||
for (int i = 0; i < MAXTRANS; i++)
|
||
{
|
||
if (fmtdata.TransData.TransTypeData[i].TransFormat != null && fmtdata.TransData.TransTypeData[i].TransMenu != null) fmtdata.TransData.TransTypeData[i].TransUI = GetTransUIEnum(fmtdata.TransData.TransTypeData[i].TransFormat, fmtdata.TransData.TransTypeData[i].TransMenu);
|
||
}
|
||
// if in dosectiontransitions, put the format/menu strings back to original
|
||
//if (XtraFlags.DoSectionTrans == "True")
|
||
//{
|
||
// for (int i = 0; i < MAXTRANS; i++)
|
||
// {
|
||
// if (i < 6 && fmtdata.TransData.TransTypeData[i].TransMenu != null)
|
||
// {
|
||
// fmtdata.TransData.TransTypeData[i].TransFormat = DefaultSectionTransFormatStr[i];
|
||
// fmtdata.TransData.TransTypeData[i].TransMenu = DefaultSectionTransFormatStr[i];
|
||
|
||
// }
|
||
// }
|
||
//}
|
||
//arcnt = arcnt + MAXTRANS;
|
||
|
||
// not used OutsideTransFmt & OutsideTransMenu
|
||
arcnt = arcnt + (MAXTRANS * 2);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectLayData.NonLinkedStepNumber = GetStringFromByte(input, indx);
|
||
|
||
//not used BldLstFile
|
||
arcnt++;
|
||
// AltPrintTBIdent (20 items)
|
||
//arcnt += MAXTABS;
|
||
for (int j = 0; j < MAXTABS; j++)
|
||
{
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx != 0)
|
||
{
|
||
string ts = GetStringFromByte(input, indx);
|
||
for (int i = 0; i < MAXSTEPS; i++)
|
||
{
|
||
if (Tabindx[i] == j)
|
||
{
|
||
fmtdata.StepData[i + 1].TabData.IdentAltPrint = ts;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectLayData.NonLinkedCautNoteNumber = GetStringFromByte(input, indx);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.PrintData.DuplexBGDirectory = GetStringFromByte(input, indx);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.PrintData.DuplexDDDirectory = GetStringFromByte(input, indx);
|
||
|
||
indx = offset[arcnt];
|
||
arcnt++;
|
||
if (indx > 0) fmtdata.SectData.StepSectionData.StpSectLayData.NonLinkedRNONumber = GetStringFromByte(input, indx);
|
||
|
||
#endregion
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.WriteLine("Error on read - format = {0}", fmtdata.Name);
|
||
Console.WriteLine(ex.Message);
|
||
Console.WriteLine();
|
||
return false;
|
||
}
|
||
return AdjustFlags(ref fmtdata, ref XtraFlags);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Replace invalid characters with a special sequence
|
||
/// </summary>
|
||
/// <param name="str"></param>
|
||
/// <returns></returns>
|
||
private string FixXmlString(string str)
|
||
{
|
||
// http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char
|
||
// http://cse-mjmcl.cse.bris.ac.uk/blog/2007/02/14/1171465494443.html
|
||
// The regular expression below find any invalid characters
|
||
// by looking for characters that are not valid
|
||
MatchCollection matches = Regex.Matches(str, @"[^\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD]");
|
||
int lastIndex = 0;
|
||
StringBuilder sb = new StringBuilder();
|
||
int len = str.Length;
|
||
foreach (Match match in matches)
|
||
{
|
||
sb.Append(str.Substring(lastIndex, match.Index - lastIndex));
|
||
foreach (char c in match.Value)
|
||
sb.Append(string.Format("[({0:X04}])", (int)c));
|
||
lastIndex = match.Index + match.Length;
|
||
}
|
||
sb.Append(str.Substring(lastIndex));
|
||
if (!str.Substring(lastIndex).EndsWith("\n"))
|
||
sb.Append("\n");
|
||
return sb.ToString();
|
||
}
|
||
|
||
private bool AdjustFlags(ref FormatData fmtdata, ref XtraFlgs XtraFlags)
|
||
{
|
||
// do format flags here - this will get yucky!!!
|
||
#region StepFlags
|
||
int step = 0;
|
||
try
|
||
{
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
step = i;
|
||
// Do base here
|
||
if (i == 0)
|
||
{
|
||
// All types get this thru inheritance
|
||
if (XtraFlags.SeparateBox == "True") fmtdata.StepData[i].SeparateBox = "True";
|
||
else fmtdata.StepData[i].SeparateBox = "False";
|
||
// All types get this thru inheritance
|
||
if (XtraFlags.LJTabs == "True") fmtdata.StepData[i].LJTabs = "True";
|
||
else fmtdata.StepData[i].LJTabs = "False";
|
||
}
|
||
if (i == 1) // Sequential flags - new name will be substeps
|
||
{
|
||
if (XtraFlags.BoxedSubsteps == "True") fmtdata.StepData[i].Boxed = "True";
|
||
else fmtdata.StepData[i].Boxed = "False";
|
||
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
if (XtraFlags.TextSubFollowsTextStyle == "True") fmtdata.StepData[i].TextSubFollowsTextStyle = "True";
|
||
else fmtdata.StepData[i].TextSubFollowsTextStyle = "False";
|
||
|
||
if (XtraFlags.DontStartLineWithDash == "True") fmtdata.StepData[i].StartLineWithDash = "False";
|
||
else fmtdata.StepData[i].StartLineWithDash = "True";
|
||
|
||
if (XtraFlags.NoBlankLineBeforeSubstep == "True") fmtdata.StepData[i].BlankLineBeforeSubStep = "False";
|
||
else fmtdata.StepData[i].BlankLineBeforeSubStep = "True";
|
||
}
|
||
else if (i == 2) // High
|
||
{
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.EnhancedStepNumFromPrev == "True") fmtdata.StepData[i].EnhancedStepNumFromPrev = "True";
|
||
else fmtdata.StepData[i].EnhancedStepNumFromPrev = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.UseSmartTemplate == "True") fmtdata.StepData[i].UseSmartTemplate = "True";
|
||
else fmtdata.StepData[i].UseSmartTemplate = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.BoxContinousActions == "True") fmtdata.StepData[i].Boxed = "True";
|
||
else fmtdata.StepData[i].Boxed = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.Xlines_StepFix == "True") fmtdata.StepData[i].XLines_StepFix = "True";
|
||
else fmtdata.StepData[i].XLines_StepFix = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.UseAlternateStepBox == "True") fmtdata.StepData[i].UseAlternateStepBox = "True";
|
||
else fmtdata.StepData[i].UseAlternateStepBox = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.PageBreakOnHighLevelStep == "True") fmtdata.StepData[i].PageBreakOnStep = "True";
|
||
else fmtdata.StepData[i].PageBreakOnStep = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.AlignNullTabWSectHead == "True") fmtdata.StepData[i].AlignNullTabWSectHead = "True";
|
||
else fmtdata.StepData[i].AlignNullTabWSectHead = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.HLSTextInPagelist == "True") fmtdata.StepData[i].InPageList = "True";
|
||
else fmtdata.StepData[i].InPageList = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.NoStepNumIfOnlyOneStep == "True") fmtdata.StepData[i].StepNumIfOnlyOne = "False";
|
||
else fmtdata.StepData[i].StepNumIfOnlyOne = "True";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.AtLeastTwoDigitsForHLS == "True") fmtdata.StepData[i].AtLeastTwoDigits = "True";
|
||
else fmtdata.StepData[i].AtLeastTwoDigits = "False";
|
||
|
||
// All High get this thru inheritance
|
||
if (XtraFlags.DontNumberHighLevelSteps == "True") fmtdata.StepData[i].Number = "False";
|
||
else fmtdata.StepData[i].Number = "True";
|
||
}
|
||
else if (i == 3) // Immediate
|
||
{
|
||
if (XtraFlags.IMMStepSpcHdr == "True") fmtdata.StepData[i].SpcHdr = "True";
|
||
else fmtdata.StepData[i].SpcHdr = "False";
|
||
}
|
||
else if (i == 4) // And
|
||
{
|
||
// All And get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
// All And get this thru inheritance
|
||
if (XtraFlags.TreatAndOrAsSequential == "True") fmtdata.StepData[i].TreatAsSequential = "True";
|
||
else fmtdata.StepData[i].TreatAsSequential = "False";
|
||
}
|
||
else if (i == 5) // Or
|
||
{
|
||
// All Or get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
// All Or get this thru inheritance
|
||
if (XtraFlags.TreatAndOrAsSequential == "True") fmtdata.StepData[i].TreatAsSequential = "True";
|
||
else fmtdata.StepData[i].TreatAsSequential = "False";
|
||
|
||
}
|
||
else if (i == 6) // Caution
|
||
{
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.EnhancedStepNumFromPrev == "True") fmtdata.StepData[i].EnhancedStepNumFromPrev = "True";
|
||
else fmtdata.StepData[i].EnhancedStepNumFromPrev = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.AlwaysUseExtralines == "True") fmtdata.StepData[i].AlwaysUseExtraLines = "True";
|
||
else fmtdata.StepData[i].AlwaysUseExtraLines = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.SeparateBoxCautions == "True") fmtdata.StepData[i].SeparateBoxCautions = "True";
|
||
else fmtdata.StepData[i].SeparateBoxCautions = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.ReduceLineAfterNoteAndCaut == "True") fmtdata.StepData[i].ReduceLineAfter = "True";
|
||
else fmtdata.StepData[i].ReduceLineAfter = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.OneLineBeforeNoteCautionTab == "True") fmtdata.StepData[i].OneLineBeforeTab = "True";
|
||
else fmtdata.StepData[i].OneLineBeforeTab = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.ReBoxCautNote == "True") fmtdata.StepData[i].Rebox = "True";
|
||
else fmtdata.StepData[i].Rebox = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.NoSpaceInNoteOrCaution == "True") fmtdata.StepData[i].SpaceIn = "False";
|
||
else fmtdata.StepData[i].SpaceIn = "True";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.PageBreakOnCautions == "True") fmtdata.StepData[i].PageBreakOnStep = "True";
|
||
else fmtdata.StepData[i].PageBreakOnStep = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.MatchUpRNOCautNote == "True") fmtdata.StepData[i].MatchUpRNO = "True";
|
||
else fmtdata.StepData[i].MatchUpRNO = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.StpCautNoteTabInPagelist == "True") fmtdata.StepData[i].InPageList = "True";
|
||
else fmtdata.StepData[i].InPageList = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.CenterOneLineOnly == "True") fmtdata.StepData[i].CenterOneLineOnly = "True";
|
||
else fmtdata.StepData[i].CenterOneLineOnly = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.RememberCautionsAndNotes == "True") fmtdata.StepData[i].Remember = "True";
|
||
else fmtdata.StepData[i].Remember = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.CenterOneLineAdjust == "True") fmtdata.StepData[i].CenterOneLineAdjust = "True";
|
||
else fmtdata.StepData[i].CenterOneLineAdjust = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.DontBreakCautionsOrNotes == "True") fmtdata.StepData[i].Break = "False";
|
||
else fmtdata.StepData[i].Break = "True";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.CenterTextWithinWidth == "True") fmtdata.StepData[i].CenterTextWithinWidth = "True";
|
||
else fmtdata.StepData[i].CenterTextWithinWidth = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.DontBreakCautionsNotesOnSubstps == "True") fmtdata.StepData[i].BreakCautionsNotesOnSubstps = "False";
|
||
else fmtdata.StepData[i].BreakCautionsNotesOnSubstps = "True";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.AlwaysTabCaution == "True") fmtdata.StepData[i].AlwaysTab = "True";
|
||
else fmtdata.StepData[i].AlwaysTab = "False";
|
||
|
||
// All Cautions get this thru inheritance
|
||
if (XtraFlags.ThreeBlanksAboveNotesCautions == "True") fmtdata.StepData[i].ThreeBlanksAbove = "True";
|
||
else fmtdata.StepData[i].ThreeBlanksAbove = "False";
|
||
}
|
||
else if (i == 7) // Note
|
||
{
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.EnhancedStepNumFromPrev == "True") fmtdata.StepData[i].EnhancedStepNumFromPrev = "True";
|
||
else fmtdata.StepData[i].EnhancedStepNumFromPrev = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.AlwaysUseExtralines == "True") fmtdata.StepData[i].AlwaysUseExtraLines = "True";
|
||
else fmtdata.StepData[i].AlwaysUseExtraLines = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.ReduceLineAfterNoteAndCaut == "True") fmtdata.StepData[i].ReduceLineAfter = "True";
|
||
else fmtdata.StepData[i].ReduceLineAfter = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.OneLineBeforeNoteCautionTab == "True") fmtdata.StepData[i].OneLineBeforeTab = "True";
|
||
else fmtdata.StepData[i].OneLineBeforeTab = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.ReBoxCautNote == "True") fmtdata.StepData[i].Rebox = "True";
|
||
else fmtdata.StepData[i].Rebox = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.NoSpaceInNoteOrCaution == "True") fmtdata.StepData[i].SpaceIn = "False";
|
||
else fmtdata.StepData[i].SpaceIn = "True";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.PageBreakOnNotes == "True") fmtdata.StepData[i].PageBreakOnStep = "True";
|
||
else fmtdata.StepData[i].PageBreakOnStep = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.MatchUpRNOCautNote == "True") fmtdata.StepData[i].MatchUpRNO = "True";
|
||
else fmtdata.StepData[i].MatchUpRNO = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.StpCautNoteTabInPagelist == "True") fmtdata.StepData[i].InPageList = "True";
|
||
else fmtdata.StepData[i].InPageList = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.CenterOneLineOnly == "True") fmtdata.StepData[i].CenterOneLineOnly = "True";
|
||
else fmtdata.StepData[i].CenterOneLineOnly = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.RememberCautionsAndNotes == "True") fmtdata.StepData[i].Remember = "True";
|
||
else fmtdata.StepData[i].Remember = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.CenterOneLineAdjust == "True") fmtdata.StepData[i].CenterOneLineAdjust = "True";
|
||
else fmtdata.StepData[i].CenterOneLineAdjust = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.DontBreakCautionsOrNotes == "True") fmtdata.StepData[i].Break = "False";
|
||
else fmtdata.StepData[i].Break = "True";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.DontBreakCautionsNotesOnSubstps == "True") fmtdata.StepData[i].BreakCautionsNotesOnSubstps = "False";
|
||
else fmtdata.StepData[i].BreakCautionsNotesOnSubstps = "True";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.CenterTextWithinWidth == "True") fmtdata.StepData[i].CenterTextWithinWidth = "True";
|
||
else fmtdata.StepData[i].CenterTextWithinWidth = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.AlwaysTabNote == "True") fmtdata.StepData[i].AlwaysTab = "True";
|
||
else fmtdata.StepData[i].AlwaysTab = "False";
|
||
|
||
// All Notes get this thru inheritance
|
||
if (XtraFlags.ThreeBlanksAboveNotesCautions == "True") fmtdata.StepData[i].ThreeBlanksAbove = "True";
|
||
else fmtdata.StepData[i].ThreeBlanksAbove = "False";
|
||
}
|
||
else if (i == 8) // Table
|
||
{
|
||
// All Table get this thru inheritance
|
||
if (XtraFlags.SubTableGetSup1Level == "True") fmtdata.StepData[i].SubTableGetsUp1Level = "True";
|
||
else fmtdata.StepData[i].SubTableGetsUp1Level = "False";
|
||
}
|
||
else if (i == 9) // Continuous
|
||
{
|
||
if (XtraFlags.BulletOnContinuous == "True") fmtdata.StepData[i].BulletOnContinuous = "True";
|
||
else fmtdata.StepData[i].BulletOnContinuous = "False";
|
||
}
|
||
else if (i == 10) // AERTable
|
||
{
|
||
}
|
||
else if (i == 11) // EquipmentList
|
||
{
|
||
// All EquipmentList get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
// Note that only equipment lists (and wblank) get this - no inherit - must be done in code!
|
||
if (XtraFlags.DontBreakEquipmentList == "True") fmtdata.StepData[i].BreakEquipmentList = "False";
|
||
else fmtdata.StepData[i].BreakEquipmentList = "True";
|
||
}
|
||
else if (i == 12) // Title
|
||
{
|
||
// All Title get this thru inheritance
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
}
|
||
else if (i == 13) // PageNumber
|
||
{
|
||
}
|
||
else if (i == 14) // EquipmentWBlank
|
||
{
|
||
}
|
||
else if (i == 15) // ProcNumber
|
||
{
|
||
}
|
||
else if (i == 16) // RevNumber
|
||
{
|
||
}
|
||
else if (i == 17) // AccPages
|
||
{
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
}
|
||
else if (i == 18) // LossOfAC
|
||
{
|
||
if (XtraFlags.DontBoxAC == "True") fmtdata.StepData[i].BoxIt = "False";
|
||
else fmtdata.StepData[i].BoxIt = "True";
|
||
}
|
||
else if (i == 19) // ExplicitAnd
|
||
{
|
||
}
|
||
else if (i == 20) // Caution1
|
||
{
|
||
if (XtraFlags.MixCautionsAndNotes == "True") fmtdata.StepData[i].MixCautionsAndNotes = "True";
|
||
else fmtdata.StepData[i].MixCautionsAndNotes = "False";
|
||
|
||
if (XtraFlags.Caution1SameRowAsParent == "True") fmtdata.StepData[i].SameRowAsParent = "True";
|
||
else fmtdata.StepData[i].SameRowAsParent = "False";
|
||
}
|
||
else if (i == 21) // Caution2
|
||
{
|
||
if (XtraFlags.AlwaysTabCaution2 == "True") fmtdata.StepData[i].AlwaysTab = "True";
|
||
else fmtdata.StepData[i].AlwaysTab = "False";
|
||
|
||
if (XtraFlags.Caution2SameRowAsParent == "True") fmtdata.StepData[i].SameRowAsParent = "True";
|
||
else fmtdata.StepData[i].SameRowAsParent = "False";
|
||
}
|
||
else if (i == 22) // Note1
|
||
{
|
||
if (XtraFlags.MixCautionsAndNotes == "True") fmtdata.StepData[i].MixCautionsAndNotes = "True";
|
||
else fmtdata.StepData[i].MixCautionsAndNotes = "False";
|
||
}
|
||
else if (i == 23) // Note2
|
||
{
|
||
}
|
||
else if (i == 24) // Paragraph
|
||
{
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
}
|
||
else if (i == 25) // Default
|
||
{
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
}
|
||
else if (i == 26) // Note3
|
||
{
|
||
}
|
||
else if (i == 27) // Caution3
|
||
{
|
||
}
|
||
else if (i == 28) // Note4
|
||
{
|
||
}
|
||
else if (i == 29) // Caution4
|
||
{
|
||
}
|
||
else if (i == 30) // EquipmentOpt
|
||
{
|
||
// All EquipmentOpt get this thru inheritance
|
||
if (XtraFlags.QuotedSubsteps == "True") fmtdata.StepData[i].Quoted = "True";
|
||
else fmtdata.StepData[i].Quoted = "False";
|
||
|
||
// Note that only opt equipment lists (and wblank) get this - no inherit - must be done in code!
|
||
if (XtraFlags.DontBreakOptEquipmentList == "True")
|
||
fmtdata.StepData[i].BreakEquipmentList = "False";
|
||
else
|
||
fmtdata.StepData[i].BreakEquipmentList = "True";
|
||
}
|
||
else if (i == 31) // EquipmentOptWBlank
|
||
{
|
||
// All EquipmentOptWBlank get this thru inheritance
|
||
if (XtraFlags.QuotedSubsteps == "True") fmtdata.StepData[i].Quoted = "True";
|
||
else fmtdata.StepData[i].Quoted = "False";
|
||
}
|
||
else if (i == 32) // Note5
|
||
{
|
||
}
|
||
else if (i == 33) // BorderlessAERTable
|
||
{
|
||
if (XtraFlags.LJBorderlessTable == "True") fmtdata.StepData[i].LeftJustifyBorderless = "True";
|
||
else fmtdata.StepData[i].LeftJustifyBorderless = "False";
|
||
}
|
||
else if (i == 34) // BorderlessTable
|
||
{
|
||
if (XtraFlags.LJBorderlessTable == "True") fmtdata.StepData[i].LeftJustifyBorderless = "True";
|
||
else fmtdata.StepData[i].LeftJustifyBorderless = "False";
|
||
}
|
||
else if (i == 35) // ImplicitOr
|
||
{
|
||
}
|
||
else if (i == 36) // Figure
|
||
{
|
||
}
|
||
else if (i == 37) // AERFigure
|
||
{
|
||
}
|
||
else if (i == 38) // BorderlessFigure
|
||
{
|
||
if (XtraFlags.LJBorderlessTable == "True") fmtdata.StepData[i].LeftJustifyBorderless = "True";
|
||
else fmtdata.StepData[i].LeftJustifyBorderless = "False";
|
||
}
|
||
else if (i == 39) // BorderlessAERFigure
|
||
{
|
||
if (XtraFlags.LJBorderlessTable == "True") fmtdata.StepData[i].LeftJustifyBorderless = "True";
|
||
else fmtdata.StepData[i].LeftJustifyBorderless = "False";
|
||
}
|
||
else if (i == 40) // RNOType
|
||
{
|
||
if (XtraFlags.DoubleRNOSpace == "True") fmtdata.StepData[i].DoubleSpace = "True";
|
||
else fmtdata.StepData[i].DoubleSpace = "False";
|
||
|
||
if (XtraFlags.EnhancedStepNumFromPrev == "True") fmtdata.StepData[i].EnhancedStepNumFromPrev = "True";
|
||
else fmtdata.StepData[i].EnhancedStepNumFromPrev = "False";
|
||
|
||
if (XtraFlags.NoSpaceDoubleRNO == "True") fmtdata.StepData[i].SpaceDouble = "False";
|
||
else fmtdata.StepData[i].SpaceDouble = "True";
|
||
|
||
if (XtraFlags.RNOSameLevel == "True") fmtdata.StepData[i].SameLevel = "True";
|
||
else fmtdata.StepData[i].SameLevel = "False";
|
||
|
||
if (XtraFlags.BoldHighLevelRNO == "True") fmtdata.StepData[i].BoldHighLevel = "True";
|
||
else fmtdata.StepData[i].BoldHighLevel = "False";
|
||
|
||
if (XtraFlags.RNOContinueOnly == "True") fmtdata.StepData[i].ContinueOnly = "True";
|
||
else fmtdata.StepData[i].ContinueOnly = "False";
|
||
|
||
if (XtraFlags.RNOSepAfterAER == "True") fmtdata.StepData[i].SepAfterAER = "True";
|
||
else fmtdata.StepData[i].SepAfterAER = "False";
|
||
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
|
||
if (XtraFlags.RNOInPagelist == "True") fmtdata.StepData[i].InPageList = "True";
|
||
else fmtdata.StepData[i].InPageList = "False";
|
||
|
||
if (XtraFlags.DontBreakOnRNO == "True") fmtdata.StepData[i].Break = "False";
|
||
else fmtdata.StepData[i].Break = "True";
|
||
|
||
if (XtraFlags.NoNewlineAfterRNO == "True") fmtdata.StepData[i].NewlineAfter = "False";
|
||
else fmtdata.StepData[i].NewlineAfter = "True";
|
||
|
||
if (XtraFlags.NumberHighLevelRNO == "True") fmtdata.StepData[i].NumberHighLevel = "True";
|
||
else fmtdata.StepData[i].NumberHighLevel = "False";
|
||
|
||
if (XtraFlags.DontOffsetTab == "True") fmtdata.StepData[i].OffsetTab = "False";
|
||
else fmtdata.StepData[i].OffsetTab = "True";
|
||
|
||
if (XtraFlags.DontNumberRNOSubs == "True") fmtdata.StepData[i].NumberSubs = "False";
|
||
else fmtdata.StepData[i].NumberSubs = "True";
|
||
|
||
if (XtraFlags.NoStepNumberForHighLevelRNO == "True") fmtdata.StepData[i].StepNumberForHighLevel = "False";
|
||
else fmtdata.StepData[i].StepNumberForHighLevel = "True";
|
||
|
||
if (XtraFlags.RNOCheckOffSameAsParent == "True") fmtdata.StepData[i].CheckoffSameAsParent = "True";
|
||
else fmtdata.StepData[i].CheckoffSameAsParent = "False";
|
||
|
||
if (XtraFlags.UseRNOTypeInActable == "True") fmtdata.StepData[i].UseInAcTable = "True";
|
||
else fmtdata.StepData[i].UseInAcTable = "False";
|
||
}
|
||
else if (i == 41) // High5
|
||
{
|
||
}
|
||
else if (i == 42) // TitleWithTextRight
|
||
{
|
||
}
|
||
else if (i == 43) // TitleWithTextBelow
|
||
{
|
||
}
|
||
else if (i == 44) // ContAcSequential
|
||
{
|
||
if (XtraFlags.UnderlineAfterDashSpace == "True") fmtdata.StepData[i].UnderlineAfterDashSpace = "True";
|
||
else fmtdata.StepData[i].UnderlineAfterDashSpace = "False";
|
||
}
|
||
else if (i == 45) // ContAcAnd
|
||
{
|
||
}
|
||
else if (i == 46) // ContAcOr
|
||
{
|
||
}
|
||
else if (i == 47) // ContAcParagraph
|
||
{
|
||
}
|
||
if (fmtdata.StepData[i].TabData.MacroList != null)
|
||
{
|
||
if (XtraFlags.NoCheckOffsInRNO == "True") fmtdata.StepData[i].TabData.MacroList[0].NotInRNO = "True";
|
||
else fmtdata.StepData[i].TabData.MacroList[0].NotInRNO = "False";
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.WriteLine("Error on step data");
|
||
}
|
||
#endregion
|
||
#region StepStructLayout
|
||
if (XtraFlags.Dev_Format == "True") fmtdata.SectData.StepSectionData.StpSectLayData.Dev_Format = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.Dev_Format = "False";
|
||
if (XtraFlags.EnhancedShortFormDev == "True") fmtdata.SectData.StepSectionData.StpSectLayData.EnhancedShortFormDev = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.EnhancedShortFormDev = "False";
|
||
if (XtraFlags.SpecialPageBreakFlag == "True") fmtdata.SectData.StepSectionData.StpSectLayData.SpecialPageBreakFlag = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.SpecialPageBreakFlag = "False";
|
||
if (XtraFlags.DontPaginateOnFirstSubStep == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep = "True";
|
||
if (XtraFlags.DontPaginateOnFirstSubStep2X == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep2X = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep2X = "True";
|
||
if (XtraFlags.DontUseHalfLines == "True") fmtdata.SectData.StepSectionData.StpSectLayData.UseHalfLines = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.UseHalfLines = "True";
|
||
if (XtraFlags.DontTryToFillHalfOfPage == "True") fmtdata.SectData.StepSectionData.StpSectLayData.TryToFillHalfOfPage = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.TryToFillHalfOfPage = "True";
|
||
if (XtraFlags.DoNotCompressSteps == "True") fmtdata.SectData.StepSectionData.StpSectLayData.CompressSteps = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.CompressSteps = "True";
|
||
if (XtraFlags.DontDoSTExtraAtTop == "True") fmtdata.SectData.StepSectionData.StpSectLayData.DoSTExtraAtTop = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.DoSTExtraAtTop = "True";
|
||
if (XtraFlags.KeepStepsOnPage == "True") fmtdata.SectData.StepSectionData.StpSectLayData.KeepStepsOnPage = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.KeepStepsOnPage = "False";
|
||
if (XtraFlags.DontBreakOnSections == "True") fmtdata.SectData.StepSectionData.StpSectLayData.BreakOnSections = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.BreakOnSections = "True";
|
||
if (XtraFlags.ShowSectionTitles == "True") fmtdata.SectData.StepSectionData.StpSectLayData.ShowSectionTitles = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.ShowSectionTitles = "False";
|
||
if (XtraFlags.NoEndForSingle == "True") fmtdata.SectData.StepSectionData.StpSectLayData.EndForSingle = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.EndForSingle = "True";
|
||
if (XtraFlags.DontPaginateOnFirstSubstep3X == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep3X = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep3X = "True";
|
||
if (XtraFlags.PaginateOnLowerStepLevel == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnLowerStepLevel = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PaginateOnLowerStepLevel = "False";
|
||
if (XtraFlags.CustomSpacing == "True") fmtdata.SectData.StepSectionData.StpSectLayData.CustomSpacing = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.CustomSpacing = "False";
|
||
if (XtraFlags.DontSplitStepInPrntStep == "True") fmtdata.SectData.StepSectionData.StpSectLayData.SplitStepInPrntStep = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.SplitStepInPrntStep = "True";
|
||
if (XtraFlags.LineAboveUnderSection == "True") fmtdata.SectData.StepSectionData.StpSectLayData.LineAboveUnderSection = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.LineAboveUnderSection = "False";
|
||
if (XtraFlags.PicaIgnoreFiveSixths == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PicaIgnoreFiveSixths = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PicaIgnoreFiveSixths = "False";
|
||
if (XtraFlags.SpaceFoRNOSecNumb == "True") fmtdata.SectData.StepSectionData.StpSectLayData.SpaceForNoSecNumb = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.SpaceForNoSecNumb = "False";
|
||
if (XtraFlags.PageBreakOnFirstBlankLine == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PageBreakOnFirstBlankLine = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PageBreakOnFirstBlankLine = "False";
|
||
if (XtraFlags.PutOnPageByItself == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PutOnPageByItself = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PutOnPageByItself = "False";
|
||
if (XtraFlags.PaginateAtHighestPaginLevel == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PaginateAtHighestPaginLevel = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PaginateAtHighestPaginLevel = "False";
|
||
if (XtraFlags.UseSTExtraRealValue == "True") fmtdata.SectData.StepSectionData.StpSectLayData.UseSTExtraRealValue = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.UseSTExtraRealValue = "False";
|
||
if (XtraFlags.DoSectionSeparatorLine == "True") fmtdata.SectData.StepSectionData.StpSectLayData.DoSectionSeparatorLine = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.DoSectionSeparatorLine = "False";
|
||
if (XtraFlags.TieTabToLevel == "True") fmtdata.SectData.StepSectionData.StpSectLayData.TieTabToLevel = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.TieTabToLevel = "False";
|
||
if (XtraFlags.HighLevelRNOBeforeAERSubStps == "True") fmtdata.SectData.StepSectionData.StpSectLayData.HighLevelRNOBeforeAERSubsteps = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.HighLevelRNOBeforeAERSubsteps = "False";
|
||
if (XtraFlags.UseStepTypeWidthOverride == "True") fmtdata.SectData.StepSectionData.StpSectLayData.UseStepTypeWidthOverride = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.UseStepTypeWidthOverride = "False";
|
||
if (XtraFlags.UseStepTypeWidthOverrideEditPrint == "True") fmtdata.SectData.StepSectionData.StpSectLayData.UseStepTypeWidthOverrideEditPrint = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.UseStepTypeWidthOverrideEditPrint = "False";
|
||
if (XtraFlags.PartialStepCompression == "True") fmtdata.SectData.StepSectionData.StpSectLayData.PartialStepCompression = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.PartialStepCompression = "False";
|
||
if (XtraFlags.VirtualDotInHLSTab == "True") fmtdata.SectData.StepSectionData.StpSectLayData.VirtualDotInHLSTab = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.VirtualDotInHLSTab = "False";
|
||
if (XtraFlags.OverrideEnhancedTabs == "True") fmtdata.SectData.StepSectionData.StpSectLayData.OverrideEnhancedTabs = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.OverrideEnhancedTabs = "False";
|
||
if (XtraFlags.NoRNO == "True") fmtdata.SectData.StepSectionData.StpSectLayData.RNO = "False";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.RNO = "True";
|
||
if (XtraFlags.OnlySingleColumn == "True") fmtdata.SectData.StepSectionData.StpSectLayData.OnlySingleColumn = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.OnlySingleColumn = "False";
|
||
if (XtraFlags.NullBox == "True") fmtdata.SectData.StepSectionData.StpSectLayData.NullBox = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectLayData.NullBox = "False";
|
||
#endregion
|
||
#region StepSection
|
||
if (XtraFlags.WolfCreekBackgroundFormat == "True") fmtdata.SectData.StepSectionData.WolfCreekBackgroundFormat = "True";
|
||
else fmtdata.SectData.StepSectionData.WolfCreekBackgroundFormat = "False";
|
||
if (XtraFlags.WolfcreekCKLFormat == "True") fmtdata.SectData.StepSectionData.WolfcreekCKLFormat = "True";
|
||
else fmtdata.SectData.StepSectionData.WolfcreekCKLFormat = "False";
|
||
if (XtraFlags.WolfcreekCKLBackgndFormat == "True") fmtdata.SectData.StepSectionData.WolfcreekCKLBackgndFormat = "True";
|
||
else fmtdata.SectData.StepSectionData.WolfcreekCKLBackgndFormat = "False";
|
||
if (XtraFlags.FortranFormatNumbers == "True") fmtdata.SectData.StepSectionData.FortranFormatNumbers = "True";
|
||
else fmtdata.SectData.StepSectionData.FortranFormatNumbers = "False";
|
||
if (XtraFlags.UseTopContinueMessageAtEnd == "True") fmtdata.SectData.StepSectionData.UseTopContinueMessageAtEnd = "True";
|
||
else fmtdata.SectData.StepSectionData.UseTopContinueMessageAtEnd = "False";
|
||
if (XtraFlags.FloatingContinueMessage == "True") fmtdata.SectData.StepSectionData.FloatingContinueMessage = "True";
|
||
else fmtdata.SectData.StepSectionData.FloatingContinueMessage = "False";
|
||
if (XtraFlags.WrapSameAsEdit == "True") fmtdata.SectData.StepSectionData.WrapSameAsEdit = "True";
|
||
else fmtdata.SectData.StepSectionData.WrapSameAsEdit = "False";
|
||
if (XtraFlags.ContinueSectionHeader == "True") fmtdata.SectData.StepSectionData.ContinueSectionHeader = "True";
|
||
else fmtdata.SectData.StepSectionData.ContinueSectionHeader = "False";
|
||
if (XtraFlags.CompressHPSub == "True") fmtdata.SectData.StepSectionData.CompressHPSub = "True";
|
||
else fmtdata.SectData.StepSectionData.CompressHPSub = "False";
|
||
if (XtraFlags.CompressHPSuper == "True") fmtdata.SectData.StepSectionData.CompressHPSuper = "True";
|
||
else fmtdata.SectData.StepSectionData.CompressHPSuper = "False";
|
||
//if (XtraFlags.UndSpecialStepsFoldout == "True") fmtdata.SectData.StepSectionData.UndSpecialStepsFoldout = "True";
|
||
//else fmtdata.SectData.StepSectionData.UndSpecialStepsFoldout = "False";
|
||
if (XtraFlags.UnderlineAllMetaTitles == "True") fmtdata.SectData.StepSectionData.UnderlineAllMetaTitles = "True";
|
||
else fmtdata.SectData.StepSectionData.UnderlineAllMetaTitles = "False";
|
||
if (XtraFlags.BoldOnlySectionZero == "True") fmtdata.SectData.StepSectionData.BoldOnlySectionZero = "True";
|
||
else fmtdata.SectData.StepSectionData.BoldOnlySectionZero = "False";
|
||
if (XtraFlags.ImperfectStructure == "True") fmtdata.SectData.StepSectionData.ImperfectStructure = "True";
|
||
else fmtdata.SectData.StepSectionData.ImperfectStructure = "False";
|
||
if (XtraFlags.ImperfectSubstep == "True") fmtdata.SectData.StepSectionData.ImperfectSubstep = "True";
|
||
else fmtdata.SectData.StepSectionData.ImperfectSubstep = "False";
|
||
if (XtraFlags.ImperfectStructurePlus4 == "True") fmtdata.SectData.StepSectionData.ImperfectStructurePlus4 = "True";
|
||
else fmtdata.SectData.StepSectionData.ImperfectStructurePlus4 = "False";
|
||
if (XtraFlags.CountAllSubLevels == "True") fmtdata.SectData.StepSectionData.CountAllSubLevels = "True";
|
||
else fmtdata.SectData.StepSectionData.CountAllSubLevels = "False";
|
||
if (XtraFlags.UseMultiLineSectionTitle == "True") fmtdata.SectData.StepSectionData.UseMultiLineSectionTitle = "True";
|
||
else fmtdata.SectData.StepSectionData.UseMultiLineSectionTitle = "False";
|
||
#endregion
|
||
#region ChangeBars
|
||
if (XtraFlags.CondensedChangeBar == "True") fmtdata.ProcData.ChangeBarData.CondensedChangeBar = "True";
|
||
else fmtdata.ProcData.ChangeBarData.CondensedChangeBar = "False";
|
||
if (XtraFlags.AbsoluteFixedChangeColumn == "True") fmtdata.ProcData.ChangeBarData.AbsoluteFixedChangeColumn = "True";
|
||
else fmtdata.ProcData.ChangeBarData.AbsoluteFixedChangeColumn = "False";
|
||
if (XtraFlags.ContinuousChangeBars == "True") fmtdata.ProcData.ChangeBarData.ContinuousChangeBars = "True";
|
||
else fmtdata.ProcData.ChangeBarData.ContinuousChangeBars = "False";
|
||
if (XtraFlags.ChgBarMessageFromEdit == "True") fmtdata.ProcData.ChangeBarData.ChgBarMessageFromEdit = "True";
|
||
else fmtdata.ProcData.ChangeBarData.ChgBarMessageFromEdit = "False";
|
||
if (XtraFlags.MultipleChangeIds == "True") fmtdata.ProcData.ChangeBarData.MultipleChangeIds = "True";
|
||
else fmtdata.ProcData.ChangeBarData.MultipleChangeIds = "False";
|
||
if (XtraFlags.ChangeBarToRNOSep == "True") fmtdata.ProcData.ChangeBarData.ChangeBarToRNOSep = "True";
|
||
else fmtdata.ProcData.ChangeBarData.ChangeBarToRNOSep = "False";
|
||
if (XtraFlags.ChangeBarsOnLinkedText == "True") fmtdata.ProcData.ChangeBarData.ChangeBarsOnLinkedText = "True";
|
||
else fmtdata.ProcData.ChangeBarData.ChangeBarsOnLinkedText = "False";
|
||
#endregion
|
||
#region GeneralPrint & GeneralEdit
|
||
if (XtraFlags.DoRevDate == "True") fmtdata.PrintData.DoRevDate = "True";
|
||
else fmtdata.PrintData.DoRevDate = "False";
|
||
if (XtraFlags.AlternateFoldoutPages == "True") fmtdata.PrintData.AlternateFoldoutPages = "True";
|
||
else fmtdata.PrintData.AlternateFoldoutPages = "False";
|
||
if (XtraFlags.AlternateFloatingFoldout == "True") fmtdata.PrintData.AlternateFloatingFoldout = "True";
|
||
else fmtdata.PrintData.AlternateFloatingFoldout = "False";
|
||
if (XtraFlags.SectionLevelFoldouts == "True") fmtdata.PrintData.SectionLevelFoldouts = "True";
|
||
else fmtdata.PrintData.SectionLevelFoldouts = "False";
|
||
if (XtraFlags.RevDateWithForwardSlash == "True") fmtdata.PrintData.RevDateWithForwardSlash = "True";
|
||
else fmtdata.PrintData.RevDateWithForwardSlash = "False";
|
||
//if (XtraFlags.SpecialStepsFoldout == "True") fmtdata.PrintData.SpecialStepsFoldout = "True";
|
||
//else fmtdata.PrintData.SpecialStepsFoldout = "False";
|
||
if (XtraFlags.AccessoryDocsInDuplex == "True") fmtdata.PrintData.AccessoryDocsInDuplex = "True";
|
||
else fmtdata.PrintData.AccessoryDocsInDuplex = "False";
|
||
if (XtraFlags.FoldoutsInDuplex == "True") fmtdata.PrintData.FoldoutsInDuplex = "True";
|
||
else fmtdata.PrintData.FoldoutsInDuplex = "False";
|
||
if (XtraFlags.PagelistChangeIDsWithCommas == "True") fmtdata.PrintData.PagelistChangeIDsWithCommas = "True";
|
||
else fmtdata.PrintData.PagelistChangeIDsWithCommas = "False";
|
||
if (XtraFlags.PromptForCautinType == "True") fmtdata.EditData.PromptForCautionType = "True";
|
||
else fmtdata.EditData.PromptForCautionType = "False";
|
||
fmtdata.PrintData.AllowDuplex = _fmtFileName.StartsWith("WPB") || _fmtFileName.StartsWith("WEP2") ? "True" : "False";
|
||
#endregion
|
||
#region Procedure
|
||
if (XtraFlags.DontCapitalizeTitle == "True") fmtdata.ProcData.CapitalizeTitle = "False";
|
||
else fmtdata.ProcData.CapitalizeTitle = "True";
|
||
if (XtraFlags.ChangeStyleForEverySection == "True") fmtdata.ProcData.ChangeStyleForEverySection = "True";
|
||
else fmtdata.ProcData.ChangeStyleForEverySection = "False";
|
||
if (XtraFlags.DontPrintNoTitle == "True") fmtdata.ProcData.PrintNoTitle = "False";
|
||
else fmtdata.ProcData.PrintNoTitle = "True";
|
||
if (XtraFlags.NotesToFootnotes == "True") fmtdata.ProcData.NotesToFootnotes = "True";
|
||
else fmtdata.ProcData.NotesToFootnotes = "False";
|
||
if (XtraFlags.DontCountFoldoutPages == "True") fmtdata.ProcData.CountFoldoutPages = "False";
|
||
else fmtdata.ProcData.CountFoldoutPages = "True";
|
||
#endregion
|
||
#region Section
|
||
//if (XtraFlags.CancelSecTitlesOnS1 == "True") fmtdata.SectData.CancelSecTitlesOnS1 = "True";
|
||
//else fmtdata.SectData.CancelSecTitlesOnS1 = "False";
|
||
//if (XtraFlags.CancelSecTitlesOnS2 == "True") fmtdata.SectData.CancelSecTitlesOnS2 = "True";
|
||
//else fmtdata.SectData.CancelSecTitlesOnS2 = "False";
|
||
//if (XtraFlags.CancelSecTitlesOnE0 == "True") fmtdata.SectData.CancelSecTitlesOnE0 = "True";
|
||
//else fmtdata.SectData.CancelSecTitlesOnE0 = "False";
|
||
//if (XtraFlags.CancelSecTitlesOnE2 == "True") fmtdata.SectData.CancelSecTitlesOnE2 = "True";
|
||
//else fmtdata.SectData.CancelSecTitlesOnE2 = "False";
|
||
if (XtraFlags.MetaSectEndMessage == "True") fmtdata.SectData.MetaSectEndMessage = "True";
|
||
else fmtdata.SectData.MetaSectEndMessage = "False";
|
||
if (XtraFlags.ReadOnlyTypeInContMsg == "True") fmtdata.SectData.ReadOnlyTypeInContMsg = "True";
|
||
else fmtdata.SectData.ReadOnlyTypeInContMsg = "False";
|
||
if (XtraFlags.DontReplaceWordsInROs == "True") fmtdata.SectData.ReplaceWordsInROs = "False";
|
||
else fmtdata.SectData.ReplaceWordsInROs = "True";
|
||
if (XtraFlags.UseMetaSections == "True") fmtdata.SectData.UseMetaSections = "True";
|
||
else fmtdata.SectData.UseMetaSections = "False";
|
||
if (XtraFlags.NonEditableSteps == "True") fmtdata.SectData.NonEditableSteps = "True";
|
||
else fmtdata.SectData.NonEditableSteps = "False";
|
||
if (XtraFlags.SearchAllReplaceWords == "True") fmtdata.SectData.SearchAllReplaceWords = "True";
|
||
else fmtdata.SectData.SearchAllReplaceWords = "False";
|
||
if (XtraFlags.SecTitleContinue == "True") fmtdata.SectData.SecTitleContinue = "True";
|
||
else fmtdata.SectData.SecTitleContinue = "False";
|
||
if (XtraFlags.DontConvertCaretToDelta == "True") fmtdata.SectData.ConvertCaretToDelta = "False";
|
||
else fmtdata.SectData.ConvertCaretToDelta = "True";
|
||
#endregion
|
||
#region StepSectionPrint
|
||
if (XtraFlags.LowerCaseRevnum == "True") fmtdata.SectData.StepSectionData.StpSectPrtData.LowerCaseRevNum = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectPrtData.LowerCaseRevNum = "False";
|
||
if (XtraFlags.UseXtraRevNumber == "True") fmtdata.SectData.StepSectionData.StpSectPrtData.UseXtraRevNumber = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectPrtData.UseXtraRevNumber = "False";
|
||
if (XtraFlags.SpecialLandscapeMode == "True") fmtdata.SectData.StepSectionData.StpSectPrtData.SpecialLandscapeMode = "True";
|
||
else fmtdata.SectData.StepSectionData.StpSectPrtData.SpecialLandscapeMode = "False";
|
||
#endregion
|
||
#region CheckOff
|
||
if (XtraFlags.DropCheckOff == "True") fmtdata.ProcData.CheckOffData.DropCheckOff = "True";
|
||
else fmtdata.ProcData.CheckOffData.DropCheckOff = "False";
|
||
if (XtraFlags.CheckoffOnHLSOnly == "True") fmtdata.ProcData.CheckOffData.CheckOffOnHLSOnly = "True";
|
||
else fmtdata.ProcData.CheckOffData.CheckOffOnHLSOnly = "False";
|
||
#endregion
|
||
#region Trans
|
||
if (XtraFlags.SpecifiedSubstepsOnly == "True") fmtdata.TransData.SpecifiedSubstepsOnly = "True";
|
||
else fmtdata.TransData.SpecifiedSubstepsOnly = "False";
|
||
if (XtraFlags.CapsTransitions == "True") fmtdata.TransData.CapsTransitions = "True";
|
||
else fmtdata.TransData.CapsTransitions = "False";
|
||
if (XtraFlags.CapTranStep == "True") fmtdata.TransData.CapTranStep = "True";
|
||
else fmtdata.TransData.CapTranStep = "False";
|
||
if (XtraFlags.TSTepNoFlag == "True") fmtdata.TransData.TStepNoFlag = "True";
|
||
else fmtdata.TransData.TStepNoFlag = "False";
|
||
if (XtraFlags.LowerCaseTranNumber == "True") fmtdata.TransData.LowerCaseTranNumber = "True";
|
||
else fmtdata.TransData.LowerCaseTranNumber = "False";
|
||
if (XtraFlags.UpcaseTranAnd == "True") fmtdata.TransData.UpcaseTranAnd = "True";
|
||
else fmtdata.TransData.UpcaseTranAnd = "False";
|
||
if (XtraFlags.SuppressAndInTran == "True") fmtdata.TransData.SuppressAndInTran = "True";
|
||
else fmtdata.TransData.SuppressAndInTran = "False";
|
||
if (XtraFlags.Cap1stCharTrans == "True") fmtdata.TransData.Cap1stCharTrans = "True";
|
||
else fmtdata.TransData.Cap1stCharTrans = "False";
|
||
if (XtraFlags.UseTransitionModifier == "True") fmtdata.TransData.UseTransitionModifier = "True";
|
||
else fmtdata.TransData.UseTransitionModifier = "False";
|
||
if (XtraFlags.DontUseSecTitles == "True") fmtdata.TransData.UseSecTitles = "False";
|
||
else fmtdata.TransData.UseSecTitles = "True";
|
||
if (XtraFlags.HardSpTranProcNumb == "True") fmtdata.TransData.HardSpTranProcNumb = "True";
|
||
else fmtdata.TransData.HardSpTranProcNumb = "False";
|
||
if (XtraFlags.XChngTranSpForHard == "True") fmtdata.TransData.XchngTranSpForHard = "True";
|
||
else fmtdata.TransData.XchngTranSpForHard = "False";
|
||
if (XtraFlags.AbsoluteTransitionUpdate == "True") fmtdata.TransData.AbsoluteTransitionUpdate = "True";
|
||
else fmtdata.TransData.AbsoluteTransitionUpdate = "False";
|
||
if (XtraFlags.LowerCaseStepInTran == "True") fmtdata.TransData.LowerCaseStepInTran = "True";
|
||
else fmtdata.TransData.LowerCaseStepInTran = "False";
|
||
if (XtraFlags.DoSectionTrans == "True") fmtdata.TransData.DoSectionTransitions = "True";
|
||
else fmtdata.TransData.DoSectionTransitions = "False";
|
||
#endregion
|
||
#region RO
|
||
if (XtraFlags.AllUnits == "True") fmtdata.ROData.AllUnits = "True";
|
||
else fmtdata.ROData.AllUnits = "False";
|
||
if (XtraFlags.UpSetpntAftrDash == "True") fmtdata.ROData.UpRoAftrDash = "True";
|
||
else fmtdata.ROData.UpRoAftrDash = "False";
|
||
if (XtraFlags.UpcaseAllSetpointUnits == "True") fmtdata.ROData.UpcaseAllRoUnits = "True";
|
||
else fmtdata.ROData.UpcaseAllRoUnits = "False";
|
||
if (XtraFlags.CapHighSetpnt == "True") fmtdata.ROData.CapHighRo = "True";
|
||
else fmtdata.ROData.CapHighRo = "False";
|
||
if (XtraFlags.CapsPIFLastLower == "True") fmtdata.ROData.CapRoIfLastLower = "True";
|
||
else fmtdata.ROData.CapRoIfLastLower = "False";
|
||
if (XtraFlags.UpSpIfPrevUpper == "True") fmtdata.ROData.UpRoIfPrevUpper = "True";
|
||
else fmtdata.ROData.UpRoIfPrevUpper = "False";
|
||
if (XtraFlags.UnderlineSetpoints == "True") fmtdata.ROData.UnderlineRo = "True";
|
||
else fmtdata.ROData.UnderlineRo = "False";
|
||
if (XtraFlags.CapFirstLetterInHighSP == "True") fmtdata.ROData.CapFirstLetterInHighRO = "True";
|
||
else fmtdata.ROData.CapFirstLetterInHighRO = "False";
|
||
#endregion
|
||
#region New Format Flags
|
||
// by default TurnOffReplaceWords should be False.
|
||
// this will be overrided as needed (ex. NSP (Prairie Island) Deviations
|
||
fmtdata.SectData.TurnOffReplaceWords = "False";
|
||
#endregion
|
||
return true;
|
||
}
|
||
|
||
private string GetTransUIEnum(string format, string menu)
|
||
{
|
||
string transtrtmp = (menu == null || menu == "") ? format : menu;
|
||
E_TransFormatXlate xlt = TransFormat(transtrtmp);
|
||
// xlt has flags that say what is included in the transition menu
|
||
// string. Use this to set the enum that the 32-bit code will use
|
||
// to display menuing...
|
||
E_TransitionMenus transmenuflag = TransToMenuFlags(xlt);
|
||
return ((E_TransitionMenus)transmenuflag).ToString();
|
||
}
|
||
private E_TransitionMenus TransToMenuFlags(E_TransFormatXlate xlt)
|
||
{
|
||
E_TransitionMenus result = E_TransitionMenus.None;
|
||
|
||
// for procedures, if the menu string contains a 'procedure', then the
|
||
// selection will come from a menu, otherwise, it defaults to current procedure
|
||
// and the menu will be disabled.
|
||
result |= (xlt & E_TransFormatXlate.Procedure) == E_TransFormatXlate.Procedure ? E_TransitionMenus.ProcMenu : E_TransitionMenus.ProcCur;
|
||
|
||
// for sections...
|
||
if ((xlt & E_TransFormatXlate.Section) == E_TransFormatXlate.Section)
|
||
{
|
||
if ((xlt & E_TransFormatXlate.Range) == E_TransFormatXlate.Range)
|
||
result |= E_TransitionMenus.SectMenuStep;
|
||
else
|
||
result |= E_TransitionMenus.SectMenuAny;
|
||
|
||
}
|
||
else
|
||
{
|
||
if ((xlt & E_TransFormatXlate.Procedure) == E_TransFormatXlate.Procedure)
|
||
result |= E_TransitionMenus.SectDefault;
|
||
else
|
||
result |= E_TransitionMenus.SectCur;
|
||
}
|
||
|
||
// now do steps...
|
||
if ((xlt & E_TransFormatXlate.Range) == E_TransFormatXlate.Range)
|
||
{
|
||
result |= E_TransitionMenus.StepFirst;
|
||
result |= E_TransitionMenus.StepLast;
|
||
}
|
||
else
|
||
result |= E_TransitionMenus.StepFirst;
|
||
if (((result & E_TransitionMenus.SectDefault) == E_TransitionMenus.SectDefault) || ((result & E_TransitionMenus.SectMenuAny) == E_TransitionMenus.SectMenuAny))
|
||
result |= E_TransitionMenus.StepAllowNone;
|
||
|
||
return result;
|
||
}
|
||
private static E_TransFormatXlate TransFormat(string str)
|
||
{
|
||
E_TransFormatXlate retval = E_TransFormatXlate.None;
|
||
if (HasRange(str)) retval |= E_TransFormatXlate.Range;
|
||
else if (HasStep(str)) retval |= E_TransFormatXlate.Step;
|
||
if (HasSection(str)) retval |= E_TransFormatXlate.Section;
|
||
if (HasProc(str)) retval |= E_TransFormatXlate.Procedure;
|
||
if (HasPage(str)) retval |= E_TransFormatXlate.Page;
|
||
return retval;
|
||
}
|
||
private static bool HasProc(string str)
|
||
{
|
||
return str.Contains("{Proc") || str.Contains("{?.Proc");
|
||
}
|
||
private static bool HasPage(string str)
|
||
{
|
||
return str.Contains("{Page");
|
||
}
|
||
private static bool HasSection(string str)
|
||
{
|
||
return str.Contains("{Sect") || str.Contains("{?.Sect");
|
||
}
|
||
private static bool HasRange(string str)
|
||
{
|
||
return str.Contains("{Last");
|
||
}
|
||
private static bool HasStep(string str)
|
||
{
|
||
if (str.Contains("{Step")) return true;
|
||
return str.Contains("{First Step");
|
||
}
|
||
private string ConvertSeqStart(byte p)
|
||
{
|
||
if (p == 0 || p == 0x30) return "{numeric}";
|
||
else if (p == 0x60) return "{alpha}";
|
||
else if (p == 0x40) return "{ALPHA}";
|
||
else return "{UNKNOWN}";
|
||
}
|
||
#endregion
|
||
private static Dictionary<string, XslCompiledTransform> _TransForms = new Dictionary<string, XslCompiledTransform>();
|
||
public static XslCompiledTransform getTransform(string path)
|
||
{
|
||
if (!_TransForms.ContainsKey(path))
|
||
{
|
||
XslCompiledTransform xsl = new XslCompiledTransform();
|
||
xsl.Load(path);
|
||
_TransForms.Add(path, xsl);
|
||
}
|
||
return _TransForms[path];
|
||
}
|
||
public bool WriteOutXmlTmp(FormatData fmtdata, string suffix)
|
||
{
|
||
try
|
||
{
|
||
XmlSerializer serializer = new XmlSerializer(typeof(FormatData));
|
||
string lfmtname = fmtName;
|
||
int findx = fmtName.IndexOf('.');
|
||
// for subformats, make the name FMT_00 where FMT is format name & 00 is number
|
||
// from original name. This will allow the data load to know it's a sub.
|
||
if (findx > 0)
|
||
lfmtname = fmtName.Substring(0, fmtName.Length - 4) + "_" + fmtName.Substring(fmtName.Length - 2, 2);
|
||
string destfile = "tmp_fmt_xml\\" + lfmtname + "_" + suffix + ".xml";
|
||
if (File.Exists(destfile)) File.Delete(destfile);
|
||
TextWriter writer = new StreamWriter(destfile);
|
||
_MyFormatSerializer.Serialize(writer, fmtdata);
|
||
writer.Close();
|
||
return true;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine("Error writing out xml or xsl - format = {0}", fmtdata.Name);
|
||
Console.WriteLine(e.Message);
|
||
Console.WriteLine();
|
||
return false;
|
||
}
|
||
}
|
||
#region WriteOutXml
|
||
static private XmlSerializer _MyFormatSerializer = new XmlSerializer(typeof(FormatData));
|
||
public bool WriteOutXml(FormatData fmtdata)
|
||
{
|
||
// First serialize files based on the above - then use xsl to transform
|
||
// into prefered xml.
|
||
if (!Directory.Exists("fmt_xml")) Directory.CreateDirectory("fmt_xml");
|
||
if (!Directory.Exists("tmp_fmt_xml")) Directory.CreateDirectory("tmp_fmt_xml");
|
||
//XmlSerializer serializer = new XmlSerializer(typeof(FormatData));
|
||
|
||
string lfmtname = fmtName;
|
||
int findx = fmtName.IndexOf('.');
|
||
// for subformats, make the name FMT_00 where FMT is format name & 00 is number
|
||
// from original name. This will allow the data load to know it's a sub.
|
||
if (findx > 0)
|
||
lfmtname = fmtName.Substring(0, fmtName.Length - 4) + "_" + fmtName.Substring(fmtName.Length - 2, 2);
|
||
string destfile = "tmp_fmt_xml\\" + lfmtname + "f.xml";
|
||
if (File.Exists(destfile)) File.Delete(destfile);
|
||
TextWriter writer = new StreamWriter(destfile);
|
||
try
|
||
{
|
||
_MyFormatSerializer.Serialize(writer, fmtdata);
|
||
writer.Close();
|
||
//XslCompiledTransform xsl = new XslCompiledTransform();
|
||
//xsl.Load(Application.StartupPath + "\\TranslateFmt.XSL");
|
||
string sResults = "fmt_xml\\" + lfmtname + "f.xml";
|
||
//xsl.Transform(destfile, sResults); // Perform Transform
|
||
XslCompiledTransform xsl = getTransform(Application.StartupPath + "\\TranslateFmt.XSL");
|
||
xsl.Transform(destfile, sResults); // Perform Transform
|
||
xsl = getTransform(Application.StartupPath + "\\removeempty.XSL");
|
||
//xsl.Load(Application.StartupPath + "\\removeempty.XSL");
|
||
string sResults2 = "fmt_xml\\" + lfmtname + "xf.xml";
|
||
xsl.Transform(sResults, sResults2);
|
||
File.Delete(sResults);
|
||
xsl.Transform(sResults2, sResults);
|
||
File.Delete(sResults2);
|
||
}
|
||
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine("Error writing out xml or xsl - format = {0}", fmtdata.Name);
|
||
Console.WriteLine(e.Message);
|
||
Console.WriteLine();
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
#endregion
|
||
#region OriginalNoBase
|
||
//public void LoadFormatFileOrig(string fname)
|
||
//{
|
||
// FormatData fmtdata = new FormatData();
|
||
|
||
// // read in data & put into correct place of structures.
|
||
// // for test string fnm = "E:\\proms.net\\exe\\fmtxml\\" + fname;
|
||
// string fnm = "E:\\ve-proms\\format\\" + fname;
|
||
// brFmt = new BinaryReader(File.Open(fnm, System.IO.FileMode.Open, System.IO.FileAccess.ReadWrite, FileShare.ReadWrite));
|
||
// bool success = ReadInFmtFile(ref fmtdata);
|
||
// #region FinishMainConvert
|
||
// if (success)
|
||
// {
|
||
// DoStepInheritance(ref fmtdata.StepData);
|
||
// success = WriteOutXml(fmtdata);
|
||
// }
|
||
// #endregion
|
||
// brFmt.Close();
|
||
|
||
// #region ProcessSubFormats
|
||
// // For each sub-format, load the entire file & compare to parent contents
|
||
// DirectoryInfo di = new DirectoryInfo("E:\\ve-proms\\format");
|
||
// string substr = fname.Substring(0, fname.IndexOf('.')) + ".x*";
|
||
// FileInfo [] fis = di.GetFiles(substr);
|
||
// foreach (FileInfo fi in fis)
|
||
// {
|
||
// //this.listBox1.Items.Add(fi.Name);
|
||
// fmtName = fi.Name;
|
||
// fnm = "E:\\ve-proms\\format\\" + fi.Name;
|
||
// brFmt = new BinaryReader(File.Open(fnm, System.IO.FileMode.Open, System.IO.FileAccess.ReadWrite, FileShare.ReadWrite));
|
||
// FormatData subdata = new FormatData();
|
||
// success = ReadInFmtFile(ref subdata);
|
||
// if (success)
|
||
// {
|
||
// DoStepInheritance(ref subdata.StepData);
|
||
// }
|
||
// // Now do entire format inheritance - then write out.
|
||
// success = CompareParentSub(fmtdata, ref subdata);
|
||
// success = WriteOutXml(subdata);
|
||
|
||
// }
|
||
// #endregion
|
||
//}
|
||
#endregion
|
||
#region InheritBase
|
||
public void LoadFormatFile(string fname, ref XtraFlgs XtraFlags)
|
||
{
|
||
FormatData fmtdata = new FormatData();
|
||
|
||
// read in data & put into correct place of structures.
|
||
// for test string fnm = "E:\\proms.net\\exe\\fmtxml\\" + fname;
|
||
string fnm = MyPath + @"\" + fname;
|
||
brFmt = new BinaryReader(File.Open(fnm, System.IO.FileMode.Open, System.IO.FileAccess.ReadWrite, FileShare.ReadWrite));
|
||
bool success = ReadInFmtFile(ref fmtdata, ref BaseXtraFlags, fname);
|
||
AddPlantSpecific(fname, ref fmtdata);
|
||
if (!HasBase) SetBaseStepNumericValues(ref fmtdata);
|
||
FixInactiveForHigh(ref fmtdata);
|
||
FixInactiveForSubStep(ref fmtdata);
|
||
FixInactiveForText(ref fmtdata);
|
||
if (!HasBase) InitSymbols(ref fmtdata);
|
||
else fmtdata.Symbols = null;
|
||
if (success)
|
||
{
|
||
PushStepLists(fmtdata.StepData);
|
||
DoStepInheritance(ref fmtdata.StepData, fname);
|
||
AddPlantSpecificOverrideInheritance(fname, ref fmtdata);
|
||
}
|
||
brFmt.Close();
|
||
|
||
// Now compare with gen (if !gen).
|
||
if (HasBase == false)
|
||
success = WriteOutXml(fmtdata);
|
||
else
|
||
{
|
||
//success = WriteOutXmlTmp(fmtdata, "beforeParent");
|
||
success = CompareParentSub(BaseFormat, ref fmtdata);
|
||
AddPlantSpecificOverrideAfterInheritance(fname, ref fmtdata);
|
||
success = WriteOutXml(fmtdata);
|
||
|
||
// For each sub-format, load the entire file & compare to parent contents
|
||
DirectoryInfo di = new DirectoryInfo(MyPath);
|
||
string substr = fname.Substring(0, fname.IndexOf('.')) + ".x*";
|
||
FileInfo[] fis = di.GetFiles(substr);
|
||
foreach (FileInfo fi in fis)
|
||
{
|
||
if (!Form1.Excluded(fi))
|
||
{
|
||
//this.listBox1.Items.Add(fi.Name);
|
||
fmtName = fi.Name;
|
||
fnm = MyPath + @"\" + fi.Name;
|
||
brFmt = new BinaryReader(File.Open(fnm, System.IO.FileMode.Open, System.IO.FileAccess.ReadWrite, FileShare.ReadWrite));
|
||
FormatData subdata = new FormatData();
|
||
success = ReadInFmtFile(ref subdata, ref SubXtraFlags, fi.Name);
|
||
AddPlantSpecific(fi.Name, ref subdata);
|
||
//OutputStepFonts(fi.Name, subdata);
|
||
if (success)
|
||
{
|
||
PushStepLists(subdata.StepData);
|
||
DoStepInheritance(ref subdata.StepData,fname);
|
||
AddPlantSpecificOverrideInheritance(fmtName, ref subdata);
|
||
PopStepLists();
|
||
}
|
||
// Now do entire format inheritance - then write out.
|
||
success = CompareParentSub(fmtdata, ref subdata);
|
||
success = CompareParentSub(BaseFormat, ref subdata);
|
||
AddPlantSpecificOverrideAfterInheritance(fmtName, ref subdata);
|
||
success = WriteOutXml(subdata);
|
||
}
|
||
}
|
||
}
|
||
MyFormat = fmtdata;
|
||
if (HasBase) PopStepLists(); // leave the base format on 'stack', i.e. only pop if !base.
|
||
}
|
||
|
||
private void AddPlantSpecificOverrideAfterInheritance(string genFileName, ref FormatData fmtdata)
|
||
{
|
||
string genName = genFileName.Substring(genFileName.LastIndexOf('\\') + 1);
|
||
switch (genName.ToUpper())
|
||
{
|
||
case "CPL.X03":
|
||
OverrideCPL_X03(ref fmtdata);
|
||
break;
|
||
case "MCG.FMT":
|
||
case "MCGBOX.FMT":
|
||
AddMCGfmtOVR(ref fmtdata);
|
||
break;
|
||
case "CAT.FMT":
|
||
case "CATBOX.FMT":
|
||
AddCATfmtOVR(ref fmtdata);
|
||
break;
|
||
}
|
||
}
|
||
|
||
private void SetBaseStepNumericValues(ref FormatData fmtdata)
|
||
{
|
||
Step stp = fmtdata.StepData[0];
|
||
stp.ColOverride = "0";
|
||
stp.ColOverrideEdit = "0";
|
||
stp.WidthOverride = "0";
|
||
stp.WidthOverrideEdit = "0";
|
||
stp.StepLayoutData.STExtraSpace = "0";
|
||
stp.StepLayoutData.EveryNLines = "1"; //default for this is 1
|
||
stp.StepLayoutData.SpaceAfter = "0";
|
||
stp.StepLayoutData.SpaceBefore = "0";
|
||
}
|
||
|
||
private void PushStepLists(Step[] stpdata)
|
||
{
|
||
Dictionary<string, Step> dicSteps = BuildStepDic(stpdata);
|
||
StepList.Insert(0, dicSteps);
|
||
Dictionary<string, Step> dicParents = BuildParentDic(stpdata, dicSteps);
|
||
StepParentList.Insert(0, dicParents);
|
||
}
|
||
private void PopStepLists()
|
||
{
|
||
StepList.RemoveAt(0);
|
||
StepParentList.RemoveAt(0);
|
||
}
|
||
private static void OutputStepFonts1(string fname, FormatData fmtdata)
|
||
{
|
||
if (fname == "BASE.fmt")
|
||
{
|
||
Console.Write("'Name','Description'");
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
Console.Write(",'{0}'", fmtdata.StepData[i].Type);
|
||
}
|
||
Console.Write("\r\n");
|
||
Console.Write("'base','Default'");
|
||
}
|
||
else
|
||
Console.Write("'{0}','{1}'", FixName(fname), fmtdata.Name);
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
if (fmtdata.StepData[i].Font != null)
|
||
Console.Write(",'{0} [{1}] - {2}'", fmtdata.StepData[i].Font.FontFamily, fmtdata.StepData[i].Font.FontSize, fmtdata.StepData[i].Font.FontStyle);
|
||
else if (i == 1 && fmtdata.StepData[0].Font != null)
|
||
Console.Write(",'{0} [{1}] - {2}'", fmtdata.StepData[0].Font.FontFamily, fmtdata.StepData[0].Font.FontSize, fmtdata.StepData[0].Font.FontStyle);
|
||
else
|
||
Console.Write(",'Prestige Elite Tall [10] - None'");
|
||
}
|
||
Console.Write("\r\n");
|
||
}
|
||
private static void OutputStepFonts(string fname, FormatData fmtdata)
|
||
{
|
||
if (fname == "BASE.fmt")
|
||
{
|
||
Console.Write("'Name','Description'");
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
Console.Write(",'{0}'", fmtdata.StepData[i].Type);
|
||
}
|
||
Console.Write("\r\n");
|
||
Console.Write("'base','Default'");
|
||
}
|
||
else
|
||
Console.Write("'{0}','{1}'", FixName(fname), fmtdata.Name);
|
||
for (int i = 0; i < MAXSTEPS + 1; i++)
|
||
{
|
||
if (fmtdata.StepData[i].TabData.Font != null)
|
||
Console.Write(",'{0} [{1}] - {2}'", fmtdata.StepData[i].TabData.Font.FontFamily, fmtdata.StepData[i].TabData.Font.FontSize, fmtdata.StepData[i].TabData.Font.FontStyle);
|
||
else if (i == 1 && fmtdata.StepData[0].TabData.Font != null)
|
||
Console.Write(",'{0} [{1}] - {2}'", fmtdata.StepData[0].TabData.Font.FontFamily, fmtdata.StepData[0].TabData.Font.FontSize, fmtdata.StepData[0].TabData.Font.FontStyle);
|
||
else
|
||
Console.Write(",'*'");
|
||
}
|
||
Console.Write("\r\n");
|
||
}
|
||
private static string FixName(string fname)
|
||
{
|
||
string lfmtname = fname;
|
||
int findx = fname.IndexOf('.');
|
||
// for subformats, make the name FMT_00 where FMT is format name & 00 is number
|
||
// from original name. This will allow the data load to know it's a sub.
|
||
if (findx > 0)
|
||
{
|
||
if (fname.ToUpper().EndsWith(".FMT"))
|
||
lfmtname = fname.Substring(0, fname.Length - 4);
|
||
else
|
||
lfmtname = fname.Substring(0, fname.Length - 4) + fname.Substring(fname.Length - 2, 2);
|
||
}
|
||
return lfmtname;
|
||
}
|
||
private void InitSymbols(ref FormatData fmtdata)
|
||
{
|
||
fmtdata.Symbols = new Symbol[37];
|
||
fmtdata.Symbols[0].Unicode = "176";
|
||
fmtdata.Symbols[0].Desc = "degree";
|
||
fmtdata.Symbols[1].Unicode = "916";
|
||
fmtdata.Symbols[1].Desc = "delta";
|
||
fmtdata.Symbols[2].Unicode = "8805";
|
||
fmtdata.Symbols[2].Desc = "greater than or equal";
|
||
fmtdata.Symbols[3].Unicode = "8804";
|
||
fmtdata.Symbols[3].Desc = "less than or equal";
|
||
fmtdata.Symbols[4].Unicode = "177";
|
||
fmtdata.Symbols[4].Desc = "plus minus";
|
||
fmtdata.Symbols[5].Unicode = "931";
|
||
fmtdata.Symbols[5].Desc = "sigma";
|
||
fmtdata.Symbols[6].Unicode = "947";
|
||
fmtdata.Symbols[6].Desc = "gamma";
|
||
fmtdata.Symbols[7].Unicode = "189";
|
||
fmtdata.Symbols[7].Desc = "half";
|
||
fmtdata.Symbols[8].Unicode = "9604";
|
||
fmtdata.Symbols[8].Desc = "accum";
|
||
fmtdata.Symbols[9].Unicode = "9679";
|
||
fmtdata.Symbols[9].Desc = "bullet";
|
||
fmtdata.Symbols[10].Unicode = "8776";
|
||
fmtdata.Symbols[10].Desc = "approx eq";
|
||
fmtdata.Symbols[11].Unicode = "8773";
|
||
fmtdata.Symbols[11].Desc = "similar eq";
|
||
fmtdata.Symbols[12].Unicode = "247";
|
||
fmtdata.Symbols[12].Desc = "division";
|
||
fmtdata.Symbols[13].Unicode = "8730";
|
||
fmtdata.Symbols[13].Desc = "square root";
|
||
fmtdata.Symbols[14].Unicode = "961";
|
||
fmtdata.Symbols[14].Desc = "rho";
|
||
fmtdata.Symbols[15].Unicode = "960";
|
||
fmtdata.Symbols[15].Desc = "pi";
|
||
fmtdata.Symbols[16].Unicode = "956";
|
||
fmtdata.Symbols[16].Desc = "micro";
|
||
fmtdata.Symbols[17].Unicode = "948";
|
||
fmtdata.Symbols[17].Desc = "lower case delta";
|
||
fmtdata.Symbols[18].Unicode = "963";
|
||
fmtdata.Symbols[18].Desc = "lower case sigma";
|
||
fmtdata.Symbols[19].Unicode = "188";
|
||
fmtdata.Symbols[19].Desc = "quarter";
|
||
fmtdata.Symbols[20].Unicode = "216";
|
||
fmtdata.Symbols[20].Desc = "dist zero";
|
||
fmtdata.Symbols[21].Unicode = "274";
|
||
fmtdata.Symbols[21].Desc = "energy";
|
||
fmtdata.Symbols[22].Unicode = "236";
|
||
fmtdata.Symbols[22].Desc = "grave";
|
||
fmtdata.Symbols[23].Unicode = "9474";
|
||
fmtdata.Symbols[23].Desc = "bar";
|
||
fmtdata.Symbols[24].Unicode = "949";
|
||
fmtdata.Symbols[24].Desc = "epsilon";
|
||
fmtdata.Symbols[25].Unicode = "952";
|
||
fmtdata.Symbols[25].Desc = "theta";
|
||
fmtdata.Symbols[26].Unicode = "8857";
|
||
fmtdata.Symbols[26].Desc = "dot in oval";
|
||
fmtdata.Symbols[27].Unicode = "964";
|
||
fmtdata.Symbols[27].Desc = "tau";
|
||
fmtdata.Symbols[28].Unicode = "9830";
|
||
fmtdata.Symbols[28].Desc = "diamond";
|
||
fmtdata.Symbols[29].Unicode = "8594";
|
||
fmtdata.Symbols[29].Desc = "right arrow";
|
||
fmtdata.Symbols[30].Unicode = "8592";
|
||
fmtdata.Symbols[30].Desc = "left arrow";
|
||
fmtdata.Symbols[31].Unicode = "8593";
|
||
fmtdata.Symbols[31].Desc = "up arrow";
|
||
fmtdata.Symbols[32].Unicode = "8595";
|
||
fmtdata.Symbols[32].Desc = "down arrow";
|
||
fmtdata.Symbols[33].Unicode = "8711";
|
||
fmtdata.Symbols[33].Desc = "unknown5";
|
||
fmtdata.Symbols[34].Unicode = "945";
|
||
fmtdata.Symbols[34].Desc = "alpha";
|
||
fmtdata.Symbols[35].Unicode = "946";
|
||
fmtdata.Symbols[35].Desc = "beta";
|
||
}
|
||
#endregion
|
||
#region TokenConvert
|
||
private string ConvertTransFormat(string p)
|
||
{
|
||
// parenflag puts paren around proc title AND sectitle.
|
||
p = p.Replace("\xff", "\xA0");
|
||
p = p.Replace("\x07", "{First Step}");
|
||
p = p.Replace("\x08", "{Last Step}");
|
||
p = p.Replace("\x04", "{Sect Title}");
|
||
p = p.Replace("\x06", "{Sect Title}");
|
||
p = p.Replace("\x03", "{Sect Num}");
|
||
p = p.Replace("\x17", "{Sect Num}");
|
||
p = p.Replace("\x02", "{Proc Title}");
|
||
p = p.Replace("\x01", "{Proc Num}");
|
||
p = p.Replace("\xF", "{Page Num}");
|
||
p = p.Replace("\x1E", "{Page Num}");
|
||
p = p.Replace("\x1D", "{Step Text}");
|
||
p = p.Replace("\x0D", "Step {First Step}");
|
||
|
||
// the following are in cpl & she format Not sure what to do so just
|
||
// flag them
|
||
//if (p.Length==1 && (p.IndexOfAny("\x19\x1A".ToCharArray())>-1))
|
||
//{
|
||
p = p.Replace("\x19", "{TransFmt hex 19}");
|
||
p = p.Replace("\x1A", "{TransFmt hex 1a}");
|
||
//}
|
||
|
||
p = ConvertText(p);
|
||
p = DoReplaceTokens(p);
|
||
return p;
|
||
}
|
||
private string DoReplaceTokens(string p)
|
||
{
|
||
if (p == null || p == "") return p;
|
||
string wkstr = p;
|
||
// use regular expressions to do the following...
|
||
|
||
try
|
||
{
|
||
// replace newline with {par}
|
||
wkstr = wkstr.Replace("\n", @"{\par}");
|
||
|
||
// special change bar token (various cpl formats)
|
||
wkstr = wkstr.Replace("\x08\x08\x08\x08\x08\x05", "{CHG_BAR with Backspace Token}");
|
||
|
||
// special change bar token (various gpc formats)
|
||
wkstr = wkstr.Replace("\x05", "{CHG_BAR Token}");
|
||
|
||
// backspage - just flag for positioning if needed.
|
||
wkstr = wkstr.Replace("\x08", "{Backspace}");
|
||
|
||
//sub on/off
|
||
//sub on/off - stop at EOL, another token or a space.
|
||
wkstr = wkstr.Replace("\x19\x19", "\x19"); // replace double sub on with single
|
||
wkstr = wkstr.Replace("~~", "\x19");
|
||
wkstr = Regex.Replace(wkstr, @"\x19([^\x19\x18 ]*?)(?:[\x19\x18]|(?= )|\Z)(.*?)", @"\dn2 $1\up0 $2");
|
||
|
||
//super on/off
|
||
//super on/off - stop at EOL, another token or a space.
|
||
wkstr = Regex.Replace(wkstr, @"\x18([^\x19\x18 ]*?)(?:[\x19\x18]|(?= )|\Z)(.*?)", @"\up2 $1\up0 $2");
|
||
|
||
//bold on/off - stop at end of line or another token.
|
||
wkstr = Regex.Replace(wkstr, @"\x01([^\x01]*?)(?:\x01|\Z)", @"\b $1\b0 ");
|
||
//OLD CODE (pre-10/2007): wkstr = Regex.Replace(wkstr, @"\x01([^\x01 ]*?)(?:[\x01]|(?= )|\Z)(.*?)", @"\b$1\b0$2");
|
||
//bold on/off - stop at EOL, another token or a space
|
||
wkstr = Regex.Replace(wkstr, @"\x13([^\x13\xd6 ]*?)(?:[\x13\xd6]|(?= )|\Z)(.*?)", @"\b $1\b0 $2");
|
||
|
||
//underline on/off - look for 16 followed by non-sixteen (as many as there are) and followed by 16 or endofline
|
||
//OLD CODE (pre-10/2007): wkstr = Regex.Replace(wkstr, @"\x16([^\x16 ]*?)(?:[\x16]|(?= )|\Z)(.*?)", @"\ul$1\ul0$2");
|
||
//underline on/off - stop at end of line or another token.
|
||
//wkstr = Regex.Replace(wkstr, @"\x16([^\x16]*?)(?:\x16|\Z)", @"\ul $1\ul0 ");
|
||
wkstr = Regex.Replace(wkstr, @"\x16([^\x16]*?)(?:\x16|\Z)", @"\ul $1\ulnone ");
|
||
|
||
//narrator
|
||
//wkstr = Regex.Replace(wkstr, @"\x86([^\x86 ]*?)(?:[\x86]|(?= )|\Z)(.*?)", @"\f{Narrator}$1\f0$2");
|
||
wkstr = Regex.Replace(wkstr, @"\x86([^\x86 ]*?)(?:[\x86]|(?= )|\Z)(.*?)", @"$1$2");
|
||
|
||
// remove hanging indent, vertical tab
|
||
wkstr = Regex.Replace(wkstr, @"\x02", @"\NonSupported Hanging Indent (Hex x02)");
|
||
//wkstr = Regex.Replace(wkstr, @"\x0B", @"\NonSupported Vertical Tab (Hex x0b");
|
||
wkstr = Regex.Replace(wkstr, @"\x0B", @"");
|
||
|
||
// remove some unknown chars for ano & fpl - these plants are not supported
|
||
// as of conversion date.
|
||
wkstr = Regex.Replace(wkstr, @"\x95", @"\NonSupported Unknown (Hex x95)"); //ano2vlv
|
||
wkstr = Regex.Replace(wkstr, @"\x1bf1", @"\NonSupported Unknown (hex 1b f1)"); //fpl
|
||
wkstr = Regex.Replace(wkstr, @"\x1bf0", @"\NonSupported Unknown (hex 1b f0)"); //fpl
|
||
wkstr = Regex.Replace(wkstr, @"\x1bM1", @"\NonSupported Unknown (hex 1b M1)"); //fpl
|
||
wkstr = Regex.Replace(wkstr, @"\x1bM0", @"\NonSupported Unknown (hex 1b M0)"); //fpl
|
||
|
||
// replace \xff with \xA0, i.e. hardspace
|
||
wkstr = Regex.Replace(wkstr, @"\xFF", @"\xA0");
|
||
|
||
// replace x10 & x11 in various ano tabs - not this needs fixed if ANO comes
|
||
// back into the program
|
||
wkstr = wkstr.Replace("\x10", "");
|
||
wkstr = wkstr.Replace("\x11", "");
|
||
|
||
// replace x15 with {RO} for now.
|
||
wkstr = wkstr.Replace("\x15", "{RO}");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.WriteLine("error replacing token (regex) = {0}", ex.Message);
|
||
}
|
||
|
||
return wkstr;
|
||
}
|
||
private float CalculateTabWid(string p)
|
||
{
|
||
if (p == null || p.Length == 0) return 0;
|
||
int tablen = p.Length;
|
||
// don't count if macro....
|
||
int tokb = p.IndexOf("{");
|
||
if (tokb > -1)
|
||
{
|
||
if ((tokb = p.IndexOf("{!")) > -1)
|
||
{
|
||
int toke = p.IndexOf("}", tokb + 2);
|
||
tablen -= (toke - tokb + 1);
|
||
}
|
||
else
|
||
tablen -= 2; // "{}"
|
||
}
|
||
if ((tokb = p.IndexOf("\xA1")) > -1) tablen--; // flags circle macro
|
||
if ((tokb = p.IndexOf("##-3#")) > -1) tablen -= 5; // positioning
|
||
if ((tokb = p.IndexOf("\xAF")) > -1) tablen--; // indent
|
||
if ((tokb = p.IndexOf("\n")) > -1) tablen--; // newline - not sure what to do here
|
||
if ((tokb = p.IndexOf("<22>")) > -1) tablen--; // box step flag
|
||
for (int i = 0; i < p.Length; i++) if (p[i] == 0x08) tablen--; // discount backspaces.
|
||
for (int i = 0; i < p.Length; i++) if (p[i] == 0x16) tablen--; // underline toggle tokens
|
||
if (tablen < 0) tablen = 0;
|
||
return ColToPoints(tablen, _PlantDefaultFontStyle);
|
||
}
|
||
private int NBRSub = 16;
|
||
// STANDARD,AND,OR,EQUIPMENTLIST,EQUIPMENTWBLANK,EXPLICITAND,IMPLICITOR,PARAGRAPH,
|
||
// EQUIPMENTOPT,EQUIPMENTOPTWBLANK,CONTACSEQUENTIAL,CONTACAND,CONTACOR,CONTACPARAGRAPH,TITLEWITHTEXTRIGHT,TITLEWITHTEXTBELOW
|
||
private int[] SubTypeValue ={0,3,4,10,13,18,34,23,29,30,43,44,45,46,41,42};
|
||
private string DoTabs(VE_Font vefont, string po, int i, string p, bool doNumeric)
|
||
{
|
||
// subtypes were defined as the list of types in the comment above from 16bit. These types, if a tab
|
||
// string is not defined, should get a {seq}
|
||
if ((p == null || p == "") && !IsSubType(i)) return p ?? "";
|
||
|
||
string wkstr = p;
|
||
if (p == null)
|
||
return "{seq}";
|
||
//Number Formatting
|
||
// $ - Uppercase Alphabetical (IP2, GEN, CAL2, VLNCAS)
|
||
// & - Roman Numeral - UpperCase
|
||
// @ - Uppercase Alphabetical (AEP, CAL2, GEN, IP2, NSP, RGE, VLNCAS)
|
||
wkstr = Regex.Replace(wkstr, @"\$", @"{ALPHA}");
|
||
wkstr = Regex.Replace(wkstr, @"&", @"{ROMAN}");
|
||
wkstr = Regex.Replace(wkstr, @"@", @"{ALPHA}");
|
||
|
||
// Position offset - do this one here, so don't get background substitution below..
|
||
// ##-3# - Offset of -3 from Parent (FNP)
|
||
wkstr = Regex.Replace(wkstr, @"##-3#", @"{Pos-3}");
|
||
|
||
// Background/Deviation Documents - check for E_PurchaseOptions.(ENHANCEDBACKGROUNDS or ENHANCEDDEVIATIONS)
|
||
// # - Related Caution or Note number
|
||
// ~ - Linked Step Number
|
||
|
||
if ((po.ToUpper().IndexOf("ENHANCEDBACKGROUNDS") > -1) || (po.ToUpper().IndexOf("ENHANCEDDEVIATIONS") > -1))
|
||
{
|
||
wkstr = wkstr.Replace("#", "{LNK C/N Num}");
|
||
wkstr = wkstr.Replace("~", "{LNK Step Num}");
|
||
}
|
||
|
||
// Insert seq & numeric for sequential & any high type if there are not other
|
||
// commands.
|
||
int indx = 0;
|
||
// if sequential or high, add the seq or numeric token
|
||
if (i == 0 && ((indx = wkstr.IndexOf("{")) < 0)) // sequential - put in "{seq}"
|
||
wkstr = wkstr.Insert(0, "{seq}");
|
||
// high, immediate, continuous, lossofac, high5 - put in " {numeric} "
|
||
else if ((i == 1 || i == 2 || i == 8 || i == 17 || i == 40) && ((indx = wkstr.IndexOf("{")) < 0) && doNumeric)
|
||
{
|
||
int indxColon = wkstr.IndexOf(":");
|
||
int indxPercent = wkstr.IndexOf("%");
|
||
if (indxColon > 0)
|
||
wkstr = wkstr.Insert(indxColon, "{numeric}");
|
||
else if (indxPercent > 0)
|
||
wkstr = wkstr.Insert(indxPercent + 1, "{numeric}"); // put numeric after section prefix
|
||
else
|
||
wkstr = wkstr.Insert(1, "{numeric}");
|
||
}
|
||
|
||
//Section Numbers
|
||
// % - Prefix with section number (works string in 16 bit, ie.e For 4.3 the prefix becomes 4.
|
||
// wid that would be stored.
|
||
wkstr = Regex.Replace(wkstr, @"%", @"{Section Prefix}");
|
||
|
||
// Position offset
|
||
// \257 - Indent (CALLOWAY BACKGROUNDS)
|
||
// Newline within a tab (calbck)
|
||
wkstr = wkstr.Replace("\xAF", @"{indent}");
|
||
wkstr = wkstr.Replace("\n", @"{par}");
|
||
|
||
//Macros
|
||
// <!diamond> - draws a diamond around the stepnumber
|
||
// <!diamond1> - A macro
|
||
// <!asterisk> for SHE (Shearon Harris) format. Convert to just a tab with asterisk.
|
||
// <> - ignored
|
||
// \241 - circle macro around step, same as <!circle>
|
||
// Also note, the format files had "<>", these get converted during input in this
|
||
// format converter code.
|
||
if (wkstr.Contains("!asterisk")) wkstr = "{asterisk} {numeric}. ";
|
||
wkstr = Regex.Replace(wkstr, @"{![.*?]}", @"{!$1}");
|
||
wkstr = wkstr.Replace("{}", "");
|
||
wkstr = wkstr.Replace("<22>", "{!C0}");
|
||
if (vefont != null && vefont.HasCircleString2()) wkstr.Insert(0, "{!C0}");
|
||
|
||
// Symbols
|
||
// * - simply an asterisk (do nothing here)
|
||
// - - simlply a dash (do nothing here)
|
||
// \007 - bullet (gets translated
|
||
wkstr = wkstr.Replace("\007", "\x9679");
|
||
wkstr = wkstr.Replace("<22>", @"{Box Step}");
|
||
wkstr = DoReplaceTokens(wkstr);
|
||
wkstr = ConvertText(wkstr);
|
||
return wkstr;
|
||
}
|
||
private bool IsSubType(int indx)
|
||
{
|
||
for (int i = 0; i < NBRSub; i++) if (indx == SubTypeValue[i]) return true;
|
||
return false;
|
||
}
|
||
#endregion
|
||
#region DoEntireInherit
|
||
private bool CompareParentSub(FormatData mainFmt, ref FormatData subFmt)
|
||
{
|
||
// just compare all fields - clear the subformat if equal.
|
||
#region COMPAREACTIVE
|
||
subFmt.FontData = FixInheritedFont(subFmt.FontData, mainFmt.FontData); // Phase 10
|
||
if (mainFmt.PurchaseOptions == subFmt.PurchaseOptions) subFmt.PurchaseOptions = null;
|
||
if (mainFmt.TPL == subFmt.TPL) subFmt.TPL = null;
|
||
if (mainFmt.EditData.EMode == subFmt.EditData.EMode) subFmt.EditData.EMode = null;
|
||
if (mainFmt.EditData.PromptForCautionType != null && mainFmt.EditData.PromptForCautionType == subFmt.EditData.PromptForCautionType) subFmt.EditData.PromptForCautionType = "null";
|
||
if (mainFmt.SectData.StepSectionData.TopRow == subFmt.SectData.StepSectionData.TopRow) subFmt.SectData.StepSectionData.TopRow = NullInt;
|
||
if (mainFmt.PrintData.DoPrnDrvrAdjusts == subFmt.PrintData.DoPrnDrvrAdjusts) subFmt.PrintData.DoPrnDrvrAdjusts = NullInt;
|
||
if (mainFmt.PrintData.DoRevDate != null && mainFmt.PrintData.DoRevDate == subFmt.PrintData.DoRevDate) subFmt.PrintData.DoRevDate = "null";
|
||
if (mainFmt.PrintData.AlternateFoldoutPages != null && mainFmt.PrintData.AlternateFoldoutPages == subFmt.PrintData.AlternateFoldoutPages) subFmt.PrintData.AlternateFoldoutPages = "null";
|
||
if (mainFmt.PrintData.AlternateFloatingFoldout != null && mainFmt.PrintData.AlternateFloatingFoldout == subFmt.PrintData.AlternateFloatingFoldout) subFmt.PrintData.AlternateFloatingFoldout = "null";
|
||
if (mainFmt.PrintData.SectionLevelFoldouts != null && mainFmt.PrintData.SectionLevelFoldouts == subFmt.PrintData.SectionLevelFoldouts) subFmt.PrintData.SectionLevelFoldouts = "null";
|
||
if (mainFmt.PrintData.RevDateWithForwardSlash != null && mainFmt.PrintData.RevDateWithForwardSlash == subFmt.PrintData.RevDateWithForwardSlash) subFmt.PrintData.RevDateWithForwardSlash = "null";
|
||
//if (mainFmt.PrintData.SpecialStepsFoldout != null && mainFmt.PrintData.SpecialStepsFoldout == subFmt.PrintData.SpecialStepsFoldout) subFmt.PrintData.SpecialStepsFoldout = "null";
|
||
if (mainFmt.PrintData.AccessoryDocsInDuplex != null && mainFmt.PrintData.AccessoryDocsInDuplex == subFmt.PrintData.AccessoryDocsInDuplex) subFmt.PrintData.AccessoryDocsInDuplex = "null";
|
||
if (mainFmt.PrintData.AllowDuplex != null && mainFmt.PrintData.AllowDuplex == subFmt.PrintData.AllowDuplex) subFmt.PrintData.AllowDuplex = "null";
|
||
if (mainFmt.PrintData.FoldoutsInDuplex != null && mainFmt.PrintData.FoldoutsInDuplex == subFmt.PrintData.FoldoutsInDuplex) subFmt.PrintData.FoldoutsInDuplex = "null";
|
||
if (mainFmt.PrintData.PagelistChangeIDsWithCommas != null && mainFmt.PrintData.PagelistChangeIDsWithCommas == subFmt.PrintData.PagelistChangeIDsWithCommas) subFmt.PrintData.PagelistChangeIDsWithCommas = "null";
|
||
|
||
// box data...
|
||
for (int i = 0; i < MAXBOXES + 1; i++)
|
||
{
|
||
Box mbox = mainFmt.BoxData[i];
|
||
Box sbox = subFmt.BoxData[i];
|
||
if (mbox.Start == sbox.Start) sbox.Start = NullInt;
|
||
if (mbox.End == sbox.End) sbox.End = NullInt;
|
||
if (mbox.TxtStart == sbox.TxtStart) sbox.TxtStart = NullInt;
|
||
if (mbox.TxtWidth == sbox.TxtWidth) sbox.TxtWidth = NullInt;
|
||
if (mbox.Height == sbox.Height) sbox.Height = NullInt;
|
||
if (mbox.TabPos == sbox.TabPos) sbox.TabPos = NullInt;
|
||
subFmt.BoxData[i].Font = FixInheritedFont(sbox.Font, mbox.Font); // Phase 3
|
||
}
|
||
string subName = subFmt.Name;
|
||
bool inheritShowSectionTitles = true;
|
||
if (fmtName.Contains("NSPIFG.X00")) inheritShowSectionTitles = false;
|
||
StepSectionLayout msctlay = mainFmt.SectData.StepSectionData.StpSectLayData;
|
||
StepSectionLayout ssctlay = subFmt.SectData.StepSectionData.StpSectLayData;
|
||
if (msctlay.TableCenterPos == ssctlay.TableCenterPos) subFmt.SectData.StepSectionData.StpSectLayData.TableCenterPos = null;
|
||
subFmt.SectData.StepSectionData.StpSectLayData.TopOfPage.Font = FixInheritedFont(ssctlay.TopOfPage.Font, msctlay.TopOfPage.Font);// Phase 4
|
||
if (msctlay.TopOfPage.Row == ssctlay.TopOfPage.Row) subFmt.SectData.StepSectionData.StpSectLayData.TopOfPage.Row = NullInt;
|
||
if (msctlay.TopOfPage.Col == ssctlay.TopOfPage.Col) subFmt.SectData.StepSectionData.StpSectLayData.TopOfPage.Col = NullInt;
|
||
|
||
StepSectionPrint msctpr = mainFmt.SectData.StepSectionData.StpSectPrtData;
|
||
StepSectionPrint ssctpr = subFmt.SectData.StepSectionData.StpSectPrtData;
|
||
subFmt.SectData.StepSectionData.StpSectPrtData.ModifiedTextStyle = FixInheritedFont(msctpr.ModifiedTextStyle, msctpr.ModifiedTextStyle); // Phase 11
|
||
if (!subFmt.Name.Contains("IP3"))subFmt.SectData.StepSectionData.StpSectLayData.Separator.Font = FixInheritedFont(ssctlay.Separator.Font, msctlay.Separator.Font); // Phase 5
|
||
if (msctlay.Separator.SeparatorLocation == ssctlay.Separator.SeparatorLocation) subFmt.SectData.StepSectionData.StpSectLayData.Separator.SeparatorLocation = NullInt;
|
||
if (msctlay.LastLineToStartStep == ssctlay.LastLineToStartStep) subFmt.SectData.StepSectionData.StpSectLayData.LastLineToStartStep = NullInt;
|
||
|
||
//for (int i=0; i<10; i++)
|
||
// if (mainFmt.SectData.StepSectionData.TextTypeValue[i] == subFmt.SectData.StepSectionData.TextTypeValue[i]) mainFmt.SectData.StepSectionData.TextTypeValue[i] = 0;
|
||
|
||
if (msctlay.LineDrawingOption == ssctlay.LineDrawingOption) subFmt.SectData.StepSectionData.StpSectLayData.LineDrawingOption = NullInt;
|
||
if (msctlay.ColS == ssctlay.ColS) subFmt.SectData.StepSectionData.StpSectLayData.ColS = NullInt;
|
||
|
||
StepSectionEdit mscted = mainFmt.SectData.StepSectionData.StpSectEditData;
|
||
StepSectionEdit sscted = subFmt.SectData.StepSectionData.StpSectEditData;
|
||
if (mscted.ColSScreenAdj == sscted.ColSScreenAdj) subFmt.SectData.StepSectionData.StpSectEditData.ColSScreenAdj = NullInt;
|
||
if (mscted.ScrnAdjRNOText == sscted.ScrnAdjRNOText) subFmt.SectData.StepSectionData.StpSectEditData.ScrnAdjRNOText = NullInt;
|
||
|
||
if (msctlay.ColT == ssctlay.ColT) subFmt.SectData.StepSectionData.StpSectLayData.ColT = NullInt;
|
||
if (msctlay.ColAbs == ssctlay.ColAbs) subFmt.SectData.StepSectionData.StpSectLayData.ColAbs = NullInt;
|
||
if (msctlay.WidT == ssctlay.WidT) subFmt.SectData.StepSectionData.StpSectLayData.WidT = NullInt;
|
||
if (msctlay.PMode == ssctlay.PMode) subFmt.SectData.StepSectionData.StpSectLayData.PMode = NullInt;
|
||
if (msctlay.MaxRNO == ssctlay.MaxRNO) subFmt.SectData.StepSectionData.StpSectLayData.MaxRNO = NullInt;
|
||
if (msctlay.MaxRNOTable == ssctlay.MaxRNOTable) subFmt.SectData.StepSectionData.StpSectLayData.MaxRNOTable = null;
|
||
if (msctlay.ColRTable == ssctlay.ColRTable) subFmt.SectData.StepSectionData.StpSectLayData.ColRTable = null;
|
||
if (msctlay.WidSTablePrint == ssctlay.WidSTablePrint) subFmt.SectData.StepSectionData.StpSectLayData.WidSTablePrint = null;
|
||
if (mscted.ColRScreen == sscted.ColRScreen) subFmt.SectData.StepSectionData.StpSectEditData.ColRScreen = null;
|
||
if (msctlay.AdjRNOCol == ssctlay.AdjRNOCol) subFmt.SectData.StepSectionData.StpSectLayData.AdjRNOCol = NullInt;
|
||
|
||
// change bar
|
||
ChangeBar mcb = mainFmt.ProcData.ChangeBarData;
|
||
ChangeBar scb = subFmt.ProcData.ChangeBarData;
|
||
if (mcb.ChangeBarMessage == scb.ChangeBarMessage) subFmt.ProcData.ChangeBarData.ChangeBarMessage = null;
|
||
if (mcb.FixedChangeColumn == scb.FixedChangeColumn) subFmt.ProcData.ChangeBarData.FixedChangeColumn = NullInt;
|
||
if (mcb.FixedAERChangeColumn == scb.FixedAERChangeColumn) subFmt.ProcData.ChangeBarData.FixedAERChangeColumn = NullInt;
|
||
if (mcb.ChangeSummaryStyle == scb.ChangeSummaryStyle) subFmt.ProcData.ChangeBarData.ChangeSummaryStyle = NullInt;
|
||
if (mcb.ChangeBarStyle == scb.ChangeBarStyle) subFmt.ProcData.ChangeBarData.ChangeBarStyle = NullInt;
|
||
if (mcb.CondensedChangeBar != null && mcb.CondensedChangeBar == scb.CondensedChangeBar) subFmt.ProcData.ChangeBarData.CondensedChangeBar = "null";
|
||
if (mcb.AbsoluteFixedChangeColumn != null && mcb.AbsoluteFixedChangeColumn == scb.AbsoluteFixedChangeColumn) subFmt.ProcData.ChangeBarData.AbsoluteFixedChangeColumn = "null";
|
||
if (mcb.ContinuousChangeBars != null && mcb.ContinuousChangeBars == scb.ContinuousChangeBars) subFmt.ProcData.ChangeBarData.ContinuousChangeBars = "null";
|
||
if (mcb.ChgBarMessageFromEdit != null && mcb.ChgBarMessageFromEdit == scb.ChgBarMessageFromEdit) subFmt.ProcData.ChangeBarData.ChgBarMessageFromEdit = "null";
|
||
if (mcb.MultipleChangeIds != null && mcb.MultipleChangeIds == scb.MultipleChangeIds) subFmt.ProcData.ChangeBarData.MultipleChangeIds = "null";
|
||
if (mcb.ChangeBarToRNOSep != null && mcb.ChangeBarToRNOSep == scb.ChangeBarToRNOSep) subFmt.ProcData.ChangeBarData.ChangeBarToRNOSep = "null";
|
||
if (mcb.ChangeBarsOnLinkedText != null && mcb.ChangeBarsOnLinkedText == scb.ChangeBarsOnLinkedText) subFmt.ProcData.ChangeBarData.ChangeBarsOnLinkedText = "null";
|
||
|
||
if (mainFmt.ProcData.TitleLength == subFmt.ProcData.TitleLength) subFmt.ProcData.TitleLength = NullInt;
|
||
if (mainFmt.ProcData.CoverTitleLength == subFmt.ProcData.CoverTitleLength) subFmt.ProcData.CoverTitleLength = NullInt;
|
||
if (mainFmt.ProcData.ProcForeColor == subFmt.ProcData.ProcForeColor) subFmt.ProcData.ProcForeColor = null;
|
||
if (mainFmt.ProcData.ProcBackColor == subFmt.ProcData.ProcBackColor) subFmt.ProcData.ProcBackColor = null;
|
||
if (mainFmt.ProcData.CapitalizeTitle != null && mainFmt.ProcData.CapitalizeTitle == subFmt.ProcData.CapitalizeTitle) subFmt.ProcData.CapitalizeTitle = "null";
|
||
if (mainFmt.ProcData.ChangeStyleForEverySection != null && mainFmt.ProcData.ChangeStyleForEverySection == subFmt.ProcData.ChangeStyleForEverySection) subFmt.ProcData.ChangeStyleForEverySection = "null";
|
||
if (mainFmt.ProcData.PrintNoTitle != null && mainFmt.ProcData.PrintNoTitle == subFmt.ProcData.PrintNoTitle) subFmt.ProcData.PrintNoTitle = "null";
|
||
if (mainFmt.ProcData.CountFoldoutPages != null && mainFmt.ProcData.CountFoldoutPages == subFmt.ProcData.CountFoldoutPages) subFmt.ProcData.CountFoldoutPages = "null";
|
||
|
||
// checkoff
|
||
CheckOffData mco = mainFmt.ProcData.CheckOffData;
|
||
CheckOffData sco = subFmt.ProcData.CheckOffData;
|
||
for (int i = 0; i < MAXCHKHEADINGS; i++)
|
||
{
|
||
if (mco.CheckOffHeaderList[i].CheckOffHeading == sco.CheckOffHeaderList[i].CheckOffHeading) subFmt.ProcData.CheckOffData.CheckOffHeaderList[i].CheckOffHeading = null;
|
||
sco.CheckOffHeaderList[i].Font = FixInheritedFont(sco.CheckOffHeaderList[i].Font, mco.CheckOffHeaderList[i].Font); // Phase 6
|
||
}
|
||
if (mco.Menu == sco.Menu) subFmt.ProcData.CheckOffData.Menu = "null";
|
||
if (mco.AllowSectEdit == sco.AllowSectEdit) subFmt.ProcData.CheckOffData.AllowSectEdit = "null";
|
||
if (mco.AllowStepEdit == sco.AllowStepEdit) subFmt.ProcData.CheckOffData.AllowStepEdit = "null";
|
||
if (mco.UseCheckOffsIn == sco.UseCheckOffsIn) subFmt.ProcData.CheckOffData.UseCheckOffsIn = NullInt;
|
||
if (mco.XLocation == sco.XLocation) subFmt.ProcData.CheckOffData.XLocation = NullInt;
|
||
if (mco.CheckOffAdjustment == sco.CheckOffAdjustment) subFmt.ProcData.CheckOffData.CheckOffAdjustment = NullInt;
|
||
if (mco.DropCheckOff != null && mco.DropCheckOff == sco.DropCheckOff) subFmt.ProcData.CheckOffData.DropCheckOff = "null";
|
||
if (mco.CheckOffOnHLSOnly != null && mco.CheckOffOnHLSOnly == sco.CheckOffOnHLSOnly) subFmt.ProcData.CheckOffData.CheckOffOnHLSOnly = "null";
|
||
if (mco.SkipSpaces != null && mco.SkipSpaces == sco.SkipSpaces) subFmt.ProcData.CheckOffData.SkipSpaces = "null";
|
||
|
||
if (mco.LayoutList != null && sco.LayoutList != null)
|
||
{
|
||
int mLayoutCount = mco.LayoutList.Length;
|
||
int sLayoutCount = sco.LayoutList.Length;
|
||
if (sLayoutCount == mLayoutCount)
|
||
{
|
||
for (int i = 0; i < sLayoutCount; i++)
|
||
{
|
||
if (mco.LayoutList[i].RnoLevel == sco.LayoutList[i].RnoLevel) subFmt.ProcData.CheckOffData.LayoutList[i].RnoLevel = "null";
|
||
if (mco.LayoutList[i].Column == sco.LayoutList[i].Column) subFmt.ProcData.CheckOffData.LayoutList[i].Column = NullInt;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (msctlay.EndMessagePos == ssctlay.EndMessagePos) subFmt.SectData.StepSectionData.StpSectLayData.EndMessagePos = NullInt;
|
||
|
||
StepSection msctstp = mainFmt.SectData.StepSectionData;
|
||
StepSection ssctstp = subFmt.SectData.StepSectionData;
|
||
if (msctstp.IndentToken == ssctstp.IndentToken) subFmt.SectData.StepSectionData.IndentToken = NullByte;
|
||
if (msctpr.ImmStepHdrCol == ssctpr.ImmStepHdrCol) subFmt.SectData.StepSectionData.StpSectPrtData.ImmStepHdrCol = NullInt;
|
||
subFmt.SectData.StepSectionData.StpSectPrtData.ImmStepHdrStyle = FixInheritedFont(ssctpr.ImmStepHdrStyle, msctpr.ImmStepHdrStyle);
|
||
if (msctstp.WolfCreekBackgroundFormat != null && msctstp.WolfCreekBackgroundFormat == ssctstp.WolfCreekBackgroundFormat) subFmt.SectData.StepSectionData.WolfCreekBackgroundFormat = "null";
|
||
if (msctstp.WolfcreekCKLFormat != null && msctstp.WolfcreekCKLFormat == ssctstp.WolfcreekCKLFormat) subFmt.SectData.StepSectionData.WolfcreekCKLFormat = "null";
|
||
if (msctstp.WolfcreekCKLBackgndFormat != null && msctstp.WolfcreekCKLBackgndFormat == ssctstp.WolfcreekCKLBackgndFormat) subFmt.SectData.StepSectionData.WolfcreekCKLBackgndFormat = "null";
|
||
if (msctstp.FortranFormatNumbers != null && msctstp.FortranFormatNumbers == ssctstp.FortranFormatNumbers) subFmt.SectData.StepSectionData.FortranFormatNumbers = "null";
|
||
if (msctstp.UseTopContinueMessageAtEnd != null && msctstp.UseTopContinueMessageAtEnd == ssctstp.UseTopContinueMessageAtEnd) subFmt.SectData.StepSectionData.UseTopContinueMessageAtEnd = "null";
|
||
if (msctstp.FloatingContinueMessage != null && msctstp.FloatingContinueMessage == ssctstp.FloatingContinueMessage) subFmt.SectData.StepSectionData.FloatingContinueMessage = "null";
|
||
if (msctstp.WrapSameAsEdit != null && msctstp.WrapSameAsEdit == ssctstp.WrapSameAsEdit) subFmt.SectData.StepSectionData.WrapSameAsEdit = "null";
|
||
if (msctstp.ContinueSectionHeader != null && msctstp.ContinueSectionHeader == ssctstp.ContinueSectionHeader) subFmt.SectData.StepSectionData.ContinueSectionHeader = "null";
|
||
if (msctstp.CompressHPSub != null && msctstp.CompressHPSub == ssctstp.CompressHPSub) subFmt.SectData.StepSectionData.CompressHPSub = "null";
|
||
if (msctstp.CompressHPSuper != null && msctstp.CompressHPSuper == ssctstp.CompressHPSuper) subFmt.SectData.StepSectionData.CompressHPSuper = "null";
|
||
//if (msctstp.UndSpecialStepsFoldout != null && msctstp.UndSpecialStepsFoldout == ssctstp.UndSpecialStepsFoldout) subFmt.SectData.StepSectionData.UndSpecialStepsFoldout = "null";
|
||
if (msctstp.UnderlineAllMetaTitles != null && msctstp.UnderlineAllMetaTitles == ssctstp.UnderlineAllMetaTitles) subFmt.SectData.StepSectionData.UnderlineAllMetaTitles = "null";
|
||
if (msctstp.BoldOnlySectionZero != null && msctstp.BoldOnlySectionZero == ssctstp.BoldOnlySectionZero) subFmt.SectData.StepSectionData.BoldOnlySectionZero = "null";
|
||
if (msctstp.ImperfectStructure != null && msctstp.ImperfectStructure == ssctstp.ImperfectStructure) subFmt.SectData.StepSectionData.ImperfectStructure = "null";
|
||
if (msctstp.ImperfectSubstep != null && msctstp.ImperfectSubstep == ssctstp.ImperfectSubstep) subFmt.SectData.StepSectionData.ImperfectSubstep = "null";
|
||
if (msctstp.ImperfectStructurePlus4 != null && msctstp.ImperfectStructurePlus4 == ssctstp.ImperfectStructurePlus4) subFmt.SectData.StepSectionData.ImperfectStructurePlus4 = "null";
|
||
if (msctstp.CountAllSubLevels != null && msctstp.CountAllSubLevels == ssctstp.CountAllSubLevels) subFmt.SectData.StepSectionData.CountAllSubLevels = "null";
|
||
if (msctstp.UseMultiLineSectionTitle != null && msctstp.UseMultiLineSectionTitle == ssctstp.UseMultiLineSectionTitle) subFmt.SectData.StepSectionData.UseMultiLineSectionTitle = "null";
|
||
|
||
if (msctlay.RNOWidthAlt == ssctlay.RNOWidthAlt) subFmt.SectData.StepSectionData.StpSectLayData.RNOWidthAlt = null;
|
||
if (msctlay.HLSWidthOVRD == ssctlay.HLSWidthOVRD) subFmt.SectData.StepSectionData.StpSectLayData.HLSWidthOVRD = NullInt;
|
||
if (msctpr.SecColHdrforActPMode == ssctpr.SecColHdrforActPMode) subFmt.SectData.StepSectionData.StpSectPrtData.SecColHdrforActPMode = NullInt;
|
||
|
||
SectionNum msctn = mainFmt.SectData.SectionNumber;
|
||
SectionNum ssctn = subFmt.SectData.SectionNumber;
|
||
SectionHead mscth = mainFmt.SectData.SectionHeader;
|
||
SectionHead sscth = subFmt.SectData.SectionHeader;
|
||
subFmt.SectData.SectionNumber.Font = FixInheritedFont(ssctn.Font, msctn.Font); // Phase 7
|
||
if (msctn.Pos == ssctn.Pos) subFmt.SectData.SectionNumber.Pos = NullInt;
|
||
if (msctn.Just == ssctn.Just) subFmt.SectData.SectionNumber.Just = null;
|
||
subFmt.SectData.SectionHeader.Font = FixInheritedFont(sscth.Font, mscth.Font); // Phase 8
|
||
if (mscth.Pos == sscth.Pos) subFmt.SectData.SectionHeader.Pos = NullInt;
|
||
if (mscth.Just == sscth.Just) subFmt.SectData.SectionHeader.Just = null;
|
||
|
||
if (mainFmt.SectData.SectionTitleLength == subFmt.SectData.SectionTitleLength) subFmt.SectData.SectionTitleLength = NullInt;
|
||
if (mainFmt.SectData.SectForeColor == subFmt.SectData.SectForeColor) subFmt.SectData.SectForeColor = null;
|
||
if (mainFmt.SectData.SectBackColor == subFmt.SectData.SectBackColor) subFmt.SectData.SectBackColor = null;
|
||
if (mainFmt.SectData.MetaSectEndMessage != null && mainFmt.SectData.MetaSectEndMessage == subFmt.SectData.MetaSectEndMessage) subFmt.SectData.MetaSectEndMessage = "null";
|
||
if (mainFmt.SectData.ReadOnlyTypeInContMsg != null && mainFmt.SectData.ReadOnlyTypeInContMsg == subFmt.SectData.ReadOnlyTypeInContMsg) subFmt.SectData.ReadOnlyTypeInContMsg = "null";
|
||
if (mainFmt.SectData.ReplaceWordsInROs != null && mainFmt.SectData.ReplaceWordsInROs == subFmt.SectData.ReplaceWordsInROs) subFmt.SectData.ReplaceWordsInROs = "null";
|
||
if (mainFmt.SectData.UseMetaSections != null && mainFmt.SectData.UseMetaSections == subFmt.SectData.UseMetaSections) subFmt.SectData.UseMetaSections = "null";
|
||
if (mainFmt.SectData.NonEditableSteps != null && mainFmt.SectData.NonEditableSteps == subFmt.SectData.NonEditableSteps) subFmt.SectData.NonEditableSteps = "null";
|
||
if (mainFmt.SectData.SearchAllReplaceWords != null && mainFmt.SectData.SearchAllReplaceWords == subFmt.SectData.SearchAllReplaceWords) subFmt.SectData.SearchAllReplaceWords = "null";
|
||
if (mainFmt.SectData.SecTitleContinue != null && mainFmt.SectData.SecTitleContinue == subFmt.SectData.SecTitleContinue) subFmt.SectData.SecTitleContinue = "null";
|
||
if (mainFmt.SectData.ConvertCaretToDelta != null && mainFmt.SectData.ConvertCaretToDelta == subFmt.SectData.ConvertCaretToDelta) subFmt.SectData.ConvertCaretToDelta = "null";
|
||
if (mainFmt.SectData.TurnOffReplaceWords != null && mainFmt.SectData.TurnOffReplaceWords == subFmt.SectData.TurnOffReplaceWords) subFmt.SectData.TurnOffReplaceWords = "null";
|
||
|
||
if (msctlay.SubPaginationWght == ssctlay.SubPaginationWght) subFmt.SectData.StepSectionData.StpSectLayData.SubPaginationWght = NullInt;
|
||
if (msctlay.TextTitleAdjustment == ssctlay.TextTitleAdjustment) subFmt.SectData.StepSectionData.StpSectLayData.TextTitleAdjustment = NullInt;
|
||
|
||
AccSection maccsec = mainFmt.SectData.AccSectionData;
|
||
AccSection saccsec = subFmt.SectData.AccSectionData;
|
||
|
||
if (maccsec.TableOfContentsData.TofCSecNumPos == saccsec.TableOfContentsData.TofCSecNumPos) subFmt.SectData.AccSectionData.TableOfContentsData.TofCSecNumPos = NullInt;
|
||
if (maccsec.TableOfContentsData.TofCSecTitlePos == saccsec.TableOfContentsData.TofCSecTitlePos) subFmt.SectData.AccSectionData.TableOfContentsData.TofCSecTitlePos = NullInt;
|
||
if (maccsec.TableOfContentsData.TofCSecTitleLen == saccsec.TableOfContentsData.TofCSecTitleLen) subFmt.SectData.AccSectionData.TableOfContentsData.TofCSecTitleLen = NullByte;
|
||
if (maccsec.TableOfContentsData.TofCPageNumPos == saccsec.TableOfContentsData.TofCPageNumPos) subFmt.SectData.AccSectionData.TableOfContentsData.TofCPageNumPos = NullInt;
|
||
if (maccsec.TableOfContentsData.TofCSpaceChar == saccsec.TableOfContentsData.TofCSpaceChar) subFmt.SectData.AccSectionData.TableOfContentsData.TofCSpaceChar = null;
|
||
if (maccsec.TableOfContentsData.TofCLineSpacing == saccsec.TableOfContentsData.TofCLineSpacing) subFmt.SectData.AccSectionData.TableOfContentsData.TofCLineSpacing = NullByte;
|
||
subFmt.SectData.AccSectionData.TableOfContentsData.Font = FixInheritedFont(saccsec.TableOfContentsData.Font, maccsec.TableOfContentsData.Font); // Phase 9
|
||
subFmt.SectData.StepSectionData.StpSectLayData.VertStyle = FixInheritedFont(ssctlay.VertStyle, msctlay.VertStyle);// Phase 13
|
||
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
if (mainFmt.SectData.MetaSectionData[i].SecNumPositionAdj == subFmt.SectData.MetaSectionData[i].SecNumPositionAdj) subFmt.SectData.MetaSectionData[i].SecNumPositionAdj = NullInt;
|
||
if (mainFmt.SectData.MetaSectionData[i].SecTitlePositionAdj == subFmt.SectData.MetaSectionData[i].SecTitlePositionAdj) subFmt.SectData.MetaSectionData[i].SecTitlePositionAdj = NullInt;
|
||
if (mainFmt.SectData.MetaSectionData[i].ColSByLevel == subFmt.SectData.MetaSectionData[i].ColSByLevel) subFmt.SectData.MetaSectionData[i].ColSByLevel = NullInt;
|
||
if (mainFmt.SectData.MetaSectionData[i].TofCPositionAdj == subFmt.SectData.MetaSectionData[i].TofCPositionAdj) subFmt.SectData.MetaSectionData[i].TofCPositionAdj = NullInt;
|
||
if (mainFmt.SectData.MetaSectionData[i].WidSAdjByLevel == subFmt.SectData.MetaSectionData[i].WidSAdjByLevel) subFmt.SectData.MetaSectionData[i].WidSAdjByLevel = NullInt;
|
||
}
|
||
|
||
if (msctstp.NumberOfHighLevelSteps == ssctstp.NumberOfHighLevelSteps) subFmt.SectData.StepSectionData.NumberOfHighLevelSteps = NullInt;
|
||
|
||
for (int i = 0; i < MAXBOXES + 1; i++)
|
||
{
|
||
if (mainFmt.BoxData[i].TxtRowAdj == subFmt.BoxData[i].TxtRowAdj) subFmt.BoxData[i].TxtRowAdj = (sbyte)NullByte;
|
||
if (mainFmt.BoxData[i].BXURC == subFmt.BoxData[i].BXURC) subFmt.BoxData[i].BXURC = null;
|
||
if (mainFmt.BoxData[i].BXHorz == subFmt.BoxData[i].BXHorz) subFmt.BoxData[i].BXHorz = null;
|
||
if (mainFmt.BoxData[i].BXULC == subFmt.BoxData[i].BXULC) subFmt.BoxData[i].BXULC = NullString;
|
||
if (mainFmt.BoxData[i].BXVert == subFmt.BoxData[i].BXVert) subFmt.BoxData[i].BXVert = null;
|
||
if (mainFmt.BoxData[i].BXMLS == subFmt.BoxData[i].BXMLS) subFmt.BoxData[i].BXMLS = null;
|
||
if (mainFmt.BoxData[i].BXMRS == subFmt.BoxData[i].BXMRS) subFmt.BoxData[i].BXMRS = null;
|
||
if (mainFmt.BoxData[i].BXLRC == subFmt.BoxData[i].BXLRC) subFmt.BoxData[i].BXLRC = null;
|
||
if (mainFmt.BoxData[i].BXLLC == subFmt.BoxData[i].BXLLC) subFmt.BoxData[i].BXLLC = null;
|
||
if (mainFmt.BoxData[i].BXMID == subFmt.BoxData[i].BXMID) subFmt.BoxData[i].BXMID = null;
|
||
if (mainFmt.BoxData[i].BXLHorz == subFmt.BoxData[i].BXLHorz) subFmt.BoxData[i].BXLHorz = null;
|
||
if (mainFmt.BoxData[i].BXUMID == subFmt.BoxData[i].BXUMID) subFmt.BoxData[i].BXUMID = null;
|
||
if (mainFmt.BoxData[i].BXLMID == subFmt.BoxData[i].BXLMID) subFmt.BoxData[i].BXLMID = null;
|
||
|
||
}
|
||
|
||
if (msctstp.NumberOfSubStepTypes == ssctstp.NumberOfSubStepTypes) subFmt.SectData.StepSectionData.NumberOfSubStepTypes = NullInt;
|
||
|
||
if (mainFmt.SectData.AccSectionData.AutoContActSumSection == subFmt.SectData.AccSectionData.AutoContActSumSection) subFmt.SectData.AccSectionData.AutoContActSumSection = NullInt;
|
||
|
||
if (msctstp.IdentB == ssctstp.IdentB) subFmt.SectData.StepSectionData.IdentB = null;
|
||
|
||
//for (int i = 0; i < MAXSEQ; i++)
|
||
// if (msctstp.SeqTab[i] == ssctstp.SeqTab[i]) subFmt.SectData.StepSectionData.SeqTab[i]=null;
|
||
|
||
// don't clear replace words. these would have to match exactly, because order matters when processing replace words & integrating the two lists when they are to be
|
||
// used is too complicated.
|
||
//for (int i = 0; i < MAXREPLACE; i++)
|
||
//{
|
||
// if (mainFmt.SectData.ReplaceStrData[i].ReplaceWord == subFmt.SectData.ReplaceStrData[i].ReplaceWord) subFmt.SectData.ReplaceStrData[i].ReplaceWord = null;
|
||
// if (mainFmt.SectData.ReplaceStrData[i].ReplaceWith == subFmt.SectData.ReplaceStrData[i].ReplaceWith) subFmt.SectData.ReplaceStrData[i].ReplaceWith = null;
|
||
// // clear flags only if both replaceword & replacewith ended up getting cleared.
|
||
// if ((subFmt.SectData.ReplaceStrData[i].ReplaceWord == null) && (subFmt.SectData.ReplaceStrData[i].ReplaceWith == null)) subFmt.SectData.ReplaceStrData[i].Flag = null;
|
||
//}
|
||
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
if (mainFmt.PrintData.ProcDescrList[i].MatchProcNumber == subFmt.PrintData.ProcDescrList[i].MatchProcNumber) subFmt.PrintData.ProcDescrList[i].MatchProcNumber = null;
|
||
if (mainFmt.PrintData.ProcDescrList[i].ProcDescr1 == subFmt.PrintData.ProcDescrList[i].ProcDescr1) subFmt.PrintData.ProcDescrList[i].ProcDescr1 = null;
|
||
if (mainFmt.PrintData.ProcDescrList[i].ProcDescr2 == subFmt.PrintData.ProcDescrList[i].ProcDescr2) subFmt.PrintData.ProcDescrList[i].ProcDescr2 = null;
|
||
}
|
||
for (int i = 0; i < 5; i++)
|
||
if (mainFmt.PrintData.VersionIdText[i] == subFmt.PrintData.VersionIdText[i]) subFmt.PrintData.VersionIdText[i] = null;
|
||
|
||
if (mainFmt.TransData.DelimiterForTransitionTitle == subFmt.TransData.DelimiterForTransitionTitle) subFmt.TransData.DelimiterForTransitionTitle = null;
|
||
if (mainFmt.TransData.StepSubstepDelimeter == subFmt.TransData.StepSubstepDelimeter) subFmt.TransData.StepSubstepDelimeter = null;
|
||
if (mainFmt.TransData.ThroughString == subFmt.TransData.ThroughString) subFmt.TransData.ThroughString = null;
|
||
if (mainFmt.TransData.SpecifiedSubstepsOnly != null && mainFmt.TransData.SpecifiedSubstepsOnly == subFmt.TransData.SpecifiedSubstepsOnly) subFmt.TransData.SpecifiedSubstepsOnly = "null";
|
||
if (mainFmt.TransData.CapsTransitions != null && mainFmt.TransData.CapsTransitions == subFmt.TransData.CapsTransitions) subFmt.TransData.CapsTransitions = "null";
|
||
if (mainFmt.TransData.CapTranStep != null && mainFmt.TransData.CapTranStep == subFmt.TransData.CapTranStep) subFmt.TransData.CapTranStep = "null";
|
||
if (mainFmt.TransData.TStepNoFlag != null && mainFmt.TransData.TStepNoFlag == subFmt.TransData.TStepNoFlag) subFmt.TransData.TStepNoFlag = "null";
|
||
if (mainFmt.TransData.LowerCaseTranNumber != null && mainFmt.TransData.LowerCaseTranNumber == subFmt.TransData.LowerCaseTranNumber) subFmt.TransData.LowerCaseTranNumber = "null";
|
||
if (mainFmt.TransData.UpcaseTranAnd != null && mainFmt.TransData.UpcaseTranAnd == subFmt.TransData.UpcaseTranAnd) subFmt.TransData.UpcaseTranAnd = "null";
|
||
if (mainFmt.TransData.SuppressAndInTran != null && mainFmt.TransData.SuppressAndInTran == subFmt.TransData.SuppressAndInTran) subFmt.TransData.SuppressAndInTran = "null";
|
||
if (mainFmt.TransData.Cap1stCharTrans != null && mainFmt.TransData.Cap1stCharTrans == subFmt.TransData.Cap1stCharTrans) subFmt.TransData.Cap1stCharTrans = "null";
|
||
if (mainFmt.TransData.UseTransitionModifier != null && mainFmt.TransData.UseTransitionModifier == subFmt.TransData.UseTransitionModifier) subFmt.TransData.UseTransitionModifier = "null";
|
||
if (mainFmt.TransData.UseSecTitles != null && mainFmt.TransData.UseSecTitles == subFmt.TransData.UseSecTitles) subFmt.TransData.UseSecTitles = "null";
|
||
if (mainFmt.TransData.HardSpTranProcNumb != null && mainFmt.TransData.HardSpTranProcNumb == subFmt.TransData.HardSpTranProcNumb) subFmt.TransData.HardSpTranProcNumb = "null";
|
||
if (mainFmt.TransData.XchngTranSpForHard != null && mainFmt.TransData.XchngTranSpForHard == subFmt.TransData.XchngTranSpForHard) subFmt.TransData.XchngTranSpForHard = "null";
|
||
if (mainFmt.TransData.AbsoluteTransitionUpdate != null && mainFmt.TransData.AbsoluteTransitionUpdate == subFmt.TransData.AbsoluteTransitionUpdate) subFmt.TransData.AbsoluteTransitionUpdate = "null";
|
||
if (mainFmt.TransData.LowerCaseStepInTran != null && mainFmt.TransData.LowerCaseStepInTran == subFmt.TransData.LowerCaseStepInTran) subFmt.TransData.LowerCaseStepInTran = "null";
|
||
if (mainFmt.TransData.DoSectionTransitions != null && mainFmt.TransData.DoSectionTransitions == subFmt.TransData.DoSectionTransitions) subFmt.TransData.DoSectionTransitions = "null";
|
||
|
||
if (mainFmt.ROData.AllUnits != null && mainFmt.ROData.AllUnits == subFmt.ROData.AllUnits) subFmt.ROData.AllUnits = "null";
|
||
if (mainFmt.ROData.UpRoAftrDash != null && mainFmt.ROData.UpRoAftrDash == subFmt.ROData.UpRoAftrDash) subFmt.ROData.UpRoAftrDash = "null";
|
||
if (mainFmt.ROData.UpcaseAllRoUnits != null && mainFmt.ROData.UpcaseAllRoUnits == subFmt.ROData.UpcaseAllRoUnits) subFmt.ROData.UpcaseAllRoUnits = "null";
|
||
if (mainFmt.ROData.CapHighRo != null && mainFmt.ROData.CapHighRo == subFmt.ROData.CapHighRo) subFmt.ROData.CapHighRo = "null";
|
||
if (mainFmt.ROData.CapRoIfLastLower != null && mainFmt.ROData.CapRoIfLastLower == subFmt.ROData.CapRoIfLastLower) subFmt.ROData.CapRoIfLastLower = "null";
|
||
if (mainFmt.ROData.UpRoIfPrevUpper != null && mainFmt.ROData.UpRoIfPrevUpper == subFmt.ROData.UpRoIfPrevUpper) subFmt.ROData.UpRoIfPrevUpper = "null";
|
||
if (mainFmt.ROData.UnderlineRo != null && mainFmt.ROData.UnderlineRo == subFmt.ROData.UnderlineRo) subFmt.ROData.UnderlineRo = "null";
|
||
if (mainFmt.ROData.CapFirstLetterInHighRO != null && mainFmt.ROData.CapFirstLetterInHighRO == subFmt.ROData.CapFirstLetterInHighRO) subFmt.ROData.CapFirstLetterInHighRO = "null";
|
||
|
||
if (mainFmt.ProcData.ProcedureSuffixFlags == subFmt.ProcData.ProcedureSuffixFlags) subFmt.ProcData.ProcedureSuffixFlags = null;
|
||
for (int i = 0; i < 10; i++)
|
||
if (mainFmt.ProcData.ProcedureSuffix[i] == subFmt.ProcData.ProcedureSuffix[i]) subFmt.ProcData.ProcedureSuffix[i] = null;
|
||
|
||
if (mainFmt.PrintData.TopOfPageThing == subFmt.PrintData.TopOfPageThing) subFmt.PrintData.TopOfPageThing = null;
|
||
|
||
//for (int i=0; i<10; i++)
|
||
// if (msctstp.TextType[i] == ssctstp.TextType[i]) subFmt.SectData.StepSectionData.TextType[i]=null;
|
||
|
||
//for (int i=0; i<MAXSEQ; i++)
|
||
//{
|
||
// if (msctstp.PreSeqTabEdit[i] == ssctstp.PreSeqTabEdit[i]) subFmt.SectData.StepSectionData.PreSeqTabEdit[i]=null;
|
||
// if (msctstp.PreSeqTabPrint[i] == ssctstp.PreSeqTabPrint[i]) subFmt.SectData.StepSectionData.PreSeqTabPrint[i]=null;
|
||
// //if (msctstp.PostSeqTabEdit[i] == ssctstp.PostSeqTabEdit[i]) subFmt.SectData.StepSectionData.PostSeqTabEdit[i]=null;
|
||
// //if (msctstp.PostSeqTabPrint[i] == ssctstp.PostSeqTabPrint[i]) subFmt.SectData.StepSectionData.PostSeqTabPrint[i]=null;
|
||
//}
|
||
|
||
if (msctpr.RNOSepString == ssctpr.RNOSepString) subFmt.SectData.StepSectionData.StpSectPrtData.RNOSepString = null;
|
||
if (msctpr.RNOSepLineLength == ssctpr.RNOSepLineLength) subFmt.SectData.StepSectionData.StpSectPrtData.RNOSepLineLength = 0;
|
||
|
||
for (int i = 0; i < 10; i++)
|
||
if (msctstp.UnderlineTerminate[i] == ssctstp.UnderlineTerminate[i]) subFmt.SectData.StepSectionData.UnderlineTerminate[i] = null;
|
||
|
||
for (int i = 0; i < 2; i++)
|
||
if (msctpr.ImmStepHdr[i] == ssctpr.ImmStepHdr[i]) subFmt.SectData.StepSectionData.StpSectPrtData.ImmStepHdr[i] = null;
|
||
|
||
if (mcb.SpecialChangeBar == scb.SpecialChangeBar) subFmt.ProcData.ChangeBarData.SpecialChangeBar = null;
|
||
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (msctstp.ObserveNCString1 != null && ssctstp.ObserveNCString1 != null && msctstp.ObserveNCString1[i] == ssctstp.ObserveNCString1[i]) subFmt.SectData.StepSectionData.ObserveNCString1 = null;
|
||
if (msctstp.ObserveNCString2 != null && ssctstp.ObserveNCString1 != null && msctstp.ObserveNCString2[i] == ssctstp.ObserveNCString2[i]) subFmt.SectData.StepSectionData.ObserveNCString2 = null;
|
||
}
|
||
|
||
for (int i = 0; i < MAXCHECKOFFS; i++)
|
||
{
|
||
if (mco.CheckOffList[i].UIMark == sco.CheckOffList[i].UIMark) subFmt.ProcData.CheckOffData.CheckOffList[i].UIMark = NullByte;
|
||
if (mco.CheckOffList[i].MenuItem == sco.CheckOffList[i].MenuItem) subFmt.ProcData.CheckOffData.CheckOffList[i].MenuItem = null;
|
||
if (mco.CheckOffList[i].ExcludeInSectMenu == sco.CheckOffList[i].ExcludeInSectMenu) subFmt.ProcData.CheckOffData.CheckOffList[i].ExcludeInSectMenu = null;
|
||
if (mco.CheckOffList[i].NotOnEmpty == sco.CheckOffList[i].NotOnEmpty) subFmt.ProcData.CheckOffData.CheckOffList[i].NotOnEmpty = null;
|
||
if (mco.CheckOffList[i].Macro == sco.CheckOffList[i].Macro) subFmt.ProcData.CheckOffData.CheckOffList[i].Macro = null;
|
||
if (mco.CheckOffList[i].CheckOffXtraLines == sco.CheckOffList[i].CheckOffXtraLines) subFmt.ProcData.CheckOffData.CheckOffList[i].CheckOffXtraLines = NullInt;
|
||
if (mco.CheckOffList[i].CheckOffWidAdjust == sco.CheckOffList[i].CheckOffWidAdjust) subFmt.ProcData.CheckOffData.CheckOffList[i].CheckOffWidAdjust = NullInt;
|
||
}
|
||
|
||
for (int i = 0; i < MAXCHKHEADINGS; i++)
|
||
if (mco.CheckOffHeaderList[i].CheckOffHeading == sco.CheckOffHeaderList[i].CheckOffHeading) subFmt.ProcData.CheckOffData.CheckOffHeaderList[i].CheckOffHeading = null;
|
||
|
||
if (msctpr.HLStpSeparatorString == ssctpr.HLStpSeparatorString) subFmt.SectData.StepSectionData.StpSectPrtData.HLStpSeparatorString = null;
|
||
if (msctpr.HLRNOStpSeparatorString == ssctpr.HLRNOStpSeparatorString) subFmt.SectData.StepSectionData.StpSectPrtData.HLRNOStpSeparatorString = null;
|
||
if (msctpr.LowerCaseRevNum != null && msctpr.LowerCaseRevNum == ssctpr.LowerCaseRevNum) subFmt.SectData.StepSectionData.StpSectPrtData.LowerCaseRevNum = "null";
|
||
if (msctpr.UseXtraRevNumber != null && msctpr.UseXtraRevNumber == ssctpr.UseXtraRevNumber) subFmt.SectData.StepSectionData.StpSectPrtData.UseXtraRevNumber = "null";
|
||
if (msctpr.SpecialLandscapeMode != null && msctpr.SpecialLandscapeMode == ssctpr.SpecialLandscapeMode) subFmt.SectData.StepSectionData.StpSectPrtData.SpecialLandscapeMode = "null";
|
||
for (int i = 0; i < MAXSEQ; i++)
|
||
{
|
||
if (msctpr.LeftJustifyList[i].Size == ssctpr.LeftJustifyList[i].Size) subFmt.SectData.StepSectionData.StpSectPrtData.LeftJustifyList[i].Size = NullInt;
|
||
}
|
||
if (msctlay.LowerLimitDivisor == ssctlay.LowerLimitDivisor) subFmt.SectData.StepSectionData.StpSectLayData.LowerLimitDivisor = null;
|
||
|
||
for (int i = 0; i < MAXTRANS; i++)
|
||
{
|
||
if (mainFmt.TransData.TransTypeData[i].TransFormat == subFmt.TransData.TransTypeData[i].TransFormat) subFmt.TransData.TransTypeData[i].TransFormat = null;
|
||
if (mainFmt.TransData.TransTypeData[i].TransMenu == subFmt.TransData.TransTypeData[i].TransMenu) subFmt.TransData.TransTypeData[i].TransMenu = null;
|
||
if (mainFmt.TransData.TransTypeData[i].TransUI == subFmt.TransData.TransTypeData[i].TransUI) subFmt.TransData.TransTypeData[i].TransUI = null;
|
||
}
|
||
|
||
if (msctlay.NonLinkedStepNumber == ssctlay.NonLinkedStepNumber) subFmt.SectData.StepSectionData.StpSectLayData.NonLinkedStepNumber = null;
|
||
if (msctlay.NonLinkedCautNoteNumber == ssctlay.NonLinkedCautNoteNumber) subFmt.SectData.StepSectionData.StpSectLayData.NonLinkedCautNoteNumber = null;
|
||
if (msctlay.NonLinkedRNONumber == ssctlay.NonLinkedRNONumber) subFmt.SectData.StepSectionData.StpSectLayData.NonLinkedRNONumber = null;
|
||
if (msctlay.Dev_Format != null && msctlay.Dev_Format == ssctlay.Dev_Format) subFmt.SectData.StepSectionData.StpSectLayData.Dev_Format = "null";
|
||
if (msctlay.EnhancedShortFormDev != null && msctlay.EnhancedShortFormDev == ssctlay.EnhancedShortFormDev) subFmt.SectData.StepSectionData.StpSectLayData.EnhancedShortFormDev = "null";
|
||
if (msctlay.SpecialPageBreakFlag != null && msctlay.SpecialPageBreakFlag == ssctlay.SpecialPageBreakFlag) subFmt.SectData.StepSectionData.StpSectLayData.SpecialPageBreakFlag = "null";
|
||
if (msctlay.PaginateOnFirstSubstep != null && msctlay.PaginateOnFirstSubstep == ssctlay.PaginateOnFirstSubstep) subFmt.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep = "null";
|
||
if (msctlay.PaginateOnFirstSubstep2X != null && msctlay.PaginateOnFirstSubstep2X == ssctlay.PaginateOnFirstSubstep2X) subFmt.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep2X = "null";
|
||
if (msctlay.UseHalfLines != null && msctlay.UseHalfLines == ssctlay.UseHalfLines) subFmt.SectData.StepSectionData.StpSectLayData.UseHalfLines = "null";
|
||
if (msctlay.TryToFillHalfOfPage != null && msctlay.TryToFillHalfOfPage == ssctlay.TryToFillHalfOfPage) subFmt.SectData.StepSectionData.StpSectLayData.TryToFillHalfOfPage = "null";
|
||
if (msctlay.CompressSteps != null && msctlay.CompressSteps == ssctlay.CompressSteps) subFmt.SectData.StepSectionData.StpSectLayData.CompressSteps = "null";
|
||
if (msctlay.DoSTExtraAtTop != null && msctlay.DoSTExtraAtTop == ssctlay.DoSTExtraAtTop) subFmt.SectData.StepSectionData.StpSectLayData.DoSTExtraAtTop = "null";
|
||
if (msctlay.KeepStepsOnPage != null && msctlay.KeepStepsOnPage == ssctlay.KeepStepsOnPage) subFmt.SectData.StepSectionData.StpSectLayData.KeepStepsOnPage = "null";
|
||
if (msctlay.BreakOnSections != null && msctlay.BreakOnSections == ssctlay.BreakOnSections) subFmt.SectData.StepSectionData.StpSectLayData.BreakOnSections = "null";
|
||
if (inheritShowSectionTitles && msctlay.ShowSectionTitles != null && msctlay.ShowSectionTitles == ssctlay.ShowSectionTitles) subFmt.SectData.StepSectionData.StpSectLayData.ShowSectionTitles = "null";
|
||
if (msctlay.EndForSingle != null && msctlay.EndForSingle == ssctlay.EndForSingle) subFmt.SectData.StepSectionData.StpSectLayData.EndForSingle = "null";
|
||
if (msctlay.PaginateOnFirstSubstep3X != null && msctlay.PaginateOnFirstSubstep3X == ssctlay.PaginateOnFirstSubstep3X) subFmt.SectData.StepSectionData.StpSectLayData.PaginateOnFirstSubstep3X = "null";
|
||
if (msctlay.PaginateOnLowerStepLevel != null && msctlay.PaginateOnLowerStepLevel == ssctlay.PaginateOnLowerStepLevel) subFmt.SectData.StepSectionData.StpSectLayData.PaginateOnLowerStepLevel = "null";
|
||
if (msctlay.CustomSpacing != null && msctlay.CustomSpacing == ssctlay.CustomSpacing) subFmt.SectData.StepSectionData.StpSectLayData.CustomSpacing = "null";
|
||
if (msctlay.SplitStepInPrntStep != null && msctlay.SplitStepInPrntStep == ssctlay.SplitStepInPrntStep) subFmt.SectData.StepSectionData.StpSectLayData.SplitStepInPrntStep = "null";
|
||
if (msctlay.LineAboveUnderSection != null && msctlay.LineAboveUnderSection == ssctlay.LineAboveUnderSection) subFmt.SectData.StepSectionData.StpSectLayData.LineAboveUnderSection = "null";
|
||
if (msctlay.PicaIgnoreFiveSixths != null && msctlay.PicaIgnoreFiveSixths == ssctlay.PicaIgnoreFiveSixths) subFmt.SectData.StepSectionData.StpSectLayData.PicaIgnoreFiveSixths = "null";
|
||
if (msctlay.SpaceForNoSecNumb != null && msctlay.SpaceForNoSecNumb == ssctlay.SpaceForNoSecNumb) subFmt.SectData.StepSectionData.StpSectLayData.SpaceForNoSecNumb = "null";
|
||
if (msctlay.PageBreakOnFirstBlankLine != null && msctlay.PageBreakOnFirstBlankLine == ssctlay.PageBreakOnFirstBlankLine) subFmt.SectData.StepSectionData.StpSectLayData.PageBreakOnFirstBlankLine = "null";
|
||
if (msctlay.PutOnPageByItself != null && msctlay.PutOnPageByItself == ssctlay.PutOnPageByItself) subFmt.SectData.StepSectionData.StpSectLayData.PutOnPageByItself = "null";
|
||
if (msctlay.PaginateAtHighestPaginLevel != null && msctlay.PaginateAtHighestPaginLevel == ssctlay.PaginateAtHighestPaginLevel) subFmt.SectData.StepSectionData.StpSectLayData.PaginateAtHighestPaginLevel = "null";
|
||
if (msctlay.UseSTExtraRealValue != null && msctlay.UseSTExtraRealValue == ssctlay.UseSTExtraRealValue) subFmt.SectData.StepSectionData.StpSectLayData.UseSTExtraRealValue = "null";
|
||
if (msctlay.DoSectionSeparatorLine != null && msctlay.DoSectionSeparatorLine == ssctlay.DoSectionSeparatorLine) subFmt.SectData.StepSectionData.StpSectLayData.DoSectionSeparatorLine = "null";
|
||
if (msctlay.TieTabToLevel != null && msctlay.TieTabToLevel == ssctlay.TieTabToLevel) subFmt.SectData.StepSectionData.StpSectLayData.TieTabToLevel = "null";
|
||
if (msctlay.HighLevelRNOBeforeAERSubsteps != null && msctlay.HighLevelRNOBeforeAERSubsteps == ssctlay.HighLevelRNOBeforeAERSubsteps) subFmt.SectData.StepSectionData.StpSectLayData.HighLevelRNOBeforeAERSubsteps = "null";
|
||
if (msctlay.UseStepTypeWidthOverride != null && msctlay.UseStepTypeWidthOverride == ssctlay.UseStepTypeWidthOverride) subFmt.SectData.StepSectionData.StpSectLayData.UseStepTypeWidthOverride = "null";
|
||
if (msctlay.UseStepTypeWidthOverrideEditPrint != null && msctlay.UseStepTypeWidthOverrideEditPrint == ssctlay.UseStepTypeWidthOverrideEditPrint) subFmt.SectData.StepSectionData.StpSectLayData.UseStepTypeWidthOverrideEditPrint = "null";
|
||
if (msctlay.PartialStepCompression != null && msctlay.PartialStepCompression == ssctlay.PartialStepCompression) subFmt.SectData.StepSectionData.StpSectLayData.PartialStepCompression = "null";
|
||
if (msctlay.VirtualDotInHLSTab != null && msctlay.VirtualDotInHLSTab == ssctlay.VirtualDotInHLSTab) subFmt.SectData.StepSectionData.StpSectLayData.VirtualDotInHLSTab = "null";
|
||
if (msctlay.OverrideEnhancedTabs != null && msctlay.OverrideEnhancedTabs == ssctlay.OverrideEnhancedTabs) subFmt.SectData.StepSectionData.StpSectLayData.OverrideEnhancedTabs = "null";
|
||
if (msctlay.RNO != null && msctlay.RNO == ssctlay.RNO) subFmt.SectData.StepSectionData.StpSectLayData.RNO = "null";
|
||
if (msctlay.OnlySingleColumn != null && msctlay.OnlySingleColumn == ssctlay.OnlySingleColumn) subFmt.SectData.StepSectionData.StpSectLayData.OnlySingleColumn = "null";
|
||
|
||
if (mainFmt.PrintData.DuplexBGDirectory == subFmt.PrintData.DuplexBGDirectory) subFmt.PrintData.DuplexBGDirectory = null;
|
||
if (mainFmt.PrintData.DuplexDDDirectory == subFmt.PrintData.DuplexDDDirectory) subFmt.PrintData.DuplexDDDirectory = null;
|
||
|
||
#endregion
|
||
return true;
|
||
}
|
||
//private bool _LookForChange = false;
|
||
private VE_Font FixInheritedFont(VE_Font font, VE_Font inhFont)
|
||
{
|
||
if (inhFont != null && font != null)
|
||
{
|
||
if (!font.CanInherit()) return font; // Already partially inherited
|
||
if (inhFont.FontFamily == font.FontFamily) font.FontFamily = null;
|
||
if (inhFont.FontSize == font.FontSize) font.FontSize = null;
|
||
if (inhFont.FontStyle == font.FontStyle) font.FontStyle = null;
|
||
if (inhFont.FontJustify == font.FontJustify) font.FontJustify = null;
|
||
if (inhFont.FontCheckOff == font.FontCheckOff) font.FontCheckOff = null;
|
||
if (inhFont.CPI == font.CPI) font.CPI = null;
|
||
//if (_LookForChange && !font.CanInherit())
|
||
// Console.WriteLine("Change Happened");
|
||
if (font.FontFamily == null && font.FontSize == null && font.FontStyle == null && font.FontJustify == null && font.FontCheckOff == null && font.CPI == null)
|
||
font = null;
|
||
}
|
||
return font;
|
||
}
|
||
#endregion
|
||
#region DoStepInherit
|
||
delegate string StepPartStr(Step stp);
|
||
private string StepPartReadOnly(Step stp) { return stp.ReadOnly; }
|
||
private string StepPartInactive(Step stp) { return stp.Inactive; }
|
||
private string StepPartColOverride(Step stp) { return stp.ColOverride; }
|
||
private string StepPartColOverrideEdit(Step stp) { return stp.ColOverrideEdit; }
|
||
private string StepPartWidthOverride(Step stp) { return stp.WidthOverride; }
|
||
private string StepPartWidthOverrideEdit(Step stp) { return stp.WidthOverrideEdit; }
|
||
private string StepPartSep(Step stp) { return stp.Sep; }
|
||
private string StepPartPrefix(Step stp) { return stp.Prefix; }
|
||
private string StepPartSuffix(Step stp) { return stp.Suffix; }
|
||
private string StepPartUnderlineTheseChar(Step stp) { return stp.UnderlineTheseChar; }
|
||
private string StepPartVertPos(Step stp) { return stp.VertPos; }
|
||
|
||
private string StepPartFontFamily(Step stp)
|
||
{
|
||
if (stp.Font == null) return null;
|
||
return stp.Font.FontFamily;
|
||
}
|
||
private string StepPartFontSize(Step stp)
|
||
{
|
||
if (stp.Font == null) return null;
|
||
return stp.Font.FontSize;
|
||
}
|
||
private string StepPartFontCPI(Step stp)
|
||
{
|
||
if (stp.Font == null) return null;
|
||
return stp.Font.CPI;
|
||
}
|
||
private string StepPartFontStyle(Step stp)
|
||
{
|
||
if (stp.Font == null) return null;
|
||
return stp.Font.FontStyle;
|
||
}
|
||
private string StepPartFontJustify(Step stp)
|
||
{
|
||
if (stp.Font == null) return null;
|
||
return stp.Font.FontJustify;
|
||
}
|
||
private string StepPartFontCheckOff(Step stp)
|
||
{
|
||
if (stp.Font == null) return null;
|
||
return stp.Font.FontCheckOff;
|
||
}
|
||
private string StepPartLayoutForeColor(Step stp) { return stp.StepLayoutData.ForeColor; }
|
||
private string StepPartLayoutBackColor(Step stp) { return stp.StepLayoutData.BackColor; }
|
||
private string StepPartLayoutSTExtraSpace(Step stp) { return stp.StepLayoutData.STExtraSpace; }
|
||
private string StepPartLayoutSTBoxindex(Step stp) { return stp.StepLayoutData.STBoxindex; }
|
||
private string StepPartLayoutEveryNLines(Step stp) { return stp.StepLayoutData.EveryNLines; }
|
||
private string StepPartLayoutSpaceBefore(Step stp) { return stp.StepLayoutData.SpaceBefore; }
|
||
private string StepPartLayoutSpaceAfter(Step stp) { return stp.StepLayoutData.SpaceAfter; }
|
||
private string StepPartLayoutAlwaysUpperCase(Step stp) { return stp.StepLayoutData.AlwaysUpperCase; }
|
||
private string StepPartLayoutPageBreakAtTypeChange(Step stp) { return stp.StepLayoutData.PageBreakAtTypeChange; }
|
||
private string StepPartLayoutAlignWithParentTab(Step stp) { return stp.StepLayoutData.AlignWithParentTab; }
|
||
|
||
private string StepPartEditForeColor(Step stp) { return stp.StepEditData.ForeColor; }
|
||
private string StepPartEditBackColor(Step stp) { return stp.StepEditData.BackColor; }
|
||
private string StepPartEditAcTable(Step stp) { return stp.StepEditData.AcTable; }
|
||
private string StepPartEditSearchable(Step stp) { return stp.StepEditData.Searchable; }
|
||
|
||
private string StepPartPrintForeColor(Step stp) { return stp.StepPrintData.ForeColor; }
|
||
private string StepPartPrintBackColor(Step stp) { return stp.StepPrintData.BackColor; }
|
||
private string StepPartPrintPosAdjust(Step stp) { return stp.StepPrintData.PosAdjust; }
|
||
|
||
private string StepPartTabIdentEdit(Step stp) { return stp.TabData.IdentEdit; }
|
||
private string StepPartTabIdent(Step stp) { return stp.TabData.Ident; }
|
||
private string StepPartTabRNOIdentEdit(Step stp) { return stp.TabData.RNOIdentEdit; }
|
||
private string StepPartTabRNOIdent(Step stp) { return stp.TabData.RNOIdent; }
|
||
//private string StepPartTabIdentEditWid(Step stp) { return stp.TabData.IdentEditWid; }
|
||
//private string StepPartTabIdentWid(Step stp) { return stp.TabData.IdentWid; }
|
||
//private string StepPartTabRNOIdentEditWid(Step stp) { return stp.TabData.RNOIdentEditWid; }
|
||
//private string StepPartTabRNOIdentWid(Step stp) { return stp.TabData.RNOIdentWid; }
|
||
private string StepPartTabJustify(Step stp) { return stp.TabData.Justify; }
|
||
private string StepPartTabTrim(Step stp) { return stp.TabData.NoTrim; }
|
||
// Do the flags:
|
||
private string StepPartDoubleSpace(Step stp) { return stp.DoubleSpace; }
|
||
private string StepPartEnhancedStepNumFromPrev(Step stp) { return stp.EnhancedStepNumFromPrev; }
|
||
private string StepPartUseSmartTemplate(Step stp) { return stp.UseSmartTemplate; }
|
||
private string StepPartAlwaysUseExtraLines(Step stp) { return stp.AlwaysUseExtraLines; }
|
||
private string StepPartSeparateBox(Step stp) { return stp.SeparateBox; }
|
||
private string StepPartSeparateBoxCautions(Step stp) { return stp.SeparateBoxCautions; }
|
||
private string StepPartSpaceDouble(Step stp) { return stp.SpaceDouble; }
|
||
private string StepPartReduceLineAfter(Step stp) { return stp.ReduceLineAfter; }
|
||
private string StepPartSameLevel(Step stp) { return stp.SameLevel; }
|
||
private string StepPartBoldHighLevel(Step stp) { return stp.BoldHighLevel; }
|
||
private string StepPartOneLineBeforeTab(Step stp) { return stp.OneLineBeforeTab; }
|
||
private string StepPartBoxIt(Step stp) { return stp.BoxIt; }
|
||
private string StepPartBoxed(Step stp) { return stp.Boxed; }
|
||
private string StepPartXLines_StepFix(Step stp) { return stp.XLines_StepFix; }
|
||
private string StepPartRebox(Step stp) { return stp.Rebox; }
|
||
private string StepPartSpcHdr(Step stp) { return stp.SpcHdr; }
|
||
private string StepPartContinueOnly(Step stp) { return stp.ContinueOnly; }
|
||
private string StepPartSepAfterAER(Step stp) { return stp.SepAfterAER; }
|
||
private string StepPartUseAlternateStepBox(Step stp) { return stp.UseAlternateStepBox; }
|
||
private string StepPartUnderlineAfterDashSpace(Step stp) { return stp.UnderlineAfterDashSpace; }
|
||
private string StepPartSpaceIn(Step stp) { return stp.SpaceIn; }
|
||
private string StepPartPageBreakOnStep(Step stp) { return stp.PageBreakOnStep; }
|
||
private string StepPartUseOldTemplate(Step stp) { return stp.UseOldTemplate; }
|
||
private string StepPartAlignNullTabWSectHead(Step stp) { return stp.AlignNullTabWSectHead; }
|
||
private string StepPartAlignHLSTabWithSectOvride(Step stp) { return stp.AlignHLSTabWithSectOvride; }
|
||
private string StepPartTextSubFollowsTextStyle(Step stp) { return stp.TextSubFollowsTextStyle; }
|
||
private string StepPartTreatAsSequential(Step stp) { return stp.TreatAsSequential; }
|
||
private string StepPartMatchUpRNO(Step stp) { return stp.MatchUpRNO; }
|
||
private string StepPartInPageList(Step stp) { return stp.InPageList; }
|
||
private string StepPartCenterOneLineOnly(Step stp) { return stp.CenterOneLineOnly; }
|
||
private string StepPartSubTableGetsUp1Level(Step stp) { return stp.SubTableGetsUp1Level; }
|
||
private string StepPartRemember(Step stp) { return stp.Remember; }
|
||
private string StepPartCenterOneLineAdjust(Step stp) { return stp.CenterOneLineAdjust; }
|
||
private string StepPartBreak(Step stp) { return stp.Break; }
|
||
private string StepPartBreakEquipmentList(Step stp) { return stp.BreakEquipmentList; }
|
||
private string StepPartBreakCautionsNotesOnSubstps(Step stp) { return stp.BreakCautionsNotesOnSubstps; }
|
||
private string StepPartCenterTextWithinWidth(Step stp) { return stp.CenterTextWithinWidth; }
|
||
private string StepPartNewlineAfter(Step stp) { return stp.NewlineAfter; }
|
||
private string StepPartStartLineWithDash(Step stp) { return stp.StartLineWithDash; }
|
||
private string StepPartBlankLineBeforeSubStep(Step stp) { return stp.BlankLineBeforeSubStep; }
|
||
private string StepPartAlwaysTab(Step stp) { return stp.AlwaysTab; }
|
||
private string StepPartMixCautionsAndNotes(Step stp) { return stp.MixCautionsAndNotes; }
|
||
private string StepPartNumberHighLevel(Step stp) { return stp.NumberHighLevel; }
|
||
private string StepPartOffsetTab(Step stp) { return stp.OffsetTab; }
|
||
private string StepPartAdjHighLevelTab(Step stp) { return stp.AdjHighLevelTab; }
|
||
private string StepPartChildIndent(Step stp) { return stp.ChildIndent; }
|
||
private string StepPartLeftJustifyBorderless(Step stp) { return stp.LeftJustifyBorderless; }
|
||
private string StepPartStepNumIfOnlyOne(Step stp) { return stp.StepNumIfOnlyOne; }
|
||
private string StepPartLJTabs(Step stp) { return stp.LJTabs; }
|
||
private string StepPartNumberSubs(Step stp) { return stp.NumberSubs; }
|
||
private string StepPartBullet(Step stp) { return stp.BulletOnContinuous; }
|
||
private string StepPartStepNumberForHighLevel(Step stp) { return stp.StepNumberForHighLevel; }
|
||
private string StepPartSameRowAsParent(Step stp) { return stp.SameRowAsParent; }
|
||
private string StepPartCheckoffSameAsParent(Step stp) { return stp.CheckoffSameAsParent; }
|
||
private string StepPartAtLeastTwoDigits(Step stp) { return stp.AtLeastTwoDigits; }
|
||
private string StepPartUseInAcTable(Step stp) { return stp.UseInAcTable; }
|
||
private string StepPartNumber(Step stp) { return stp.Number; }
|
||
private string StepPartThreeBlanksAbove(Step stp) { return stp.ThreeBlanksAbove; }
|
||
private string StepPartCheckOffs(Step stp) { return stp.CheckOffs; }
|
||
private string StepPartQuoted(Step stp) { return stp.Quoted; }
|
||
|
||
//private string StepPartTabCheckOff(Step stp) { return stp.TabData.CheckOff; }
|
||
private string StepPartTabFontFamily(Step stp)
|
||
{
|
||
if (stp.TabData.Font == null) return null;
|
||
return stp.TabData.Font.FontFamily;
|
||
}
|
||
private string StepPartTabFontSize(Step stp)
|
||
{
|
||
if (stp.TabData.Font == null) return null;
|
||
return stp.TabData.Font.FontSize;
|
||
}
|
||
private string StepPartTabFontCPI(Step stp)
|
||
{
|
||
if (stp.TabData.Font == null) return null;
|
||
return stp.TabData.Font.CPI;
|
||
}
|
||
private string StepPartTabFontStyle(Step stp)
|
||
{
|
||
if (stp.TabData.Font == null) return null;
|
||
return stp.TabData.Font.FontStyle;
|
||
}
|
||
private string StepPartTabFontJustify(Step stp)
|
||
{
|
||
if (stp.TabData.Font == null) return null;
|
||
return stp.TabData.Font.FontJustify;
|
||
}
|
||
private string StepPartTabMacroListName(Step stp)
|
||
{
|
||
if (stp.TabData.MacroList == null || stp.TabData.MacroList[0].Name == null) return null;
|
||
return stp.TabData.MacroList[0].Name;
|
||
}
|
||
private string StepPartTabMacroListMacro(Step stp)
|
||
{
|
||
if (stp.TabData.MacroList == null || stp.TabData.MacroList[0].Macro == null) return null;
|
||
return stp.TabData.MacroList[0].Macro;
|
||
}
|
||
private string StepPartTabMacroListLocWithXOff(Step stp)
|
||
{
|
||
if (stp.TabData.MacroList == null || stp.TabData.MacroList[0].LocWithXOff == null) return null;
|
||
return stp.TabData.MacroList[0].LocWithXOff;
|
||
}
|
||
private string StepPartTabMacroListGrouping(Step stp)
|
||
{
|
||
if (stp.TabData.MacroList == null || stp.TabData.MacroList[0].Grouping == null) return null;
|
||
return stp.TabData.MacroList[0].Grouping;
|
||
}
|
||
private string StepPartTabMacroListNotInRNO(Step stp)
|
||
{
|
||
if (stp.TabData.MacroList == null || stp.TabData.MacroList[0].NotInRNO == null) return null;
|
||
return stp.TabData.MacroList[0].NotInRNO;
|
||
}
|
||
private string StepPartEditTypeInMenu(Step stp) { return stp.StepEditData.TypeMenu.InMenu; }
|
||
private string StepPartEditTypeRnoInMenu(Step stp) { return stp.StepEditData.TypeMenu.RnoInMenu; }
|
||
private string StepPartEditTypeMenuItem(Step stp) { return stp.StepEditData.TypeMenu.MenuItem; }
|
||
private string StepPartEditTypeRnoMenuItem(Step stp) { return stp.StepEditData.TypeMenu.RnoMenuItem; }
|
||
private string StepPartEditTypeNoChg_Reason(Step stp) { return stp.StepEditData.TypeMenu.NoChgReason; }
|
||
private string StepPartEditTypeAlternateNameList(Step stp) { return stp.StepEditData.TypeMenu.AlternateNameList; }
|
||
|
||
private bool baseDone = false; // base is first 'GEN.Fmt', but there will be a 2nd, i.e. the genfmt.in
|
||
// pass in the format's file name so that we can check if we're working with the base format, i.e. 'gen.fmt'.
|
||
private void DoStepInheritance(ref Step[] stpdata, string fname)
|
||
{
|
||
Dictionary<string, Step> dicSteps = BuildStepDic(stpdata);
|
||
Dictionary<string, Step> dicParents = BuildParentDic(stpdata, dicSteps);
|
||
int startIndx = fname.ToUpper() == "GEN.FMT" && !baseDone? 1 : 0;
|
||
baseDone = true;
|
||
for (int i = startIndx; i < MAXSTEPS; i++)
|
||
//for (int i = 0; i < MAXSTEPS; i++)
|
||
{
|
||
FixInheritance(ref stpdata[i], dicParents);
|
||
// Since 'Step' is a structure, the StepParentList (dictionary) needs to be updated each time
|
||
// the stpdata is updated. Each instance of Step, because it is a structure, will be a separate copy
|
||
// so the dictionary had a distinct copy of the step's format data from what gets passed in by reference.
|
||
for (int j = 0; j < MAXSTEPS; j++)
|
||
{
|
||
if (stpdata[i].Type == stpdata[j].ParentType) StepParentList[0][stpdata[j].Type] = stpdata[i];
|
||
}
|
||
}
|
||
}
|
||
public const string NullString = "-12345";
|
||
public const int NullInt = -12345;
|
||
public const byte NullByte = 123;
|
||
|
||
private void FixInheritance(ref Step step, Dictionary<string, Step> dicParents)
|
||
{
|
||
if (CheckInheritedStr(new StepPartStr(StepPartReadOnly), step, dicParents)) step.ReadOnly = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartInactive), step, dicParents)) step.Inactive = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartColOverride), step, dicParents)) step.ColOverride = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartColOverrideEdit), step, dicParents)) step.ColOverrideEdit = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartWidthOverride), step, dicParents)) step.WidthOverride = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartWidthOverrideEdit), step, dicParents)) step.WidthOverrideEdit = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSep), step, dicParents)) step.Sep = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartPrefix), step, dicParents)) step.Prefix = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSuffix), step, dicParents)) step.Suffix = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartUnderlineTheseChar), step, dicParents)) step.UnderlineTheseChar = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartVertPos), step, dicParents)) step.VertPos = null;
|
||
// substructures - Font
|
||
if (step.Font != null && CheckInheritedStr(new StepPartStr(StepPartFontFamily), step, dicParents))
|
||
step.Font.FontFamily = null;
|
||
if (step.Font != null && CheckInheritedStr(new StepPartStr(StepPartFontStyle), step, dicParents))
|
||
step.Font.FontStyle = null;
|
||
if (step.Font != null && CheckInheritedStr(new StepPartStr(StepPartFontSize), step, dicParents))
|
||
step.Font.FontSize = null;
|
||
if (step.Font != null && CheckInheritedStr(new StepPartStr(StepPartFontCPI), step, dicParents))
|
||
step.Font.CPI = null;
|
||
if (step.Font != null && CheckInheritedStr(new StepPartStr(StepPartFontJustify), step, dicParents))
|
||
step.Font.FontJustify = null;
|
||
if (step.Font != null && CheckInheritedStr(new StepPartStr(StepPartFontCheckOff), step, dicParents))
|
||
step.Font.FontCheckOff = null;
|
||
if ((step.Font != null) && (step.Font.FontFamily == null) && (step.Font.FontStyle == null) && (step.Font.FontSize == null) && (step.Font.FontJustify == null) && (step.Font.FontCheckOff == null) && (step.Font.CPI == null))
|
||
step.Font = null;
|
||
// substructure - StepLayoutData
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutForeColor), step, dicParents)) step.StepLayoutData.ForeColor = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutBackColor), step, dicParents)) step.StepLayoutData.BackColor = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutSTExtraSpace), step, dicParents))
|
||
{
|
||
Console.WriteLine("{0}", fmtName);
|
||
step.StepLayoutData.STExtraSpace = NullString;
|
||
}
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutSTBoxindex), step, dicParents)) step.StepLayoutData.STBoxindex = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutEveryNLines), step, dicParents)) step.StepLayoutData.EveryNLines = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutSpaceBefore), step, dicParents)) step.StepLayoutData.SpaceBefore = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutSpaceAfter), step, dicParents)) step.StepLayoutData.SpaceAfter = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutAlwaysUpperCase), step, dicParents)) step.StepLayoutData.AlwaysUpperCase = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutPageBreakAtTypeChange), step, dicParents)) step.StepLayoutData.PageBreakAtTypeChange = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLayoutAlignWithParentTab), step, dicParents)) step.StepLayoutData.AlignWithParentTab = null;
|
||
// substructure - StepEditData
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditForeColor), step, dicParents)) step.StepEditData.ForeColor = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditBackColor), step, dicParents)) step.StepEditData.BackColor = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditAcTable), step, dicParents)) step.StepEditData.AcTable = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditSearchable), step, dicParents)) step.StepEditData.Searchable = null;
|
||
// substructure - TypeMenu
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditTypeInMenu), step, dicParents)) step.StepEditData.TypeMenu.InMenu = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditTypeRnoInMenu), step, dicParents)) step.StepEditData.TypeMenu.RnoInMenu = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditTypeMenuItem), step, dicParents)) step.StepEditData.TypeMenu.MenuItem = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditTypeRnoMenuItem), step, dicParents)) step.StepEditData.TypeMenu.RnoMenuItem = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditTypeNoChg_Reason), step, dicParents)) step.StepEditData.TypeMenu.NoChgReason = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEditTypeAlternateNameList), step, dicParents)) step.StepEditData.TypeMenu.AlternateNameList = null;
|
||
// substructure - StepPrintData
|
||
if (CheckInheritedStr(new StepPartStr(StepPartPrintForeColor), step, dicParents)) step.StepPrintData.ForeColor = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartPrintBackColor), step, dicParents)) step.StepPrintData.BackColor = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartPrintPosAdjust), step, dicParents)) step.StepPrintData.PosAdjust = NullString;
|
||
// substructure - TabData
|
||
|
||
//RHM/KBR added this - not sure: if (mstp.TabData.IdentEdit == sstp.TabData.IdentEdit) subFmt.StepData[i].TabData.IdentEdit = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabIdentEdit), step, dicParents)) step.TabData.IdentEdit = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabIdent), step, dicParents)) step.TabData.Ident = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabRNOIdentEdit), step, dicParents)) step.TabData.RNOIdentEdit = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabRNOIdent), step, dicParents)) step.TabData.RNOIdent = null;
|
||
//if (CheckInheritedStr(new StepPartStr(StepPartTabIdentEditWid), step, dicParents)) step.TabData.IdentEditWid = NullString;
|
||
//if (CheckInheritedStr(new StepPartStr(StepPartTabIdentWid), step, dicParents)) step.TabData.IdentWid = NullString;
|
||
//if (CheckInheritedStr(new StepPartStr(StepPartTabRNOIdentEditWid), step, dicParents)) step.TabData.RNOIdentEditWid = NullString;
|
||
//if (CheckInheritedStr(new StepPartStr(StepPartTabRNOIdentWid), step, dicParents)) step.TabData.RNOIdentWid = NullString;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabJustify), step, dicParents)) step.TabData.Justify = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabTrim), step, dicParents)) step.TabData.NoTrim = null;
|
||
//if (CheckInheritedStr(new StepPartStr(StepPartTabCheckOff), step, dicParents)) step.TabData.CheckOff = null;
|
||
|
||
// substructures - Tab - Font
|
||
if (step.TabData.Font != null && CheckInheritedStr(new StepPartStr(StepPartTabFontFamily), step, dicParents))
|
||
step.TabData.Font.FontFamily = null;
|
||
if (step.TabData.Font != null && CheckInheritedStr(new StepPartStr(StepPartTabFontStyle), step, dicParents))
|
||
step.TabData.Font.FontStyle = null;
|
||
if (step.TabData.Font != null && CheckInheritedStr(new StepPartStr(StepPartTabFontSize), step, dicParents))
|
||
step.TabData.Font.FontSize = null;
|
||
if (step.TabData.Font != null && CheckInheritedStr(new StepPartStr(StepPartTabFontCPI), step, dicParents))
|
||
step.TabData.Font.CPI = null;
|
||
if (step.TabData.Font != null && CheckInheritedStr(new StepPartStr(StepPartTabJustify), step, dicParents))
|
||
step.TabData.Font.FontJustify = null;
|
||
if (step.TabData.Font != null) // && CheckInheritedStr(new StepPartStr(StepPartTabCheckOff), step, dicParents))
|
||
step.TabData.Font.FontCheckOff = null;
|
||
if ((step.TabData.Font != null) && (step.TabData.Font.FontFamily == null) && (step.TabData.Font.FontStyle == null) && (step.TabData.Font.FontSize == null) && (step.TabData.Font.FontJustify == null) && (step.TabData.Font.CPI == null))
|
||
step.TabData.Font = null;
|
||
|
||
// All macro list items must be identical from step to inherited parent in order to removeit.
|
||
if (step.TabData.MacroList != null)
|
||
{
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTabMacroListName), step, dicParents) &&
|
||
CheckInheritedStr(new StepPartStr(StepPartTabMacroListMacro), step, dicParents) &&
|
||
CheckInheritedStr(new StepPartStr(StepPartTabMacroListGrouping), step, dicParents) &&
|
||
CheckInheritedStr(new StepPartStr(StepPartTabMacroListLocWithXOff), step, dicParents) &&
|
||
CheckInheritedStr(new StepPartStr(StepPartTabMacroListNotInRNO), step, dicParents))
|
||
{
|
||
step.TabData.MacroList[0].Macro = null;
|
||
step.TabData.MacroList[0].Grouping = NullString;
|
||
step.TabData.MacroList[0].NotInRNO = null;
|
||
step.TabData.MacroList[0].LocWithXOff = null;
|
||
}
|
||
}
|
||
|
||
// flags:
|
||
if (CheckInheritedStr(new StepPartStr(StepPartDoubleSpace), step, dicParents)) step.DoubleSpace = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartEnhancedStepNumFromPrev), step, dicParents)) step.EnhancedStepNumFromPrev = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartUseSmartTemplate), step, dicParents)) step.UseSmartTemplate = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartAlwaysUseExtraLines), step, dicParents)) step.AlwaysUseExtraLines = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSeparateBox), step, dicParents)) step.SeparateBox = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSeparateBoxCautions), step, dicParents)) step.SeparateBoxCautions = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSpaceDouble), step, dicParents)) step.SpaceDouble = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartReduceLineAfter), step, dicParents)) step.ReduceLineAfter = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSameLevel), step, dicParents)) step.SameLevel = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBoldHighLevel), step, dicParents)) step.BoldHighLevel = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartOneLineBeforeTab), step, dicParents)) step.OneLineBeforeTab = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBoxIt), step, dicParents)) step.BoxIt = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBoxed), step, dicParents)) step.Boxed = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartXLines_StepFix), step, dicParents)) step.XLines_StepFix = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartRebox), step, dicParents)) step.Rebox = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSpcHdr), step, dicParents)) step.SpcHdr = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartContinueOnly), step, dicParents)) step.ContinueOnly = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSepAfterAER), step, dicParents)) step.SepAfterAER = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartUseAlternateStepBox), step, dicParents)) step.UseAlternateStepBox = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartUnderlineAfterDashSpace), step, dicParents)) step.UnderlineAfterDashSpace = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSpaceIn), step, dicParents)) step.SpaceIn = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartPageBreakOnStep), step, dicParents)) step.PageBreakOnStep = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartUseOldTemplate), step, dicParents)) step.UseOldTemplate = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartAlignNullTabWSectHead), step, dicParents)) step.AlignNullTabWSectHead = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartAlignHLSTabWithSectOvride), step, dicParents)) step.AlignHLSTabWithSectOvride = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTextSubFollowsTextStyle), step, dicParents)) step.TextSubFollowsTextStyle = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartTreatAsSequential), step, dicParents)) step.TreatAsSequential = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartMatchUpRNO), step, dicParents)) step.MatchUpRNO = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartInPageList), step, dicParents)) step.InPageList = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartCenterOneLineOnly), step, dicParents)) step.CenterOneLineOnly = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSubTableGetsUp1Level), step, dicParents)) step.SubTableGetsUp1Level = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartRemember), step, dicParents)) step.Remember = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartCenterOneLineAdjust), step, dicParents)) step.CenterOneLineAdjust = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBreak), step, dicParents)) step.Break = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBreakEquipmentList), step, dicParents)) step.BreakEquipmentList = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBreakCautionsNotesOnSubstps), step, dicParents)) step.BreakCautionsNotesOnSubstps = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartCenterTextWithinWidth), step, dicParents)) step.CenterTextWithinWidth = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartNewlineAfter), step, dicParents)) step.NewlineAfter = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartStartLineWithDash), step, dicParents)) step.StartLineWithDash = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBlankLineBeforeSubStep), step, dicParents)) step.BlankLineBeforeSubStep = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartAlwaysTab), step, dicParents)) step.AlwaysTab = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartMixCautionsAndNotes), step, dicParents)) step.MixCautionsAndNotes = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartNumberHighLevel), step, dicParents)) step.NumberHighLevel = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartOffsetTab), step, dicParents)) step.OffsetTab = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartAdjHighLevelTab), step, dicParents)) step.AdjHighLevelTab = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartChildIndent), step, dicParents)) step.ChildIndent = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLeftJustifyBorderless), step, dicParents)) step.LeftJustifyBorderless = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartStepNumIfOnlyOne), step, dicParents)) step.StepNumIfOnlyOne = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartLJTabs), step, dicParents)) step.LJTabs = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartNumberSubs), step, dicParents)) step.NumberSubs = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartBullet), step, dicParents)) step.BulletOnContinuous = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartStepNumberForHighLevel), step, dicParents)) step.StepNumberForHighLevel = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartSameRowAsParent), step, dicParents)) step.SameRowAsParent = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartCheckoffSameAsParent), step, dicParents)) step.CheckoffSameAsParent = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartAtLeastTwoDigits), step, dicParents)) step.AtLeastTwoDigits = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartUseInAcTable), step, dicParents)) step.UseInAcTable = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartNumber), step, dicParents)) step.Number = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartThreeBlanksAbove), step, dicParents)) step.ThreeBlanksAbove = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartCheckOffs), step, dicParents)) step.CheckOffs = null;
|
||
if (CheckInheritedStr(new StepPartStr(StepPartQuoted), step, dicParents)) step.Quoted = null;
|
||
|
||
}
|
||
|
||
private bool CheckInheritedStr(StepPartStr stepPartStr, Step step, Dictionary<string, Step> dicParents)
|
||
{
|
||
string inheritedValue = GetStepInherited(stepPartStr, step.Type, 0);
|
||
string stepValue = stepPartStr(step);
|
||
return inheritedValue == stepValue;
|
||
//Step parent = step;
|
||
//while ((stepPartStr(parent) == null) || (step.Type == parent.Type))
|
||
//{
|
||
// if (!dicParents.ContainsKey(parent.Type))
|
||
// {
|
||
// if (BaseFormat.StepData != null)
|
||
// {
|
||
// Step mstp = BaseFormat.StepData[step.Index];
|
||
// if (stepPartStr(mstp) == stepPartStr(step)) return true;
|
||
// }
|
||
// return false;// No non-null parent value found
|
||
// }
|
||
// parent = dicParents[parent.Type];
|
||
// if (stepPartStr(step) == stepPartStr(parent))
|
||
// return true; // step value same as parent.
|
||
//}
|
||
//return false; // parent value different from step value
|
||
}
|
||
|
||
private string GetStepInherited(StepPartStr stepPartStr, string stepType, int level)
|
||
{
|
||
string typ = stepType;
|
||
// spin through the step inheritance looking for a value
|
||
while (StepParentList[level].ContainsKey(typ))
|
||
{
|
||
Step parent = StepParentList[level][typ];
|
||
string parentVal = stepPartStr(parent);
|
||
if (parentVal != null && parentVal != "-12345") return parentVal;
|
||
typ = parent.Type;
|
||
}
|
||
// no more parent formats to look at:
|
||
if (level >= (StepParentList.Count - 1)) return null;
|
||
Step stp = StepList[level + 1][stepType];
|
||
string stpVal = stepPartStr(stp);
|
||
if (stpVal != null) return stpVal;
|
||
return GetStepInherited(stepPartStr, stepType, level + 1);
|
||
}
|
||
private Dictionary<string, Step> BuildStepDic(Step[] stpdata)
|
||
{
|
||
Dictionary<string, Step> dicSteps = new Dictionary<string, Step>();
|
||
foreach (Step stp in stpdata) dicSteps[stp.Type] = stp;
|
||
return dicSteps;
|
||
}
|
||
private Dictionary<string, Step> BuildParentDic(Step[] stpdata, Dictionary<string, Step> dicSteps)
|
||
{
|
||
Dictionary<string, Step> dicParent = new Dictionary<string, Step>();
|
||
foreach (Step stp in stpdata)
|
||
if (stp.ParentType != "") dicParent[stp.Type] = dicSteps[stp.ParentType];
|
||
return dicParent;
|
||
}
|
||
#endregion
|
||
private void FixInactiveForHigh(ref FormatData fmtdata) // set all the HighLevelSteps beyond
|
||
{
|
||
Step[] stpdata = fmtdata.StepData;
|
||
int numHigh = fmtdata.SectData.StepSectionData.NumberOfHighLevelSteps;
|
||
if (numHigh == 0) return;
|
||
if (numHigh < HighTypeValue.Length) // need to set steps to inactive beyond numHigh
|
||
{
|
||
for (int i = numHigh; i < HighTypeValue.Length; i++)
|
||
{
|
||
string inactiveType = HighTypeValue[i];
|
||
for (int j = 0; j < stpdata.Length; j++)
|
||
{
|
||
if (stpdata[j].Type == inactiveType)
|
||
stpdata[j].Inactive = "True";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
private void FixInactiveForSubStep(ref FormatData fmtdata)
|
||
{
|
||
Step[] stpdata = fmtdata.StepData;
|
||
int numSub = fmtdata.SectData.StepSectionData.NumberOfSubStepTypes;
|
||
if (numSub == 0) return;
|
||
if (numSub < SubStepValue.Length) // need to set steps to inactive beyond numHigh
|
||
{
|
||
for (int i = numSub; i < SubStepValue.Length; i++)
|
||
{
|
||
string inactiveType = SubStepValue[i];
|
||
for (int j = 0; j < stpdata.Length; j++)
|
||
{
|
||
if (stpdata[j].Type == inactiveType)
|
||
stpdata[j].Inactive = "True";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
private void FixInactiveForText(ref FormatData fmtdata)
|
||
{
|
||
Step[] stpdata = fmtdata.StepData;
|
||
if ((_AlternateIndex ?? "") == "") return;
|
||
string mask = "," + _AlternateIndex + ",";
|
||
foreach (string textType in TextTypes)
|
||
{
|
||
if (!mask.Contains("," + textType + ","))
|
||
{
|
||
for (int j = 0; j < stpdata.Length; j++)
|
||
{
|
||
if (stpdata[j].Type == textType)
|
||
stpdata[j].Inactive = "True";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
private string[] HighTypeValue ={ "High", "Continuous", "Immediate", "LossOfAC", "High5" };
|
||
private string[] SubStepValue = {"Substep","And","Or","EquipmentList","EquipmentWBlank",
|
||
"ExplicitAnd","ImplicitOr","Paragraph","EquipmentOpt","EquipmentOptWBlank","ContAcSequential",
|
||
"ContAcAnd","ContAcOr","ContAcParagraph","TitleWithTextRight","TitleWithTextBelow"};
|
||
private string[] TextTypes = {"Caution","Caution1","Caution2","Caution3","Caution4",
|
||
"Note","Note1","Note2","Note3","Note4","Note5"};
|
||
|
||
private bool RHMDebugPause(string fname, string lookfor)
|
||
{
|
||
return lookfor.Contains("." + fname.Substring(0, fname.LastIndexOf(".")).ToLower() + ".");
|
||
}
|
||
}
|
||
|
||
}
|