SourceCode/PROMS/VEPROMS User Interface/frmSectionProperties.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using VEPROMS.CSLA.Library;
using VEPROMS.Properties;
using DevComponents.DotNetBar;
using DevComponents.DotNetBar.Controls;
using Volian.Controls.Library;
using DescriptiveEnum;
using System.IO;

namespace VEPROMS
{
	public partial class frmSectionProperties : DevComponents.DotNetBar.Office2007Form
	{
		private string _DefaultFormatName = null;
		private string _DefaultNumColumns = null;
		private string _DefaultPaginationStyle = null;
		private string _DefaultPrintSize = null;
		private bool _Initializing;
		private SectionConfig _SectionConfig;
    private Document _DocumentToDelete = null;
		private StepTabRibbon _MyStepTabRibbon;
		private bool _isStepSection = true;
		private bool _hasSectionCheckoffDefault = false;
		private bool _isDefaultStepSection = false;

		public frmSectionProperties(SectionConfig sectionConfig)
		{
			_SectionConfig = sectionConfig;
			InitializeComponent();
			btnGeneral.PerformClick(); // always start with General tab or button
			ItemInfo ii = ItemInfo.Get(_SectionConfig.MySection.ItemID);
			//if (sectionConfig.Number.Length > 0)
			//    this.Text = string.Format("{0}  {1} Properties", sectionConfig.Number, sectionConfig.Title);
			//else
			//    this.Text = string.Format("{0} Properties", sectionConfig.Title);
			if (sectionConfig.Number.Length > 0)
				this.Text = string.Format("{0}  {1} Properties", ii.DisplayNumber, ii.DisplayText);
			else
				this.Text = string.Format("{0} Properties", ii.DisplayText);
			ppSectTitleStpRTB.Font = ppSectTitleStpRTB.FormatFont = new System.Drawing.Font("Microsoft Sans Serif", 10F);
			ppSectTitleStpRTB.FieldToEdit = E_FieldToEdit.Text;
			ppSectTitleStpRTB.BorderStyle = BorderStyle.Fixed3D;
			ppSectTitleStpRTB.MyItemInfo = ii;
			ppSectTitleStpRTB.RefreshDisplay(true);
			ppSectNumberStpRTB.Font = this.ppSectNumberStpRTB.FormatFont = new System.Drawing.Font("Microsoft Sans Serif", 10F);
			ppSectNumberStpRTB.FieldToEdit = E_FieldToEdit.Number;
			ppSectNumberStpRTB.BorderStyle = BorderStyle.Fixed3D;
			ppSectNumberStpRTB.MyItemInfo = ii;
			ppSectNumberStpRTB.RefreshDisplay(true);
			_MyStepTabRibbon = new StepTabRibbon();
			//_MyStepTabRibbon.Dock = System.Windows.Forms.DockStyle.Top;
			//_MyStepTabRibbon.Location = new System.Drawing.Point(0, 0);
			_MyStepTabRibbon.Name = "displayTabRibbon1";
			_MyStepTabRibbon.Visible = false;

            // B2017-272 disable/enable the Steps and Word radio buttons based on the section types defined in the format
            //           and the type of an existing section or if we are creating a new section.
            //           Move the check of creating a new section into CheckAvailableSectionTypes()
            CheckAvaibleSectionTypes();
            //// if creating a new section, enable the StepSect and WordSect radio buttons
            //rbStepSect.Enabled = rbWordSect.Enabled =  !(ii.HasWordContent || ii.HasStepContent);

			// if this is an auto table of contents (mydocstyle == null if new section, so must check for that first)
			if (ii.IsAutoTOCSection)
			{
				rbWordSect.Checked = true;
				rbStepSect.Enabled = false;
				rbWordSect.Enabled = false;
				_isStepSection = false;
			}

			// if this has already been set to be a step section, i.e. HasStepContent, disable the libdoc tab
			// also disable if there is no word content yet - the user may want to change from step type to
			// word type, as long as there is no content yet.
			if (ii.HasStepContent || !ii.HasWordContent) tcpLibDoc.Enabled = false;
			if (ii.HasWordContent) _isStepSection = false;
		}

        // B2017-272 disable/enable the Steps and Word section radio buttons based on the section types defined in the format
        //           and the type of an existing section or if we are creating a new section
        private void CheckAvaibleSectionTypes()
        {
            PlantFormat pf = (ppCmbxFormat.SelectedIndex != -1) ? FormatInfoList.SortedFormatInfoList[ppCmbxFormat.SelectedIndex].PlantFormat : (_SectionConfig.MyFormat != null) ? _SectionConfig.MyFormat.PlantFormat : _SectionConfig.MyDefaultFormat.PlantFormat;
            ItemInfo ii = ItemInfo.Get(_SectionConfig.MySection.ItemID);
            // if creating a new section, enable the StepSect and WordSect radio buttons
            bool isNewSection = !(ii.HasWordContent || ii.HasStepContent || ii.HasSectionContent); // B2018-054 added check for sub sections
            int numStepSects = 0;
            int numWordSects = 0;
            foreach (DocStyle nds in pf.DocStyles.DocStyleListActive)
            {
                if (nds.IsStepSection)
                    numStepSects++;
                else 
                    numWordSects++;
            }
            rbStepSect.Enabled = (numStepSects > 0 && (isNewSection || ii.IsStepSection)); // there are step section types and current section is a step section or creating new section
            rbWordSect.Enabled = (numWordSects > 0 && (isNewSection || !ii.IsStepSection)); // there are word section types and current section is a word section or creating new section
        }
		private void btnSectPropOK_Click(object sender, EventArgs e)
		{
			sectionConfigBindingSource.EndEdit();
			
			// Save Default settings for User
			//
			// Save whether we should display the default values on this property page
			Settings.Default.ShowDefaultSectionProp = ppCbShwDefSettings.Checked;
			Settings.Default.Save();
			// save the type based on selection.
            if (ppCmbxStyleSectionType.Items.Count > 0) // B2017-270 user click on OK button but format does not have section style for this section type
		    	_SectionConfig.MySection.MyContent.Type = ((DocStyle)ppCmbxStyleSectionType.SelectedItem).Index + 10000;

			// save any changes to checkoffs.  The bindings were added to the designer, but the 'save' was
			// hanging, so they're being done here.
			PlantFormat pf = _SectionConfig.MyFormat != null ? _SectionConfig.MyFormat.PlantFormat : _SectionConfig.MyDefaultFormat.PlantFormat;
			CheckOffList chkoffList = pf.FormatData.ProcData.CheckOffData.CheckOffList;
			CheckOffHeaderList chkoffHeaderList = pf.FormatData.ProcData.CheckOffData.CheckOffHeaderList;
			int maxindx = pf.FormatData.ProcData.CheckOffData.CheckOffList.MaxIndexNoInherit;
			// C2020-003 use the _CheckOffIndex dictionary to get and save the index of the selected checkoff from the sorted checkoff list
			// B2020-039: Added the check for a valid selected index so that crash doesn't occur
			if (ppGpbxSignoffCheckoff.Enabled && (chkoffList != null && maxindx > 1)
				&& (ppCmbxCheckoffType.SelectedIndex > -1 && _CheckOffIndex[ppCmbxCheckoffType.SelectedIndex] != _SectionConfig.Section_CheckoffListSelection))
				_SectionConfig.Section_CheckoffListSelection = _CheckOffIndex[ppCmbxCheckoffType.SelectedIndex];
			if (ppCmbxCheckoffHeading.Enabled && chkoffHeaderList != null && chkoffHeaderList.MaxIndexNoInherit > 1)
				_SectionConfig.Section_CheckoffHeaderSelection = ppCmbxCheckoffHeading.SelectedIndex;

			if (ppCmbxSectPagination.SelectedValue == null)
				_SectionConfig.Section_Pagination = (SectionConfig.SectionPagination)Enum.Parse(typeof(SectionConfig.SectionPagination), _DefaultPaginationStyle);
			else
				_SectionConfig.Section_Pagination = (SectionConfig.SectionPagination)ppCmbxSectPagination.SelectedValue;
			_SectionConfig.MySection.MyContent.Config = _SectionConfig.ToString();
				_SectionConfig.MySection.MyContent.DTS = DateTime.Now;
				_SectionConfig.MySection.MyContent.UserID = Volian.Base.Library.VlnSettings.UserID;
				Section mySection = _SectionConfig.MySection.Save();
			SaveText(ppSectNumberStpRTB); // save the section number
			SaveText(ppSectTitleStpRTB); // save the section title
			FinishSectionSave(mySection); // this will also create an empty Word Doc if this is a word section
			// B2018-126 & B2018-133: Refresh in case of library document usage change
			if (_SectionConfig.MySection.MyContent.MyEntry != null && _SectionConfig.MySection.MyContent.MyEntry.MyDocument != null)
			{
				DocumentInfo docinfo = DocumentInfo.Get(_SectionConfig.MySection.MyContent.MyEntry.MyDocument.DocID);
				docinfo.RefreshDocumentEntries();
			}
            // if there is a change to the format, clean up any overridden formats that point to the selected item before saving the format change:
            // To determine a change to the format, first see if selection changed in list and then see if the format selected does not match
            // what was set on procedure, if necessary resolve for an inherited format.
            if (_SectionConfig.MySection.MySectionInfo.ActiveFormat != null &&
                _SectionConfig.MySection.MySectionInfo.ActiveFormat.FormatID != _cmbxformatOriginal)
            {
                // clean up & then refresh the configs
                using (ContentInfoList cil = ContentInfoList.ClearOverrideFormatsByItem(_SectionConfig.MySection.ItemID, _cmbxformatOriginal, _SectionConfig.MySection.MySectionInfo.ActiveFormat.FormatID))
                {
                    foreach (ContentInfo ci in cil)
                    {
                        using (Content c = ci.Get())
                        {
                            // first refresh configs because the ContentInfo.Refresh causes events to occur that refresh screen
                            // and if configs aren't done first, the screen refresh, if based on config data, will not be correct.
                            foreach (ItemInfo ii in ci.ContentItems) ii.RefreshConfig();
                            ContentInfo.Refresh(c);
                        }
                    }
                }
            }

			// if there was a document to delete, do it.
			if (_DocumentToDelete != null)
			{
				Document.Delete(_DocumentToDelete.DocID);
				_DocumentToDelete = null;
			}
			mySection.Dispose();
			// B2019-002: if there is more than one default step section (probably from migrated data), and this section was updated to not
			//  be the default section, then reset the procedure's default section id.
			if (_isDefaultStepSection && !ppCbDefaultStepSection.Checked)
			{
				// find first section in list that has originalsteps (flags a default section)
				int defsctId = 0;
				foreach (SectionInfo si in _SectionConfig.MySection.MySectionInfo.MyProcedure.Sections)
				{
					SectionConfig sc = si.MyConfig as SectionConfig;
					if (si.ItemID != _SectionConfig.MySection.ItemID && sc != null && sc.Section_OriginalSteps == "Y")
					{
						defsctId = si.ItemID;
						break;
					}
				}
				if (defsctId != 0)
				{
					// also need to set the procedure's config sectionstart to the selected section
					// if it is not set:
					using (Procedure p = Procedure.Get(_SectionConfig.MySection.MySectionInfo.MyProcedure.ItemID))
					{
						if (p.ProcedureConfig.SectionStart != defsctId.ToString())
						{
							p.ProcedureConfig.SectionStart = defsctId.ToString();
							p.Save();
							ItemInfo.Refresh(p);
						}
					}
				}
			}
			// if this section is now the 'DefaultStepSection', clear all others  (only 1 section can have
			// this property set - it is used when printing page numbers with 'WithSteps' numbering sequence.
			else if (!_isDefaultStepSection && ppCbDefaultStepSection.Checked)
			{
				foreach (SectionInfo si in _SectionConfig.MySection.MySectionInfo.MyProcedure.Sections)
				{
					SectionConfig sc = si.MyConfig as SectionConfig;
					if (si.ItemID != _SectionConfig.MySection.ItemID && sc != null && sc.Section_OriginalSteps == "Y")
					{
						using (Section ssav = si.Get())
						{
							ssav.SectionConfig.Section_OriginalSteps = "N";
							ssav.Save();
							ItemInfo.Refresh(ssav);
						}
					}
				}
				// also need to set the procedure's config sectionstart to the selected section
				// if it is not set:
				using (Procedure p = Procedure.Get(_SectionConfig.MySection.MySectionInfo.MyProcedure.ItemID))
				{
					if (p.ProcedureConfig.SectionStart != _SectionConfig.MySection.MySectionInfo.ItemID.ToString())
					{
						p.ProcedureConfig.SectionStart = _SectionConfig.MySection.MySectionInfo.ItemID.ToString();
						p.Save();
						ItemInfo.Refresh(p);
					}
				}

			}
			// Saving of enhanced data:  Only need to save if the form_load determined that this may have enhanced & radio type
			// boxes were enabled:
			if (_isStepSection && checkEnhancedSettings && rbEnhLnkContents.Enabled)
			{
				// get string that should be used for "LnkEnh"
				string type = rbEnhLnkTitle.Checked ? "T" : rbEnhLnkNo.Checked ? "N" : "Y";
				if (_SectionConfig.Section_LnkEnh != type) 
				{
					// note that the enhanced section will get created and linked from vlntreeview (to keep the code 
					// consistent between the way procedures and sections are done).
					using (Section ssav = Section.Get(_SectionConfig.MySection.ItemID))
					{
						ssav.SectionConfig.Section_LnkEnh = type;
						ssav.Save();
						ItemInfo.Refresh(ssav);
					}
				}
			}
			this.DialogResult = DialogResult.OK;
			this.Close();
		}
		public void SaveText(StepRTB myStepRTB)
		{
			if (myStepRTB.ReadOnly) return;
			if (!myStepRTB.ActiveMode) return;
			if (!myStepRTB.IsDirty && myStepRTB.Text.Contains("(Resolved Transition Text)") == false) return;
			bool success = myStepRTB.OrigDisplayText.Save((RichTextBox)myStepRTB);
			if (success)
			{
				myStepRTB.FindAllLinks();
				myStepRTB.OrigRTF = myStepRTB.Rtf;
				myStepRTB.ClearUndo();
			}
		}
		//private static void FinishSectionSave(Section section)
		private void FinishSectionSave(Section section)
		{
			ItemInfo sectinfo = ItemInfo.Get(section.ItemID);
			//  B2020-021: Clear MyDocStyle so that it will be re-read in code checking for auto TOC below
			sectinfo.MyDocStyle = null;		
			// need to find out if this is a word document type section & if it is, create a new word doc.
			bool isWordSect = true;
			int sectype = (int)sectinfo.MyContent.Type - 10000;
			PlantFormat pf = sectinfo.ActiveFormat.PlantFormat;
			foreach (DocStyle ds in pf.DocStyles.DocStyleListActive)
			{
				if (ds.Index == sectype)
				{
					isWordSect = !ds.IsStepSection;
					break;
				}
			}
			if (isWordSect && !sectinfo.HasWordContent && !sectinfo.IsAutoTOCSection &&
				(!sectinfo.IsPlacekeeperSection || (sectinfo.IsPlacekeeperSection && !ppCbPlaceKeeper.Checked)))
			{
				using (Content cont = Content.Get(sectinfo.MyContent.ContentID))
				{
					Byte[] tstbyte = System.Text.Encoding.Default.GetBytes("");
					Document doc = Document.MakeDocument(null, tstbyte, null, null,".DOCX"); // RTF Caused B2016-196 Changed to DOCX for default
					Entry entry = cont.MyEntry;
					entry.MyDocument = Document.Get(doc.DocID);
					cont.Save();
				}
			}
		}
		private void btnSectPropCancel_Click(object sender, EventArgs e)
		{
            _DocumentToDelete = null;
			sectionConfigBindingSource.CancelEdit();
			DialogResult = DialogResult.Cancel;
			this.Close();
		}

		/// <summary>
		/// Use the ParentLookup to grab the default values
		///  - set the watermark property (where applicable) of the control with that value
		///  - set the default setting labels with that value
		/// ** the default setting labels appear when the Show Default Values checkbox is checked by the user.
		/// </summary>
		private void FindDefaultValues()
		{
			_SectionConfig.ParentLookup = true;
			// Get the default format name
			_DefaultFormatName = _SectionConfig.DefaultFormatSelection;
			SetupDefault(_DefaultFormatName, ppLblFormatDefault, ppCmbxFormat);
			//if (_DefaultFormatName != null && !(_DefaultFormatName.Equals("")))
			//{
			//    string defName = string.Format("{0}", _DefaultFormatName);
			//    ppLblFormatDefault.Text = defName;
			//    ppCmbxFormat.WatermarkText = defName;
			//}
			SectionConfig.SectionColumnMode sc = _SectionConfig.Section_ColumnMode;
			_DefaultNumColumns = sc.ToString();
			SetupDefault(EnumDescConverter.GetEnumDescription(sc), ppLblDefaultNumColumns, ppCmbxNumColumns);
			SectionConfig.SectionPagination sp = _SectionConfig.Section_Pagination;
			//Console.WriteLine("{0}, {1}, default pagination", _SectionConfig.MySection.DisplayNumber, sp);
			_DefaultPaginationStyle = sp.ToString();
			SetupDefault(EnumDescConverter.GetEnumDescription(sp), ppLblDefPaginationStyle, ppCmbxSectPagination);
			//_DefaultPrintSize = _SectionConfig.Section_AttachmentPrintSize.ToString();
			//SetupDefault(EnumDescConverter.GetEnumDescription(_SectionConfig.Section_AttachmentPrintSize), ppLblDefaultPrintSize, ppCmbxAccPgPrintSize);

		_SectionConfig.ParentLookup = false;
		}

		/// <summary>
		/// Set the watermark and default label
		/// </summary>
		/// <param name="defaultText">The default text</param>
		/// <param name="lbl">Label that displays the current default when view defaults is set</param>
		/// <param name="cmboEx">Combo box with a watermark property</param>
		private static void SetupDefault(string defaultText, Label lbl, ComboBoxEx cmbo)
		{
			if (defaultText != null && !(defaultText.Equals("")))
			{
				string deftext = string.Format("{0}", defaultText);
				lbl.Text = deftext;
				cmbo.WatermarkText = deftext;
			}
		}
		private bool checkEnhancedSettings = false;
        private int? _cmbxformatOriginal = null;
		private void frmSectionProperties_Load(object sender, EventArgs e)
		{
			_Initializing = true;
			sectionConfigBindingSource.DataSource = _SectionConfig;

			ppCmbxFormat.DataSource = null;
			ppCmbxFormat.DisplayMember = "FullName";
			ppCmbxFormat.ValueMember = "FullName";
			ppCmbxFormat.DataSource = FormatUtility.GetFilteredFormatList(FormatInfoList.SortedFormatInfoList);
      if (_SectionConfig.MySection.MySectionInfo.ActiveFormat != null) _cmbxformatOriginal = (int)_SectionConfig.MySection.MySectionInfo.ActiveFormat.FormatID;
			if (_SectionConfig.FormatSelection != null)
				ppCmbxFormat.SelectedValue = _SectionConfig.FormatSelection;
			else
				ppCmbxFormat.SelectedIndex = -1;
			// Get the saved settings for this user
			//
			// Get setting telling us whether to display the default values on this property page
			ppCbShwDefSettings.Checked = (Settings.Default["ShowDefaultSectionProp"] != null) ? Settings.Default.ShowDefaultSectionProp : false;

			// Get the User's property page style "PropPageStyle" (this is a system wide user setting)
			// 1 - Button Dialog (default)
			// 2 - Tab Dialog
			if ((int)Settings.Default["PropPageStyle"] == (int)PropPgStyle.Tab)
			{
				tcSectionProp.TabsVisible = true;
				panSectBtns.Visible = false;
				this.Width -= panSectBtns.Width;
			}

			// Get the default values for the property page information
			FindDefaultValues();
			ppCmbxSectPagination.DataSource = EnumDetail<SectionConfig.SectionPagination>.Details();
			ppCmbxSectPagination.DisplayMember = "Description";
			ppCmbxSectPagination.SelectedValueChanged -= new EventHandler(ppCmbxSectPagination_SelectedValueChanged);
			ppCmbxSectPagination.ValueMember = "EValue";
			ppCmbxSectPagination.SelectedIndex = -1;
			SectionConfig.SectionPagination sp = _SectionConfig.Section_Pagination;
			if (!(sp.ToString().Equals(_DefaultPaginationStyle)) && _isStepSection)
			{
				ppBtnDefaultPaginationStyle.Visible = true;
				ppCmbxSectPagination.SelectedValue = sp;
			}
			else
				ppBtnDefaultPaginationStyle.Visible = false;

			//Console.WriteLine("{0}, {1}, current pagination", _SectionConfig.MySection.DisplayNumber, ppCmbxSectPagination.SelectedValue);
			ppCmbxSectPagination.SelectedValueChanged += new EventHandler(ppCmbxSectPagination_SelectedValueChanged);

			ppCmbxNumColumns.DataSource = EnumDetail<SectionConfig.SectionColumnMode>.Details();
			ppCmbxNumColumns.DisplayMember = "Description";
			ppCmbxNumColumns.SelectedValueChanged -= new EventHandler(ppCmbxNumColumns_SelectedValueChanged);
			ppCmbxNumColumns.ValueMember = "EValue";
			ppCmbxNumColumns.SelectedIndex = -1;
			SectionConfig.SectionColumnMode sc = _SectionConfig.Section_ColumnMode;
			if (!(sc.ToString().Equals(_DefaultNumColumns)) && _isStepSection)
			{
				ppBtnDefaultNumColumns.Visible = true;
				ppCmbxNumColumns.SelectedValue = sc;
			}
			else
				ppBtnDefaultNumColumns.Visible = false;
			ppCmbxNumColumns.SelectedValueChanged += new EventHandler(ppCmbxNumColumns_SelectedValueChanged);

			//ppCmbxAccPgPrintSize.DataSource = EnumDetail<SectionConfig.AttPrintSize>.Details();
			//ppCmbxAccPgPrintSize.DisplayMember = "Description";
			//ppCmbxAccPgPrintSize.ValueMember = "Evalue";
			//ppCmbxAccPgPrintSize.SelectedIndex = -1;

			if (!_isStepSection)
				ppCmbxLibDocFill();

			// check type of section from document styles to determine if the stepsection checkbox should
			// be checked.  
			//int secindx = (int)_SectionConfig.SectionType;
			//// find the index for the document style to determine whether this is a step or word section.
			PlantFormat pf = _SectionConfig.MyFormat != null ? _SectionConfig.MyFormat.PlantFormat : _SectionConfig.MyDefaultFormat.PlantFormat;
			//for (int i = 0; i < pf.DocStyles.DocStyleList.Count; i++)
			//{
			//    if (pf.DocStyles.DocStyleList[i].Index == secindx)
			//        rbStepSect.Checked = pf.DocStyles.DocStyleList[i].IsStepSection; _SectionConfig.MySection.
			//}

			// set the StepSect radio button based on _isStepSection to ensure the proper section types are available
			rbStepSect.Checked = _isStepSection;
			// set up some of the format tab:
			SetupPpCmbxSectionType();
			ShowAvailableOptionsForSectionType();

			// set the section level configs:
			ppCbEditableData.Checked = (_SectionConfig.SubSection_Edit == "Y");
			ppCbAutoIndent.Checked = (pf.FormatData.SectData.UseMetaSections && _SectionConfig.SubSection_AutoIndent == "Y");

			// if this section has subsections:
			// show the editable data check box. If showing 'editable data', the procedures steps are 
			//    shown in editor (tree view & editor) & printed before any subsections. If not showing 
			//    'editable data', the steps are not shown in editor or print.
			// show the automatic indent checkbox.  
			ppCbEditableData.Enabled = _SectionConfig.MySection.MySectionInfo.Sections != null && _SectionConfig.MySection.MySectionInfo.Sections.Count > 0;
			ppCbEditableData.Visible = _isStepSection; // only display if we are on a step editor section
			//ppCbAutoIndent.Enabled = _SectionConfig.MySection.MySectionInfo.Sections != null && _SectionConfig.MySection.MySectionInfo.Sections.Count > 0;
			ppCbAutoIndent.Enabled = pf.FormatData.SectData.UseMetaSections;
			ppCbAutoIndent.Visible = _isStepSection; // only display if we are on a step editor section

			// Check for the print section num/title config item to determine whether that checkbox should
			// be checked.
			ppCbPrnSecNumTitle.Enabled = _isStepSection;//true; // pf.FormatData.SectData.UseMetaSections;
			//ppCbPrnSecNumTitle.Checked = ppCbPrnSecNumTitle.Enabled && _SectionConfig.Section_PrintHdr != "N";
			ppCbPrnSecNumTitle.Checked = (_isStepSection && _SectionConfig.Section_PrintHdr != "N");
			ppCbPrnSecNumTitle.Visible = _isStepSection; // only display if we are on a step editor section

			// check if format has automated table of contents, if so, check if config flag is set that this
			// section should be included.
			ppCbIncTOC.Enabled = false;
			gpTOC.Visible = false;
			if ((pf.FormatData.PurchaseOptions & E_PurchaseOptions.AutoTableOfContents) == E_PurchaseOptions.AutoTableOfContents && _SectionConfig.MySection.MyContent.Text.ToUpper() != "TABLE OF CONTENTS")
			{
				ppCbIncTOC.Enabled = true;
				ppCbIncTOC.Checked = _SectionConfig.Section_TOC == "Y";
				if (_SectionConfig.MySection.MySectionInfo.MyDocStyle.IncludeInTOC)
				{
					ppCbIncTOC.Text = "Exclude from Table of Contents";
					gpTOC.Visible = !ppCbIncTOC.Checked; // show grouping box if including on auto TOC
				}
				else
				{
					ppCbIncTOC.Text = "Include in Table of Contents";
					gpTOC.Visible = ppCbIncTOC.Checked; // show grouping box if including on auto TOC
				}
			}
			if (!_SectionConfig.MySection.MySectionInfo.IsStepSection)
				cbKeepWordDocMargins.Checked = _SectionConfig.Section_WordMargin == "Y";
			if ((pf.FormatData.PurchaseOptions & E_PurchaseOptions.AutoPlacekeeper) == E_PurchaseOptions.AutoPlacekeeper)
			{
				ppCbPlaceKeeper.Text = "Include In Placekeeper";
				ppCbPlaceKeeper.Enabled = _isStepSection;
				if (!_isStepSection && (_SectionConfig.MySection.MySectionInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.Placekeeper) == E_DocStructStyle.Placekeeper)
				{
					//ppCbPlaceKeeper.Text = "Auto Generate Placekeeper";
					//ppCbPlaceKeeper.Enabled = true;
					ppCbPlaceKeeper.Enabled = false;
				}
				if (ppCbPlaceKeeper.Enabled) ppCbPlaceKeeper.Checked = _SectionConfig.Section_Placekeeper == "Y";
			}
			if (pf.FormatData.SectData.PrintPhoneList)
			{
				ppCbPhoneList.Enabled = true;
				ppCbPhoneList.Checked = _SectionConfig.Section_PhoneList == "Y";
			}

			// Handle Default Step Section.  First, this checkbox is only visible if it is
			// a step section & it is the highest level (top, right below procedures).
			ppCbDefaultStepSection.Visible = false;
			if (_isStepSection && _SectionConfig.MySection.MySectionInfo.MyActiveParent.IsProcedure) // B2016-280 - use MyActiveParent because MyParent was sometimes null
			{
				ppCbDefaultStepSection.Visible = true;
				ppCbDefaultStepSection.Checked = _SectionConfig.Section_OriginalSteps == "Y";
				// Use checkbox text to clarify what is case for this section, i.e. is it already
				// the default or can it be set.  Note that this is used when printing of page numbers
				// that use the 'WithSteps' numbering sequence.
				if (_SectionConfig.Section_OriginalSteps == "Y")
				{
					ppCbDefaultStepSection.Text = "This is the Default Step Section"; // C2020-021 add the word "the"
					_isDefaultStepSection = true;
				}
				else
					ppCbDefaultStepSection.Text = "Make this the Default Step Section";
			}
			// Show Replace Words
			ppCbShowRplWords.Visible = false;
			if (_isStepSection && _SectionConfig.MySection.MySectionInfo.MyActiveParent.IsProcedure)
			{
				ppCbShowRplWords.Visible = true;
				ppCbShowRplWords.Checked = _SectionConfig.Section_ShwRplWords == "Y";
				// Use checkbox text to clarify what is case for this section, i.e. is it already
				// the default or can it be set.  Note that this is used when printing of page numbers
				// that use the 'WithSteps' numbering sequence.
				if (_SectionConfig.Section_OriginalSteps == "Y")
				{
					ppCbShowRplWords.Text = "Show Replace Words"; // C2020-021 add the word "the"
					_isDefaultStepSection = true;
				}
				else
					ppCbShowRplWords.Text = "Show Replace Words";
			}

			// if the parent has enhanced documents (and is not an enhanced document, i.e. the test
			// ed.Type != 0 proves that) put up the group panel on the automation tab that allows for setting of 
			// link types (none, title only, content). The radio buttons are only enabled if the section is 
			// NEW (determined by the 'LnkEnh' being empty).
			if (_isStepSection)
			{
				ProcedureInfo pi = ProcedureInfo.Get(_SectionConfig.MySection.MySectionInfo.MyProcedure.ItemID);
				ProcedureConfig picfg = pi.MyConfig as ProcedureConfig;
				bool hasEnh = false;
				if (picfg.MyEnhancedDocuments != null && picfg.MyEnhancedDocuments.Count > 0)
				{
					foreach (EnhancedDocument ed in picfg.MyEnhancedDocuments)
					{
						if (ed.Type != 0)
						{
							checkEnhancedSettings = true;
							hasEnh = true;
							break;
						}
					}
					if (hasEnh)
					{
						grpLnkEnh.Visible = true;
						if (_SectionConfig.Section_LnkEnh == null || _SectionConfig.Section_LnkEnh == "" || _SectionConfig.Section_LnkEnh == "Y")
							rbEnhLnkContents.Checked = true;
						else if (_SectionConfig.Section_LnkEnh == "N")
							rbEnhLnkNo.Checked = true;
						else  // "T" for title:
							rbEnhLnkTitle.Checked = true;
						rbEnhLnkContents.Enabled = rbEnhLnkNo.Enabled = rbEnhLnkTitle.Enabled = (_SectionConfig.Section_LnkEnh == null || _SectionConfig.Section_LnkEnh == "");
					}
					else
						grpLnkEnh.Visible = false;
				}
				else
					grpLnkEnh.Visible = false;
			}
			else
			{
				// for word docs, no enhanced controls should be visible:
				grpLnkEnh.Visible = false;
				ppCbNoDuplexFoldout.Visible = true; // B2019-165 make visible the checkbox to turn off duplex foldout for Word sections
			}
			//C2019-042 a section cannot be a foldout section and the default step section
			cbIsFoldoutSection.Checked = _SectionConfig.Section_IsFoldout == "Y";
			cbIsFoldoutSection.Enabled = !_isDefaultStepSection;
			// B2019-165 check box to turn off adding duplex foldout on back of last Word doc page that does not include foldouts (Byron/Braidwood 11x14 cover/continuous action page
			ppCbNoDuplexFoldout.Checked = _SectionConfig.Section_DontIncludeDuplexFoldout;
			_Initializing = false;
			//_InitialIndex = ppCmbxFormat.SelectedIndex;
		}
		int _InitialIndex = -2;

        private void ppCmbxLibDocFill()
        {
			bool sav_Initializing = _Initializing;
            _Initializing = true;
			bool isLib = false;
			// Only show the Convert To DocX button for non-library MS Word Sections
			if (_SectionConfig.MySection.MyContent.MyEntry!=null && _SectionConfig.MySection.MyContent.MyEntry.MyDocument!=null && (_SectionConfig.MySection.MyContent.MyEntry.MyDocument.LibTitle != null) && (_SectionConfig.MySection.MyContent.MyEntry.MyDocument.LibTitle != "")) isLib = true;
			if (isLib)
			{
				ppBtnConvertToDocX.Visible = false; // Don't allow save as DOCX for libraries documents
				ppBtnCvrtToLibDoc.Text = "Convert this Section To A Non-Library Document";
				lblLibraryDocument.Text = "Library Document";
				superTooltip1.SetSuperTooltip(this.ppBtnCvrtToLibDoc, new DevComponents.DotNetBar.SuperTooltipInfo("Convert To Non-Library Document", "", "This button will convert the current section from a library document to a non-library document",
								null, null, DevComponents.DotNetBar.eTooltipColor.Gray, true, false, new System.Drawing.Size(250, 76)));
			}
			else
			{
				// Only show the Convert To DocX button for RTF MS Word Sections
				if (_SectionConfig.MySection.MyContent.MyEntry.MyDocument != null && _SectionConfig.MySection.MyContent.MyEntry.MyDocument.FileExtension == ".RTF")
				{
					ItemInfo ii = ItemInfo.Get(_SectionConfig.MySection.ItemID);
					if (!ii.IsAutoTOCSection) // Only show the Convert To DocX button for non-Auto Table Of Contents Section
						this.ppBtnConvertToDocX.Visible = true; // Only allow save as DocX for normal word sections when the existing text is RTF.
				}
				else
					this.ppBtnConvertToDocX.Visible = false;
				if (_SectionConfig.MySection.MyContent.MyEntry.MyDocument == null)
					ppBtnCvrtToLibDoc.Visible = false;
				else
				{
					ppBtnCvrtToLibDoc.Text = "Convert this to a Library Document";
					lblLibraryDocument.Text = "Select Library Document";
					superTooltip1.SetSuperTooltip(this.ppBtnCvrtToLibDoc, new DevComponents.DotNetBar.SuperTooltipInfo("Convert To Library Document button", "", "This button will convert the current section to a library document, allowing it t" +
						"o be shared with other procedures.", null, null, DevComponents.DotNetBar.eTooltipColor.Gray, true, false, new System.Drawing.Size(250, 76)));
				}
			}

            DocumentInfoList LibDocList = DocumentInfoList.GetLibraries(true);
			int selindx = -1;
			ppCmbxLibDoc.Items.Clear();
            for (int i = 0; i < LibDocList.Count; i++)
            {
                ppCmbxLibDoc.Items.Add(LibDocList[i].DocumentTitle);
                // see if this lib doc should be the selected index?
				if (isLib && (LibDocList[i].DocID == _SectionConfig.MySection.MyContent.MyEntry.MyDocument.DocID)) selindx  = i;
            }
			if (selindx > -1) ppCmbxLibDoc.SelectedIndex = selindx;
			_Initializing = sav_Initializing;
        }

		#region General tab

		/// <summary>
		/// This is the General button used on the button interface design
		/// </summary>
		/// <param name="sender">object</param>
		/// <param name="e">EventArgs</param>
		private void btnGeneral_Click(object sender, EventArgs e)
		{
			ProcessButtonClick(tiGeneral, btnGeneral);
		}

		#endregion

		#region Format tab
		/// <summary>
		/// This is the Format button used on the button interface design
		/// </summary>
		/// <param name="sender">object</param>
		/// <param name="e">EventArgs</param>
		private void btnFormat_Click(object sender, EventArgs e)
		{
			ProcessButtonClick(tiFormat, btnFormat);
			if (_InitialIndex < -1) _InitialIndex = ppCmbxFormat.SelectedIndex; // save the current format selection (happens here when current section is set to the default format)
		}

		private void SetupPpCmbxSectionType()
		{
			bool myInit = _Initializing;
			// pf will be the current selected format.  If changing formats, then this will differ from the previously
			// selected.  If the format is being reset to default, selectedindex=-1. If this is a change, we'll need
			// to check that there are enough docstyles to map the selected type of section.
			PlantFormat pf = _SectionConfig.MyFormat != null ? _SectionConfig.MyFormat.PlantFormat : _SectionConfig.MyDefaultFormat.PlantFormat;
			if (!_Initializing && ppCmbxFormat.SelectedIndex >= 0)
				pf = FormatInfoList.SortedFormatInfoList[ppCmbxFormat.SelectedIndex].PlantFormat;
			else if (!_Initializing)    // if the format was changed, it may have been set to default.
				pf = _SectionConfig.MyDefaultFormat.PlantFormat;
			_Initializing = true;
			ppCmbxStyleSectionType.DisplayMember = "Name";
			ppCmbxStyleSectionType.ValueMember = "Index";

			// if this has been defined as a step section, only list step section document styles, if
			// a word section, only list word section styles.
			// Also, if changing the format, check to be sure that the section that is selected will map
			// to something valid in the new format, i.e. a section type of word or step sections exist,
			// index-wise in the new format.
			PlantFormat opf = null;
			int oldSelIndx = -1;
			if (!myInit)
			{
				DocStyleList oldDocStyles = null;
				opf = _SectionConfig.MyFormat != null ? _SectionConfig.MyFormat.PlantFormat : _SectionConfig.MyDefaultFormat.PlantFormat;
				if (pf != opf)
				{
					oldDocStyles = new DocStyleList(null);
					foreach (DocStyle ds in opf.DocStyles.DocStyleListActive)
					{
						if (_isStepSection && ds.IsStepSection)
							oldDocStyles.Add(ds);		// find only step section types
						else if (!_isStepSection && !ds.IsStepSection)
							oldDocStyles.Add(ds);	// find only accessory (MS Word) section types
						if (_SectionConfig.SectionType == ds.Index) oldSelIndx = oldDocStyles.Count - 1;
					}
				}
				if (oldSelIndx < 0) oldSelIndx = 0;
			}
			
			DocStyleList newDocStyles = new DocStyleList(null);
			int selindx = -1;
			foreach (DocStyle nds in pf.DocStyles.DocStyleListActive)
			{
				if (_isStepSection && nds.IsStepSection)
					newDocStyles.Add(nds); // add only step section types
				else if (!_isStepSection && !nds.IsStepSection)
					newDocStyles.Add(nds); // add only accessory (MS Word) section types
				if (_SectionConfig.SectionType == nds.Index) selindx = newDocStyles.Count - 1;
			}
			if (selindx < 0) selindx = 0;
			// if changing format, check for valid type (see comment above)
			if (!myInit && pf != opf)
			{
				if (newDocStyles.Count == 0)
				{
					string msg1 = string.Format("A Page Style for the type of section, {0}, is not available in the new format.  You cannot do this operation.",  _isStepSection? "Step Section": "Word Document");
					MessageBox.Show(msg1, "Cannot change to this format");
					return;
				}
				if (oldSelIndx > newDocStyles.Count)
				{
					string msg = string.Format("Since the format has been changed, the section type was also changed to '{0}'.  Verify that it is appropriate and if not, select a new section type.", newDocStyles.GetDocStyleItem(0).Name);
					MessageBox.Show(msg, "Verify section type");
					selindx = 0;
				}
			}
			ppCmbxStyleSectionType.DataSource = newDocStyles;
            if (newDocStyles.Count > 0)
                ppCmbxStyleSectionType.SelectedIndex = selindx;
			ppCmbxStyleSectionType.Refresh();
			ppBtnConvertToDocX.Visible = false;// Set the Convert To DocX button to invisible by default

			if (!_isStepSection)
				ppCmbxLibDocFill(); // set the Convert To DocX button to Visible if appropriate
			_Initializing = myInit;
			if (_isStepSection)
				SetupCheckoffsDropdowns();
		}
		// C2020-003 This is used to sort the checkoff list from the format file
		// if the checkoff has an OrderBy element, then use it for the sorting, otherwise use th checkoff Index element
		private static int CompareCheckoffUsingOrderBy(CheckOff ckf1, CheckOff ckf2)
		{
			if (ckf1.OrderBy == null)
			{
				if (ckf2.OrderBy == null) // neither ckf1 nor ckf2 uses OrderBy index
				{
					if (ckf1.Index > ckf2.Index) return 1; //ckf1 goes before ckf2
					if (ckf1.Index < ckf2.Index) return -1; // ckf1 goes after ckf2
					return 0; //ckf1 and ckf2 have the same index value
				}
				else // ckf1 does not have OrderBy index but ckf2 has OrderBy index
				{
					if (ckf1.Index > ckf2.OrderBy) return 1; //ckf1 goes before ckf2
					if (ckf1.Index < ckf2.OrderBy) return -1; // ckf1 goes after ckf2
					return 0; //ckf1 and ckf2 have the same index value
				}
			}
			else //ckf1 has orderBy
			{
				if (ckf2.OrderBy == null) // ckf1 has OrderBy index but ckf2 does not
				{
					if (ckf1.OrderBy > ckf2.Index) return 1; //ckf1 goes before ckf2
					if (ckf1.OrderBy < ckf2.Index) return -1; // ckf1 goes after ckf2
					return 0; //ckf1 and ckf2 have the same index value
				}
				else // both ckf1 and ckf2 has OrderBy index
				{
					if (ckf1.OrderBy > ckf2.OrderBy) return 1; //ckf1 goes before ckf2
					if (ckf2.OrderBy > ckf1.OrderBy) return -1; // ckf1 goes after ckf2
					return 0; //ckf1 and ckf2 have the same index value
				}
			}
		}
		private List<CheckOff> SectionPropertyCheckOffList = null;
		private Dictionary<int, int> _CheckOffIndex = new Dictionary<int, int>(); // C2020-003 translate the sorted index number to the actual checkoff index
		private void SetupCheckoffsDropdowns()
		{
			if (!_isStepSection) return; // not needed for accessory pages (word attachments)
			bool myInit = _Initializing;
			_Initializing = true;
			PlantFormat pf = _SectionConfig.MyFormat!=null?_SectionConfig.MyFormat.PlantFormat:_SectionConfig.MyDefaultFormat.PlantFormat;
			CheckOffList chkoffList = pf.FormatData.ProcData.CheckOffData.CheckOffList;
			if (chkoffList != null) chkoffList.Sort(CompareCheckoffUsingOrderBy); // C2020-003 sort the checkoff list via the Index and/or OrderBy elements
			CheckOffHeaderList chkoffHeaderList = pf.FormatData.ProcData.CheckOffData.CheckOffHeaderList;
			int maxindx = pf.FormatData.ProcData.CheckOffData.CheckOffList.MaxIndexNoInherit;
			// B2019-013: was crashing on indexer of checkofflist. If there were UCF checkoffs but none in original format, the indexer
			//  was failing for index of 0  (indexer code went through index attribute of xml and was returning null even though there
			//  were items in list).
			_hasSectionCheckoffDefault = false;
			if (chkoffList != null)
			{
				foreach (CheckOff co in chkoffList)
				{
					if (co.MenuItem.ToUpper().Equals("{SECTION DEFAULT}"))
					{
						_hasSectionCheckoffDefault = true;
						break;
					}
				}
			}
			if (chkoffList != null && maxindx > 0 &&
				(pf.FormatData.ProcData.CheckOffData.Menu == "Signoff") || _hasSectionCheckoffDefault)
			{
				if (SectionPropertyCheckOffList!=null)SectionPropertyCheckOffList.Clear();
				SectionPropertyCheckOffList = new List<CheckOff>();
				// Don't put up the first item in the chkoffList, it is '{Section Default}'.
				//for (int i = 1; i < chkoffList.Count; i++)
				int idxcnt = 0;
				int translatedCfgIdx = 0;
				_CheckOffIndex.Clear();
				foreach (CheckOff co in chkoffList)
				{
					if (!co.MenuItem.ToUpper().Equals("{SECTION DEFAULT}"))
					{
						SectionPropertyCheckOffList.Add(co);
						_CheckOffIndex.Add(idxcnt, (int)co.Index); // C2020-003 dictionary of sorted indexes to format checkoff Index element
						if (_SectionConfig.Section_CheckoffListSelection == co.Index)
							translatedCfgIdx = idxcnt; // C2020-003 translate the previous checkoff select to the sorted checkoff list position
						idxcnt++;
					}
				}
				ppGpbxSignoffCheckoff.Enabled = true;
				ppCmbxCheckoffType.DataSource = SectionPropertyCheckOffList;
				ppCmbxCheckoffType.SelectedIndex = translatedCfgIdx; // C2020-003 save the actual checkoff index
			}
			else
			{
				ppGpbxSignoffCheckoff.Enabled = false;
			}
			if (chkoffHeaderList != null && chkoffHeaderList.MaxIndex > 1)
			{
				lblCheckoffHeading.Enabled = true;
				ppCmbxCheckoffHeading.Enabled = true;
				ppCmbxCheckoffHeading.DataSource = chkoffHeaderList;
				// B2019-100: the checkoffselection may be larger than number in the list if elements of list were made inactive from UCF. Adjust as necessary:
				if (_SectionConfig.Section_CheckoffHeaderSelection >= ppCmbxCheckoffHeading.Items.Count)
					ppCmbxCheckoffHeading.SelectedIndex = -1;
				else
					ppCmbxCheckoffHeading.SelectedIndex = _SectionConfig.Section_CheckoffHeaderSelection;
			}
			else
			{
				lblCheckoffHeading.Enabled = false;
				ppCmbxCheckoffHeading.Enabled = false;
			}
			_Initializing = myInit;
		}

		private void ppBtnDefaultFmt_Click(object sender, EventArgs e)
		{
			bool foundMatch = false;
			bool isWordSection = rbWordSect.Checked;
			FormatInfo dfi = _SectionConfig.MyDefaultFormat;
			// check to see if the default format has a similar document style
			// if it does not, then do not allow the selection of the default format
			foreach (DocStyle ds in dfi.PlantFormat.DocStyles.DocStyleList)
			{
				if (ds.IsStepSection != isWordSection) foundMatch = true;
			}
			if (foundMatch)
			{
				_Initializing = true;
				ppCmbxFormat.SelectedIndex = -1; //reset to the default Format setting
				_Initializing = false;
				SetupPpCmbxSectionType();
			}
			else
			{
				string suffix = "format ";
				if (_DefaultFormatName.ToUpper().Contains("FORMAT")) suffix = "";
				MessageBox.Show(string.Format("{0}\n\n{1}does not support {2} section type", _DefaultFormatName, suffix, isWordSection ? "MS Word" : "Step"), "Incompatible Format", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
			}
		}

		private void ppCmbxFormat_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (_Initializing)
			{
				// determine if the default button and the default description text should visable
				ppBtnDefaultFmt.Visible = !(ppCmbxFormat.SelectedValue == null || ppCmbxFormat.SelectedIndex == -1);
				ppLblFormatDefault.Visible = ppCbShwDefSettings.Checked && ppBtnDefaultFmt.Visible;
				return;
			}
			if (_InitialIndex < -1) _InitialIndex = ppCmbxFormat.SelectedIndex; // save the current format selection (happens here when current section format is not the default section)
			if (ppCmbxFormat.SelectedIndex > -1)  // B2017-016 selectedindex of -1 means the default format was selected
			{
				PlantFormat pf = FormatInfoList.SortedFormatInfoList[ppCmbxFormat.SelectedIndex].PlantFormat;
				// If the selected format does not have a docstyle compatable with the section
				// then reset the format selection back to what it was
				if (!ValidPlantFormat(pf))
				{
					_Initializing = true;
					ppCmbxFormat.SelectedIndex = _InitialIndex; // reset the format selection to what it was
					ppBtnCancel.Focus(); // this will force the property page to refresh
					_Initializing = false;
					return;
				}
			}
			if ((ppCmbxFormat.SelectedIndex != -1) && _DefaultFormatName != null && _DefaultFormatName.Equals(ppCmbxFormat.SelectedValue))
			{
				ppBtnDefaultFmt.Focus();
				ppBtnDefaultFmt.PerformClick();
			}
			// determine if the default button and the default description text should visable
			ppBtnDefaultFmt.Visible = !(ppCmbxFormat.SelectedValue == null || ppCmbxFormat.SelectedIndex == -1);
			ppLblFormatDefault.Visible = ppCbShwDefSettings.Checked && ppBtnDefaultFmt.Visible;
			//if (!didDefault) SetupPpCmbxSectionType();
			SetupPpCmbxSectionType();
            // B2017-272 disable/enable the Steps and Word radio buttons based on the section types defined in the format
            //           and the type of an existing section or if we are creating a new section.
            CheckAvaibleSectionTypes();
		}

		//  This function is used when the user selects different format for a give section.
		//	It will verify that the newly selected format contains a document style (docstyle)
		//	compatable with the that section. (i.e. if the section is a Word section, the selected format has Word section docstyle)
				private bool ValidPlantFormat(PlantFormat pf)
				{
                    bool foundMatch = false;
                    bool isWordSection = rbWordSect.Checked;
					foreach (DocStyle ds in pf.DocStyles.DocStyleList)
					{
						if (ds.IsStepSection != isWordSection) foundMatch = true;
					}
					if (foundMatch)
						return true; // valid format
					string suffix = "format ";
					if (ppCmbxFormat.SelectedValue.ToString().ToUpper().Contains("FORMAT")) suffix = "";
					MessageBox.Show(string.Format("{0}\n\n{1}does not support {2} section type", ppCmbxFormat.SelectedValue, suffix, isWordSection ? "MS Word" : "Step"), "Incompatible Format", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
					return false;
				}

        private void ppCmbxStyleSectionType_SelectedValueChanged(object sender, EventArgs e)
        {
            if (_Initializing) return;
            if (ppCmbxStyleSectionType.SelectedValue != null)
                _SectionConfig.SectionType = (int)(ppCmbxStyleSectionType.SelectedValue);
        }

		#endregion

		#region Library Document tab

		/// <summary>
		/// This is the Library Document button used on the button interface design
		/// </summary>
		/// <param name="sender">object</param>
		/// <param name="e">EventArgs</param>
		private void btnLibDocs_Click(object sender, EventArgs e)
		{
			ProcessButtonClick(tiLibDoc, btnLibDocs);
		}
		private void ppBtnCvrtToLibDoc_Click(object sender, EventArgs e)
		{
			// Double Check that this is not a step section, if so just return.
			if (_isStepSection) return;
			// If current section is library document, user selected to convert to non-library document.  If
			// this is the case, data from lib doc must be copied to new document and the section must point
			// to id. 
			if (ppBtnCvrtToLibDoc.Text.IndexOf("Non") > 0)        // convert to a 'non' library.
			{
				ItemInfo ii = ItemInfo.Get(_SectionConfig.MySection.ItemID);
				DocumentInfo doclibinfo = ii.MyContent.MyEntry.MyDocument;
				doclibinfo.RefreshDocumentEntries();	// B2018-126 & B2018-133: Refresh for library document usage change
				// if just one usage (this one), then just convert this to a non-library document.  If there are more
				// than one usage, make a copy so that the rest of the usages still point to the library document.
				if (doclibinfo.DocumentEntryCount == 1)
					_SectionConfig.MySection.MyContent.MyEntry.MyDocument.LibTitle = null;
				else
				{
					// make new document with 'no' libtitle - use libtitle for the doc title.  Then link this
					// to the item...
					Document doc = Document.MakeDocument(null, doclibinfo.DocContent, doclibinfo.DocAscii, doclibinfo.Config,doclibinfo.FileExtension);
					_SectionConfig.MySection.MyContent.MyEntry.MyDocument = doc;
				}
				// B2018-126 & B2018-133: Refresh for library document usage change
				_SectionConfig.MySection.MyContent.MyEntry.MyDocument.Save();
				DocumentInfo docinfo = DocumentInfo.Get(_SectionConfig.MySection.MyContent.MyEntry.MyDocument.DocID);
				docinfo.RefreshDocumentEntries();

				ppCmbxLibDoc.Items.Clear();
				ppCmbxLibDoc.WatermarkEnabled = true;
				ppBtnCvrtToLibDoc.Text = "Convert this to a Library Document";
				superTooltip1.SetSuperTooltip(this.ppBtnCvrtToLibDoc, new DevComponents.DotNetBar.SuperTooltipInfo("Convert To Library Document button", "", "This button will convert the current section to a library document, allowing it t" +
						"o be shared with other procedures.", null, null, DevComponents.DotNetBar.eTooltipColor.Gray, true, false, new System.Drawing.Size(250, 76)));
				return;
			}
			// If current section is not a library document, it is either a new section or the user selected the 
			// button to convert it to a library document.  Check for this, if new, just attach to document.  
			else if (_SectionConfig.MySection.MyContent.MyEntry.MyDocument == null)
			{
				// if nothing was selected, give message & return
				if (ppCmbxLibDoc.SelectedIndex == -1)
				{
					MessageBox.Show("Must select a library document");
					return;
				}
				int docid = -1;
				DocumentInfoList LibDocList = DocumentInfoList.GetLibraries(true);
				for (int i = 0; i < LibDocList.Count; i++)
				{
					if (LibDocList[i].LibTitle == (string)ppCmbxLibDoc.Items[ppCmbxLibDoc.SelectedIndex])
					{
						docid = LibDocList[i].DocID;
						break;
					}
				}
				if (docid == -1) return;
				using (Document dc = Document.Get(docid))
				{
					_SectionConfig.MySection.MyContent.MyEntry.MyDocument = dc;
				}
			}
			else
			// if converting to library document, just put 'text' into the 'LibTitle' property (that's what flags
			// it to be a library document.
			{
				_SectionConfig.MySection.MyContent.MyEntry.MyDocument.LibTitle = _SectionConfig.MySection.MyContent.Text;
				// Save now so that it shows up in the library document list in the ppcmbxlibdoc (combo box
				// listing lib docs that is regenerated in ppCmbxLibDocFill)
				_SectionConfig.MySection.MyContent.MyEntry.MyDocument.Save();
				ppCmbxLibDocFill();
				ppCmbxLibDoc.Enabled = false;
			}
			ppBtnCvrtToLibDoc.Text = "Convert this Section To A Non-Library Document";
			lblLibraryDocument.Text = "Library Document";
			superTooltip1.SetSuperTooltip(this.ppBtnCvrtToLibDoc, new DevComponents.DotNetBar.SuperTooltipInfo("Convert To Non-Library Document", "", "This button will convert the current section from a library document to a non-library document",
				null, null, DevComponents.DotNetBar.eTooltipColor.Gray, true, false, new System.Drawing.Size(250, 76)));
		}

		private void ppCmbxLibDoc_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (_Initializing) return;

			// first check if this is a 'new' section - if so, then just return.
			if (_SectionConfig.MySection.MyContent.MyEntry == null) return;
			// see if this was NOT a library document.  If it is not a library document, ask the user if 
			// it should be linked, thus losing the original text/data.
			if (_SectionConfig.MySection.MyContent.MyEntry.MyDocument != null && !(_SectionConfig.MySection.MyContent.MyEntry.MyDocument.LibTitle != ""))
			{
				_SectionConfig.MySection.MyContent.MyEntry.MyDocument = Document.New();
				if (ppCmbxLibDoc.SelectedIndex > -1)
				{
					if (MessageBox.Show("Linking to this library document will cause loss of data to this section.  Do you want to continue?", "Link", MessageBoxButtons.YesNo) == DialogResult.Yes)
					{
						_DocumentToDelete = _SectionConfig.MySection.MyContent.MyEntry.MyDocument;
						DocumentInfoList LibDocList = DocumentInfoList.GetLibraries(true);
						_SectionConfig.MySection.MyContent.MyEntry.MyDocument = Document.Get(LibDocList[ppCmbxLibDoc.SelectedIndex].DocID);
						ppBtnCvrtToLibDoc.Enabled = true;
					}
					else
					{
						ppCmbxLibDoc.SelectedIndex = -1;
						ppBtnCvrtToLibDoc.Enabled = false;
					}
				}

			}
			//else if (_SectionConfig.MySection.MyContent.MyEntry.MyDocument == null)
			//{
			//    // was creating a new document & selected to connect it to a libdoc
			//    _DocumentToDelete = _SectionConfig.MySection.MyContent.MyEntry.MyDocument;
			//}
			else
			{
				// it already is a library document, just change usages...
				DocumentInfoList LibDocList = DocumentInfoList.GetLibraries(true);
				if (ppCmbxLibDoc.SelectedIndex >= 0 && ppCmbxLibDoc.SelectedIndex < LibDocList.Count)
				{
					_SectionConfig.MySection.MyContent.MyEntry.MyDocument = Document.Get(LibDocList[ppCmbxLibDoc.SelectedIndex].DocID);
					ppBtnCvrtToLibDoc.Enabled = true;
				}
				else
				{
					throw new Exception(string.Format("Index Out Of Range Index = {0}, Count = {1}", ppCmbxLibDoc.SelectedIndex, LibDocList.Count));
				}
			}
		}
		#endregion

		#region View Settings tab

		/// <summary>
		/// This is the View Settings button used on the button interface design
		/// </summary>
		/// <param name="sender">object</param>
		/// <param name="e">EventArgs</param>
		private void btnAutomation_Click(object sender, EventArgs e)
		{
			ProcessButtonClick(tiAutomation, btnAutomation);
		}

		#endregion

		#region Generic functions used on this property page

		/// <summary>
		/// Determines what labels (showing default values) are visable on the property pages
		/// </summary>
		private void defaultSettingsVisiblity()
		{
			//ItemInfo ii = ItemInfo.Get(_SectionConfig.MySection.ItemID);
			ppLblDefSettingsInfo.Visible = ppCbShwDefSettings.Checked;
			ppLblFormatDefault.Visible = ppCbShwDefSettings.Checked && ppBtnDefaultFmt.Visible;
			ppLblDefaultNumColumns.Visible = _isStepSection && ppCbShwDefSettings.Checked && ppBtnDefaultNumColumns.Visible;
			ppBtnDefaultNumColumns.Visible = _isStepSection && ppBtnDefaultNumColumns.Visible;  // bug fix B2016-241 something was sometimes setting this to true for Word sections
			ppLblDefPaginationStyle.Visible = _isStepSection && ppCbShwDefSettings.Checked && ppBtnDefaultPaginationStyle.Visible;
			ppBtnDefaultPaginationStyle.Visible = _isStepSection && ppBtnDefaultPaginationStyle.Visible; // bug fix B2016-241 insurence based on DefaultNumColumns sometimes set to true
			//ppLblDefaultPrintSize.Visible = !_isStepSection && ppCbShwDefSettings.Checked && ppBtnDefaultPrintSize.Visible;

		}

		/// <summary>
		/// For the Button Interface property page style, when a button is selected (pressed),
		/// it will remain in the checked state even when a different button is selected.  Thus
		/// we must clear the checked state of the buttons when a button is selected, then set
		/// the newly selected button's state to checked.
		/// </summary>
		private void ClearAllCheckedButtons()
		{
			btnGeneral.Checked = false;
			btnFormat.Checked = false;
			btnLibDocs.Checked = false;
			btnAutomation.Checked = false;
		}

		/// <summary>
		/// Select the corresponding tab and set the button's state to checked
		/// </summary>
		/// <param name="tab">Property Page Tab</param>
		/// <param name="button">Corresponding Property Page Button</param>
		private void ProcessButtonClick(TabItem tab, ButtonX button)
		{
			ClearAllCheckedButtons();
			tcSectionProp.SelectedTab = tab;
			button.Checked = true;
		}

		/// <summary>
		/// This is a generic Enter Event function for use with all of the property page tabs.
		/// Found that the visiblity value of buttons is not recorded until the property page in which it resides is diplayed.
		/// Thus we need to call defaultSettingVisiblity() to check and set visiblity states.
		/// </summary>
		/// <param name="sender"> type object</param>
		/// <param name="e">type EventArgs</param>
		private void tabpage_Enter(object sender, EventArgs e)
		{
			// Show or hide the labels containing the default values
			//if (!_Initializing) // jsj 1-23-2017 was not showing default check upon property page entry
				defaultSettingsVisiblity();
		}
		/// <summary>
		/// Process a change in the combo box selection
		/// </summary>
		/// <param name="cmbx">Combo Box Name</param>
		/// <param name="defstr">string containing default text</param>
		/// <param name="button">button to reset to default value</param>
		/// <param name="deflabel">label containing the default</param>
		private void ProcessCmbxSelectedValueChange(ComboBoxEx cmbx, string defstr, ButtonX button, Label deflabel)
		{
			if ((cmbx.SelectedIndex != -1) && defstr != null && defstr.Equals(cmbx.SelectedValue))
			{
				button.Visible = true;
				button.Focus();
				button.PerformClick();
			}
			button.Visible = (cmbx.SelectedValue != null);
			deflabel.Visible = (ppCbShwDefSettings.Checked) && button.Visible;
		}
		/// <summary>
		/// Process a change in the enum combo box selection
		/// </summary>
		/// <param name="cmbx">Combo Box Name</param>
		/// <param name="defstr">the default enum value</param>
		/// <param name="button">button to reset to default value</param>
		/// <param name="deflabel">label containing the default</param>
		private void ProcessCmbxSelectionEnumChanged(ComboBoxEx cmbx, object enumval, ButtonX button, Label deflabel)
		{
			if ((cmbx.SelectedIndex != -1) &&
				cmbx.SelectedValue.Equals(enumval))
			{
				bool sav_Initializing = _Initializing;
				_Initializing = true;
				button.Visible = true;
				button.Focus();
				button.PerformClick();
				cmbx.SelectedIndex = -1; // This will hide the Default button
				_Initializing = sav_Initializing;
			}
			//button.Visible = ((!_FolderConfig.Name.Equals("VEPROMS")) && (cmbx.SelectedValue != null));
			button.Visible = ((cmbx.SelectedValue != null) && (cmbx.SelectedIndex >= 0));
			deflabel.Visible = ppCbShwDefSettings.Checked && button.Visible;
		}
		#endregion

		private void ppSectNumberStpRTB_Enter(object sender, EventArgs e)
		{
			_MyStepTabRibbon.MyStepRTB = ppSectNumberStpRTB;
		}

		private void ppSectTitleStpRTB_Enter(object sender, EventArgs e)
		{
			_MyStepTabRibbon.MyStepRTB = ppSectTitleStpRTB;
		}

		private void ShowAvailableOptionsForSectionType()
		{
			lblColumns.Visible = _isStepSection;
			ppCmbxNumColumns.Visible = _isStepSection;
			lblPagination.Visible = _isStepSection;
			ppCmbxSectPagination.Visible = _isStepSection;
			//lblPrintSize.Visible = !_isStepSection;
			//ppCmbxAccPgPrintSize.Visible = !_isStepSection;
			ppGpbxSignoffCheckoff.Visible = _isStepSection;
			cbKeepWordDocMargins.Visible = !_isStepSection;
			ppCbDefaultStepSection.Visible = _isStepSection;
			ppCbShowRplWords.Visible = _isStepSection;
		}

		private void rbStepSect_CheckedChanged(object sender, EventArgs e)
		{
			_isStepSection = rbStepSect.Checked;
			rbWordSect.Checked = !rbStepSect.Checked;
			if (!_Initializing)
			{
				SetupPpCmbxSectionType();
				ShowAvailableOptionsForSectionType();
				tcpLibDoc.Enabled = !_isStepSection;
			}
		}

		private void ppCmbxSectPagination_SelectedValueChanged(object sender, EventArgs e)
		{
			SectionConfig.SectionPagination secpgn = (SectionConfig.SectionPagination)Enum.Parse(typeof(SectionConfig.SectionPagination), _DefaultPaginationStyle);
			ProcessCmbxSelectionEnumChanged(ppCmbxSectPagination, secpgn, ppBtnDefaultPaginationStyle, ppLblDefPaginationStyle);
			tcpFormat.Focus();
		}

		private void ppCmbxNumColumns_SelectedValueChanged(object sender, EventArgs e)
		{
			SectionConfig.SectionColumnMode seccols = (SectionConfig.SectionColumnMode)Enum.Parse(typeof(SectionConfig.SectionColumnMode), _DefaultNumColumns);
			ProcessCmbxSelectionEnumChanged(ppCmbxNumColumns, seccols, ppBtnDefaultNumColumns, ppLblDefaultNumColumns);
			tcpFormat.Focus();
		}

		//private void ppCmbxAccPgPrintSize_SelectedValueChanged(object sender, EventArgs e)
		//{
		//    SectionConfig.AttPrintSize attsize = (SectionConfig.AttPrintSize)Enum.Parse(typeof(SectionConfig.AttPrintSize), _DefaultPrintSize);
		//    ProcessCmbxSelectionEnumChanged(ppCmbxAccPgPrintSize, attsize, ppBtnDefaultPrintSize, ppLblDefaultPrintSize);
		//}

		private void ppBtnDefaultPaginationStyle_Click(object sender, EventArgs e)
		{
			// Get the parent setting
			SectionConfig.SectionPagination secpgn = (SectionConfig.SectionPagination)Enum.Parse(typeof(SectionConfig.SectionPagination), _DefaultPaginationStyle);
			// Compare parent setting with current setting
			if (secpgn != _SectionConfig.Section_Pagination)
				_SectionConfig.Section_Pagination = secpgn; // this will force a database update (write)
			ppCmbxSectPagination.SelectedIndex = -1;//reset to the default Section Pagination Style setting
			tcpFormat.Focus();
		}

		private void ppBtnDefaultNumColumns_Click(object sender, EventArgs e)
		{
			// Get the parent setting
			SectionConfig.SectionColumnMode seccols = (SectionConfig.SectionColumnMode)Enum.Parse(typeof(SectionConfig.SectionColumnMode), _DefaultNumColumns);
			// Compare parent setting with current setting
			if (seccols != _SectionConfig.Section_ColumnMode)
				_SectionConfig.Section_ColumnMode = seccols; // this will force a database update (write)
			ppCmbxNumColumns.SelectedIndex = -1;//reset to the default Number of Columns setting
			tcpFormat.Focus();
		}

		private void frmSectionProperties_Shown(object sender, EventArgs e)
		{
			ppSectNumberStpRTB.Focus();
		}

		private void ppCbEditableData_CheckedChanged(object sender, EventArgs e)
		{
			bool isEditable = ppCbEditableData.Checked;
			if (!_Initializing)
				_SectionConfig.SubSection_Edit = isEditable ? "Y" : "N";
		}

		private void ppCbPrnSecNumTitle_CheckedChanged(object sender, EventArgs e)
		{
			bool isEditable = ppCbPrnSecNumTitle.Checked;
			if (!_Initializing)
				_SectionConfig.Section_PrintHdr = isEditable ? "Y" : "N";
		}
		private void ppCbAutoIndent_CheckedChanged(object sender, EventArgs e)
		{
			bool isEditable = ppCbAutoIndent.Checked;
			if (!_Initializing)
				_SectionConfig.SubSection_AutoIndent = isEditable ? "Y" : "N";
		}
		private void ppCbIncTOC_CheckedChanged(object sender, EventArgs e)
		{
			bool isInToc = (_SectionConfig.MySection.MySectionInfo.MyDocStyle.IncludeInTOC) ? !ppCbIncTOC.Checked : ppCbIncTOC.Checked;
			if (!_Initializing)
				_SectionConfig.Section_TOC = ppCbIncTOC.Checked ? "Y" : "N";
			gpTOC.Visible = isInToc;
		}

		private void ppCmbxCheckoffHeading_SelectedIndexChanged(object sender, EventArgs e)
		{
			int selindx = ppCmbxCheckoffHeading.SelectedIndex;
			if (!_Initializing)
				_SectionConfig.Section_CheckoffHeaderSelection = selindx;
		}

		private void cbKeepWordDocMargins_CheckedChanged(object sender, EventArgs e)
		{
			bool doWordMargin = cbKeepWordDocMargins.Checked;
			if (!_Initializing)
				_SectionConfig.Section_WordMargin = doWordMargin ? "Y" : "N";
		}

		private void ppCbPlaceKeeper_CheckedChanged(object sender, EventArgs e)
		{
			if (!_Initializing)
				_SectionConfig.Section_Placekeeper = ppCbPlaceKeeper.Checked ? "Y" : "N";
		}

		private void ppCbPhoneList_CheckedChanged(object sender, EventArgs e)
		{
			if (!_Initializing)
				_SectionConfig.Section_PhoneList = ppCbPhoneList.Checked ? "Y" : "N";
		}

		private void ppCbDefaultStepSection_CheckedChanged(object sender, EventArgs e)
		{
			if (!_Initializing)
			{
				// B2019-002: if there is more than one default step section (probably from migrated data), then allow this to be turned off.
				//	The bug was on changing a transition type that included a section header - but the section header was not included
				//	in the transition text if it was a default:
				int cntDefaultSect = 0;
				string defSectDesc = "";
				string curSectDesc = "";
				foreach (SectionInfo si in _SectionConfig.MySection.MySectionInfo.MyProcedure.Sections)
				{
					SectionConfig sc = si.MyConfig as SectionConfig;
					if (sc != null && sc.Section_OriginalSteps == "Y")
					{
						cntDefaultSect++;
						if (cntDefaultSect == 1) defSectDesc = string.Format("{0} {1}", sc.Number, sc.Title).Trim(); // get default section name - used in Warning message if another section is checked to be default
					}
					if (si.ItemID == _SectionConfig.MySection.ItemID) curSectDesc = string.Format("{0} {1}", sc.Number, sc.Title).Trim();
				}
				if (!ppCbDefaultStepSection.Checked) //user un-checked the default section box
				{
					if (cntDefaultSect == 1)
					{
						// B2020-007: Don't allow the user to unselect the Default Step Section.  Give the user a message and turn the check
						// box back on.  The way to change the default section will be to check the box for the default section to change to.
						// That will bring up a dialog asking the user if they want to change the default section (see the next 'else')
						MessageBox.Show("One section MUST be set as the 'Default Step Section'.\n\nTo make another section the 'Default Step Section',\n select the checkbox on the Properties of that section.", "WARNING");
						_Initializing = true;
						ppCbDefaultStepSection.Checked = true;
						_Initializing = false;
					}
				}
				else // user checked the default section box
				{
					if (cntDefaultSect != 0)
					{
						// Note that this just sets the config item - it does not save it.  Save is 
						// done when the 'OK' button is clicked.  At that time, if this section's
						// Section_OriginalSteps is set, then all other sections will need to have this
						// property cleared (Only 1 section can be the OriginalStep section)
						string msg = string.Format("Only one section can be set as the 'Default Step Section'. '{0}' is currently the default.\n\nDo you want to make '{1}' the Default?", defSectDesc, curSectDesc);
						if (MessageBox.Show(msg, "WARNING", MessageBoxButtons.YesNo) == DialogResult.No)
						{
							_Initializing = true;
							ppCbDefaultStepSection.Checked = false; // reset the check box back to unchecked
							_Initializing = false;
						}
					}
				}
				//C2019-042 a section cannot be a foldout section and the default step section
				cbIsFoldoutSection.Enabled = !ppCbDefaultStepSection.Checked; // disable the foldout checkbox if this is the default step section
				_SectionConfig.Section_OriginalSteps = ppCbDefaultStepSection.Checked ? "Y" : "N";
			}
		}
	
			private void ppBtnConvertToDocX_Click(object sender, EventArgs e)
		{
			// Get Document as file
			ItemInfo ii = ItemInfo.Get(_SectionConfig.MySection.ItemID);
			DocumentInfo doclibinfo = ii.MyContent.MyEntry.MyDocument;
			DSOFile myfile = new DSOFile(doclibinfo);
			// When trying to fix this , the update of the document waas causing a CSLA crash so I switched
			// to make document
			//using (Document myDoc = doclibinfo.Get())
			//{
			// Open MSWord App
				LBWordLibrary.LBApplicationClass ap = new LBWordLibrary.LBApplicationClass();
				LBWordLibrary.LBDocumentClass doc = ap.Documents.Open(myfile.FullName);
				string filename = myfile.FullName.ToUpper().Replace(".RTF", ".DOCX");
				doc.SaveAs(filename, LBWordLibrary.LBWdSaveFormat.wdFormatXMLDocument);  // Convert to DocX
				doc.Close();
				ap.Quit();
				FileInfo fi = new FileInfo(filename);
				FileStream fs = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);// B2016-053
				long len = fs.Length;
				byte[] ByteArray = new byte[len];
				int nBytesRead = fs.Read(ByteArray, 0, (int)len);
				fs.Close();
				Document myDoc = Document.MakeDocument(null, ByteArray, doclibinfo.DocAscii, doclibinfo.Config, ".DOCX");
				_SectionConfig.MySection.MyContent.MyEntry.MyDocument = myDoc;
				_SectionConfig.MySection.MyContent.MyEntry.Save();
				//myDoc.DocContent = ByteArray;
				//myDoc.FileExtension = ".DOCX";
				//myDoc.Save();
				fi.Delete();// Cleanup afterwards
				ppBtnConvertToDocX.Visible = false; // Hide the button after the execution is complete.
			//}
		}

		private void ppCmbxFormat_DropDown(object sender, EventArgs e)
		{
			_Initializing = true;
			// C2017-004 - if using the default format, position the dropdown to the default format
			if (ppCmbxFormat.SelectedIndex == -1)
				ppCmbxFormat.SelectedValue = _DefaultFormatName;
			_Initializing = false;
		}

		private void ppCmbxFormat_DropDownClosed(object sender, EventArgs e)
		{
			// upon exit of the dropdown if the default format is selected - click the Default button
			if ((string)(ppCmbxFormat.SelectedValue) == _DefaultFormatName)
			{
				ppBtnDefaultFmt.PerformClick();
				ppCmbxStyleSectionType.Focus();
			}
		}

		//C2019-042 added check box to identify a Foldout Section
		private void cbIsFoldoutSection_CheckedChanged(object sender, EventArgs e)
		{
			// don't allow a foldout section be the default step section
			ppCbDefaultStepSection.Enabled = !cbIsFoldoutSection.Checked;
			_SectionConfig.Section_IsFoldout = (cbIsFoldoutSection.Checked) ? "Y" : "N";
		}

		// B2019-165 check box added to Automation tab to prevent a duplex foldout from
		//           being printed on the back of the last page of the Word document that does not include duplex foldouts
		private void ppCbNoDuplexFoldout_CheckedChanged(object sender, EventArgs e)
		{
			_SectionConfig.Section_DontIncludeDuplexFoldout = ppCbNoDuplexFoldout.Checked;
		}
			// C2029-025 Show or hide replace words.  Can highlight replace words in editor.
		private void ppCbShowRplWords_CheckedChanged(object sender, EventArgs e)
		{
			if (!_Initializing)
			{
				_SectionConfig.Section_ShwRplWords = ppCbShowRplWords.Checked ? "Y" : "N";
			}
		}

		//private void ppBtnDefaultPrintSize_Click(object sender, EventArgs e)
		//{
		//    // Get the parent setting
		//    SectionConfig.AttPrintSize attsize = (SectionConfig.AttPrintSize)Enum.Parse(typeof(SectionConfig.AttPrintSize), _DefaultPrintSize);
		//    // Compare parent setting with current setting
		//    if (attsize != _SectionConfig.Section_AttachmentPrintSize)
		//        _SectionConfig.Section_AttachmentPrintSize = attsize; // this will force a database update (write)
		//    ppCmbxAccPgPrintSize.SelectedIndex = -1;//reset to the default Accessory page Print Size setting
		//    tcpFormat.Focus();
		//}
	}
}