//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// OptionsMiscAlternate.cs//\\//\\//\\//\\//\\//
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// Global Access Software InTernational//\\//
// Copyrighted (c)2013 by John P. Edwards/\\//\\
// *** Sunday, July 21, 2013 8:01:09 AM/\\//\\//
// M Saturday, July 27, 2013 10:45:09 PM//\\//\\
// ReSharper7 Approved by -JpE- v1.4.1.2x\//\\//
// Friday, August 09, 2013 11:19:04 PM\\//\\//\\
// Friday, July 25, 2014 08:25 PM/\\//\\//\\//
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// Split out from OptionsMisc.cs\\//\\//\\//\\//
// v4.6.7.76 Jan 28 2017 Isolated to here!\\//\\
// This Source File is like 150 Lines atm.//\\//
// Including the Comments and Design Ideas\\//\\
// and everything else roughed except that//\\//
// The HelpButtonClick is pretty finished \\//\\
// codewise. Just need to complete that file\\//
// v4.6.7.78 Jan 30 2017 in Design Phase. \\//\\
// v4.6.7.87 Feb 09 2017 Early Alpha 1st phase./
// v4.6.7.95 Feb 11 2017 Alpha-Beta Stages. //\\
// I am working on the ListBox Hovers or trying/
// v4.6.7.98 Feb 11 2017 Everything works 4 AFF\
// But it's not yet hooked up to anything in IF/
// v4.6.8.23 Feb 27 2017 Touching Up Final. //\\
// v4.6.8.43 Mar 15 2017 Reworked MoveExisting./
// v4.6.9.63 Mar 26 Added "Select File" to\\//\\
// Context Menu Items along with supporting/\\//
// Methods. Tests Very Well Indeed.\//\\//\\//\\
// v4.6.9.64 Added Context Menu Item that\//\\//
// Lets the User Select a New Reports Folder//\\
// For this Data Folder. Mar 26 2017\\//\\//\\//
// v4.6.9.76 Mar 30 2017//\\//\\//\\//\\//\\//\\
// v4.6.9.77 Mar 30 Upgraded to ObjectModel!\\//
// Context Menu for Data Folders improved with\\
// v4.6.9.82 Mar 31 2017 File Print Options.\\//
// v4.6.9.87 Apr 04 2017 UpGraded Context Menus!
// v4.7.0.04 Apr 12 2017 More On The End there!
// v4.7.0.07 Apr 14 2017 Finishing ^ & DoW-Mods.
// v4.7.1.24 Apr 20 Integration & Consolidation.
// v4.7.1.31 Apr 22 Added List Restore Contexts.
// v4.7.1.35 Apr 24 and perfected them & all.
// v4.7.2.53 May 05 Restore methods almost done.
// v4.7.2.61 May 09 Backup methods nearly done.
// v4.7.3.65 May 11 Nearly Clear, Final Testing.
// v4.7.3.77 May 17 ViewAllPrefs & ViewAllAss.
// Revamped Overloads and such for DisplayResults
// & DisplayResults() to work with ViewALL-Mods.
// v4.7.3.78 Added the lil Quick-Launch Feature!
// Resources straightened out and a new Icon for
// the QS & fixed & organized right all around.
// v4.7.3.85 Adds AYS to MinVerb YesNo's, etc.
// Perfecting MoveUp-Data & Testing all more.
// v4.7.3.93 May 30 2017 Better Default Mods
// for the Selector index mods.
// v4.7.3.96 May 31 2017 Fixed ViewAllAss!
// v4.7.5.19 12Jun17 Caps a lot of mods here
// including the Backup/Restore for Both Lists
// and all the called methods therefor. i.e.
// The Big 4 and Supporting Methods Regions.
// and mostly in AppCode4 for the RecNum stuff.
// OMA now @ 2776 Lines! BackupListsAuto added.
// BLA is called from AppCode2.Restore4() now
// as part of the Scheduled Maintenance now.
// v4.7.5.20 12Jun Integration & Wipe Testings.
// v4.7.5.25 14Jun Split the Big 4 n2 the Big 2!
// with a few specific methods & reUses mostly.
// v4.7.5.28 Final Details of Formatting Code
// Files and make as readable as possible.
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// "NameSpaces" Included.
using System;
using System.IO;
using System.Linq;
using System.Drawing;
using System.Collections;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
// Code File "Aliases" to shorten.
using IF = WhoAreYou.InfoForm;
using AST = WhoAreYou.AppStatic;
using APS = WhoAreYou.Properties.AppSettings;
using OPS = WhoAreYou.Properties.OptionsSettings;
using AUS = WhoAreYou.Properties.AppUserSettings;
using ORS = WhoAreYou.Properties.OptionsResources;
using PMS = WhoAreYou.Properties.PrintMasterSettings;
namespace WhoAreYou
{
public partial class OptionsForm // <-= NOTE!
{
#region Alternate Folder Finder
/* Design Ideas and other imagineering:
* ************************************
* Okay, so like this Region and Methods herein are all about the
* AlternateFolderFinder or AFF. The ListBoxs will Allow a Collection
* of Paths to be Stored. So I need to "hook" it into the
* Data and Reports TextBoxes without altering anything there,
* but to Collect those paths, anytime there is a new one.
*
* So then, I'll need to compare those to Entries and so on.
* And I'll need Settings to store the Collections and retrieve them, etc.
*
* Then, when there is a Collection of at least the Current few we can know that
* the paths are valid or they wouldn't be in the Data or ReportsTextBox.Text!
*
* Initial Values are the good old AppDir+"\\" + Home and...
* AppDir + "\\" + Home + "\\" + Reports
* that the App defaults-to on startup and so forth. (AppCode4.cs)
*
* Then DataSelect Button Click or Double Mouse Click on the Selected Index
* will simply put that Entry into the Data or ReportsTextBox.text, etc.
*
* Also, maybe, if the Open Button is Clicked when a Listbox Item is
* highlighted, it opens that folder. ***See Context Menu Items***
*
* Then I guess Clicking the Select Button will basically put the Selected
* index item into the DataTextBox.Text (or Reports L8r) and do the same
* basic things as happen after the folderBrowser Dialog; PopulateListBoxes, etc.
* SelectedPath returns to top of list, right below default.
*
* -JpE- (I totally love this phase when there's so much potential
* and ideas are flowing freely and merging into real concepts and code.)
* Feb 01-15 2017
* Apr 04 2017 and nearly 1,000 lines of code later. IT'S FUCKING WONDERFUL!
* Much more than I'd originally envisioned, with the new Context Menu Item
* UpDates, at the Bottom, and so forth that all tie into everything nicely.
* Great Job on Creating, Designing, Writing, Testing and Upgrading Integrations.
*/
#region Collection Methods
/// <summary> Add initial default paths to BOTH Collections.
/// Called Once for Data Path, once for Reports Path.
/// called from OptionsFormLoad(); each instance if count
/// is less than 2.
/// </summary>
/// <param name="dataPath"></param>
private void AddDefaultsToPathCollectionsLocal(bool dataPath)
{
AddDefaultsToPathCollections(dataPath);
PopulateListBoxes();
}
/// <summary> Add initial default paths to BOTH Collections.
/// True for Data Path, False for Reports Path.
/// as of v4.7.1.24 Apr 20 2017, ReUsed by AppCode5 Class.
/// </summary>
/// <param name="dataPath"></param>
public static void AddDefaultsToPathCollections(bool dataPath)
{
// adds defaults to initial collections...
string path;
// true if DataCollection, false if ReportsCollection.
if (dataPath.Equals(true))
{
path =
AUS.Default.AppDir +
"\\" + APS.Default.Home;
OPS.Default.dataListBoxItems.Add(path);
}
else
{
path =
AUS.Default.AppDir +
"\\" + APS.Default.Home +
"\\" + PMS.Default.Reports;
OPS.Default.reportsListBoxItems.Add(path);
}
OPS.Default.Save();
// doesn't have to be created, just added to as a Setting.
}
private void AddToPathCollection(string path, bool which)
{
AddToPathCollectionPublic(path, which);
PopulateListBoxes(); // NOTE! Only difference locally.
}
/// <summary> Grabs the current path to see...
/// if it's in the collection and adds it to the
/// pertinent collection when it isn't already there.
/// sender == true is DataList, sender == false is ReportsList.
/// </summary><param name="path"></param>
/// <param name="which"></param>
public static void AddToPathCollectionPublic(string path, bool which)
{
if (which.Equals(true))
{
if (CheckForItem(path, true).Equals(false))
{
// check if collection is full then delete least used if it is...
SizeCollection(true);
if (OPS.Default.dataListBoxItems.Count > 1)
{
OPS.Default.dataListBoxItems.Insert(1, path);
}
else OPS.Default.dataListBoxItems.Add(path);
}
else // otherwise it already exists and we...
{
MoveExistingItemTo2NdInList(path, true);
}
}
else // If path ^v is NOT already in collection, add it.
{
if (CheckForItem(path, false).Equals(false))
{
SizeCollection(false);
if (OPS.Default.reportsListBoxItems.Count > 1)
{
OPS.Default.reportsListBoxItems.Insert(1, path);
}
else OPS.Default.reportsListBoxItems.Add(path);
}
else // otherwise it already exists and we...
{
MoveExistingItemTo2NdInList(path, false);
}
}
OPS.Default.Save();
}
/// <summary> Item is already in the collection,
/// move it to 2nd Unless already 1st or 2nd(default);
/// (i.e. Index 0 or 1 in the List.) -ed
/// Leaves 0 and 1 alone, no changes needed.
/// true to access dataListBoxItems,
/// false to access reportsListBoxItems. -JpE-
/// </summary>
/// <param name="path"></param>
/// <param name="which"></param>
private static void MoveExistingItemTo2NdInList(string path, bool which)
{
// Find index of Item and move it to Position 1.
// If which is true it's Data Path, if false it's Reports.
if (which.Equals(true))
{
if (OPS.Default // clone 2 of 3 v4.6.8.43
.dataListBoxItems.IndexOf(path) < 2) return;
if (OPS.Default.dataListBoxItems.Count > 1)
{
OPS.Default.dataListBoxItems.Remove(path);
OPS.Default.dataListBoxItems.Insert(1, path);
}
else OPS.Default.dataListBoxItems.Add(path);
}
else // NOTE: Default is always kept at Position Zero.
{
if (OPS.Default // clone 3 of 3
.reportsListBoxItems.IndexOf(path) < 2) return;
if (OPS.Default.reportsListBoxItems.Count > 1)
{
OPS.Default.reportsListBoxItems.Remove(path);
OPS.Default.reportsListBoxItems.Insert(1, path);
}
else OPS.Default.reportsListBoxItems.Add(path);
}
//OPS.Default.Save();
}
/// <summary> Removes Items Beyond Default Item Count.
/// p = true is Data, p = false is Reports.
///
/// v4.7.1.25 Apr 21 2017
/// Makes Count = 49 thus 50 paths stored. (see AppSettings)
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
private static void SizeCollection(bool p)
{
if (p.Equals(true)) // Data Code Path.
{
var count = OPS.Default.dataListBoxItems.Count;
if (count > APS.Default.Count)
{
OPS.Default.dataListBoxItems.RemoveAt(count - 1);
} // Remove Last Path in List if Collection is "full."
}
else // Reports Code Path.
{
var count = OPS.Default.reportsListBoxItems.Count;
if (count > APS.Default.Count) // testswell! // > 4
{
OPS.Default.reportsListBoxItems.RemoveAt(count - 1);
}
}
}
/// <summary> return false if path is NOT already in collection.
/// If path "is" already in collection forget it, return true.
/// </summary>
/// <param name="path"></param>
/// <param name="which"></param>
/// <returns></returns>
private static bool CheckForItem(string path, bool which)
{
// if check is false, it is not in the collection.
if (which.Equals(true)) // it's a Data Path.
{
if (OPS.Default.dataListBoxItems.Contains(path)) return true;
}
else // it's a Reports Path.
if (OPS.Default.reportsListBoxItems.Contains(path)) return true;
return false;
}
#endregion Collection Methods
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Action Methods
private void PopulateListBoxes()
{
OPS.Default.Save();
// Initialize and Populate both ListBoxes with appropriate collections.
var hasno = false;
var invalid = new Collection<string>();
dataListBox.Items.Clear();
reportsListBox.Items.Clear();
if (OPS.Default.dataListBoxItems.Count < 1)
AddDefaultsToPathCollectionsLocal(true);
if (OPS.Default.reportsListBoxItems.Count < 1)
AddDefaultsToPathCollectionsLocal(false);
IF.CheckBothFolderCollections(); // <-= v4.7.1.33
foreach (var item in OPS.Default.dataListBoxItems)
{
if (!ValidateItem(item, true))
{
hasno = true;
invalid.Add(item);
continue;
}
dataListBox.Items.Add(item);
}
dataListBox.SelectedIndex = OPS.Default.dataListBoxItems // v4.7.0.03
.IndexOf(OPS.Default.dataListBoxItems.Contains(PreviouslySelectedDir1)
? PreviouslySelectedDir1 : OPS.Default.PrefRootDir);
if (hasno) RemoveInvalidFolders(true, invalid);
hasno = false;
invalid.Clear();
// And do similarly for reportsListBox.Items.
if (OPS.Default.reportsListBoxItems.Count < 1)
{
OPS.Default.reportsListBoxItems
.Add(ReportsTextBox.Text);
OPS.Default.Save();
}
foreach (var item in OPS.Default.reportsListBoxItems)
{
if (!ValidateItem(item, false))
{
hasno = true;
invalid.Add(item);
continue;
}
reportsListBox.Items.Add(item);
}
reportsListBox.SelectedIndex = OPS.Default.reportsListBoxItems // v4.7.0.03
.IndexOf(OPS.Default.reportsListBoxItems.Contains(PreviouslySelectedDir2)
? PreviouslySelectedDir2 : OPS.Default.PrefReportsDir);
if (hasno) RemoveInvalidFolders(false, invalid);
}
/// <summary> Select Previously Selected Index Mods; Set Previous.
/// v4.7.0.03 v PSD1&2C vars Used Above ONLY. Set to Prefs on FormLoad.
/// These EVENT Handlers are called on changes and these vars only change herein.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SelectedIndex1Change(object sender, EventArgs e)
{
PreviouslySelectedDir1 =
dataListBox.SelectedItem.ToString();
}
private void SelectedIndex2Change(object sender, EventArgs e)
{
PreviouslySelectedDir2 =
reportsListBox.SelectedItem.ToString();
}
private void RemoveInvalidFolders
(bool data, ICollection<string> list)
{
if (list.Count < 1) return;
var default1 = OPS.Default.dataListBoxItems[0];
var default2 = OPS.Default.reportsListBoxItems[0];
if (data)
{
if (list.Contains(default1)) list.Remove(default1);
foreach (var item in list)
OPS.Default.dataListBoxItems.Remove(item);
}
else
{
if (list.Contains(default2)) list.Remove(default2);
foreach (var item in list)
OPS.Default.reportsListBoxItems.Remove(item);
}
PopulateListBoxes();
}
/// <summary> Verify Folder Exists and
/// in the case of DataFolder, that data files exist.
/// </summary>
/// <param name="item"></param>
/// <param name="path"></param>
/// <returns></returns>
private static bool ValidateItem(string item, bool path)
{
var test = false;
if (path.Equals(true)) // Data Folder.
{
if (Directory.Exists(item)
&& HasDataFiles(item)) test = true;
}
else // Reports Folder.
{
if (Directory.Exists(item)) test = true;
}
return test;
}
/// <summary> Make Sure Data Folder has data files.
/// Rev v4.7.1.24 April 20 2017 and made public.
/// </summary>
/// <param name="folder"></param>
/// <returns></returns>
public static bool HasDataFiles(string folder)
{
return
(from file in Directory.EnumerateFiles(folder)
let extension = Path.GetExtension(file)
where !string.IsNullOrEmpty(extension)
&& !string.IsNullOrEmpty(file)
where extension.Equals(APS.Default.Ext)
&& !file.Contains("Bac_")
&& !file.Contains(APS.Default._drf)
&& !file.Equals(APS.Default.NewFile)
select extension).Any();
}
private void DataSelectButtonClick(object sender, EventArgs e)
{
var path = dataListBox.Text;
// NOTE: Every time a Path is reSelected, it needs be put back on top.
var test = OPS.Default.dataListBoxItems.IndexOf(path);
if (test > 1) // if default path or 2nd leave it alone.
{
MoveExistingItemTo2NdInList(path, true);
}
// Now put that path into the dataTextBox.Text and Save Changes.
folderBrowser.SelectedPath = path;
DataChanges();
}
private void ReportsSelectButtonClick
(object sender, EventArgs e)
{
var path = reportsListBox.Text;
var test = OPS.Default.reportsListBoxItems.IndexOf(path);
if (test > 1) MoveExistingItemTo2NdInList(path, false);
folderBrowser.SelectedPath = path;
ReportsChanges();
}
#endregion Action Methods
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Context Menu Items
/* DOC:
* \\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
* The Context Menu 1 items and true args are DataFolder
* Specific and the Context Menu 2 items and false args
* are Reports Folder Specific throughout.
*
* NOTE: Numerous Updates were done after the initial code.
* See notes and Docs for each Below.
* \\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
*/
#region Original Context Menu Items
private void ViewToolStrip1MenuItemClick(object sender, EventArgs e)
{
MessageBox.Show(dataListBox.SelectedItem.ToString());
}
private void OpenToolStrip1MenuItemClick(object sender, EventArgs e)
{
if (!OPS.Default.MiniVerb && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog("Open This Folder?")) return;
var folder = dataListBox.SelectedItem.ToString();
AST.OpenFolder(folder);
}
private void RemoveToolStrip1MenuItemClick(object sender, EventArgs e)
{
var item = dataListBox.SelectedIndex;
if (item.Equals(0))
{
MessageBox.Show(ORS.OF_Remove);
return;
}
if (item.Equals(1))
{
MessageBox.Show(ORS.OF_Reselect);
return;
}
if (!OPS.Default.MiniVerb)// && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(string.Format(
"Remove this Folder from the List?\n{0}",
dataListBox.Items[item]))) return;
OPS.Default.dataListBoxItems.RemoveAt(item);
PopulateListBoxes();
}
private void ClearToolStrip1MenuItemClick(object sender, EventArgs e)
{
var test = OPS.Default.dataListBoxItems.Count;
if (test < 2) return; // Keep The Default.
if (!OPS.Default.MiniVerb)// && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog("Clear This Entire List?")) return;
OPS.Default.dataListBoxItems.Clear();
AddDefaultsToPathCollectionsLocal(true);
DataTextBox.Text =
OPS.Default.dataListBoxItems[0];
}
private void OpenToolStrip2MenuItemClick(object sender, EventArgs e)
{
if (OPS.Default.reportsListBoxItems.Count < 2) return;
if (!OPS.Default.MiniVerb && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog("Open This Folder?")) return;
var folder = reportsListBox.SelectedItem.ToString();
AST.OpenFolder(folder);
}
private void RemoveToolStrip2MenuItemClick(object sender, EventArgs e)
{
var item = reportsListBox.SelectedIndex;
if (item.Equals(0))
{
MessageBox.Show(ORS.OF_Remove);
return;
}
if (item.Equals(1))
{
MessageBox.Show(ORS.OF_Reselect);
return;
}
if (!OPS.Default.MiniVerb)
if (!AST.YesNoDialog(string.Format(
"Remove this Folder from the List?\n{0}",
reportsListBox.Items[item]))) return;
OPS.Default.reportsListBoxItems.RemoveAt(item);
PopulateListBoxes();
}
private void ClearToolStrip2MenuItemClick(object sender, EventArgs e)
{
if (OPS.Default.reportsListBoxItems.Count < 2) return;
// ^ Keep The Default.
if (!OPS.Default.MiniVerb) //&& !OPS.Default.AreYouSure
if (!AST.YesNoDialog("Clear This Entire List?")) return;
OPS.Default.reportsListBoxItems.Clear();
AddDefaultsToPathCollectionsLocal(false);
ReportsTextBox.Text = OPS.Default.reportsListBoxItems[0];
}
private void ViewToolStripMenuItem2Click(object sender, EventArgs e)
{
MessageBox.Show(reportsListBox.SelectedItem.ToString());
}
#endregion Original Context Menu Items
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region v4.6.9.67 Mar 27 2017
private void SelectFileToolStrip1MenuItemClick
(object sender, EventArgs e)
{
if (!OPS.Default.MiniVerb && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(
"Select a Data File for this Folder?")) return;
// Now do it!
var dir = dataListBox.SelectedItem.ToString();
if (!Directory.Exists(dir) || !HasDataFiles(dir))
{ PopulateListBoxes(); return; }
var files = GetDataFileList(dir);
// v4.7.3.93 May 30 2017 vvvvvvv
var index = 0;
var test = GetPrefFileName(dir);
if (files.Contains(test))
index = files.IndexOf(test);
else
if (files.Contains(OPS.Default.PrefFileName))
index = files.IndexOf(OPS.Default.PrefFileName);
else
if (files.Contains(AUS.Default.FileName))
index = files.IndexOf(AUS.Default.FileName);
else
if (files.Contains(PMS.Default.Bac_PrefFileName))
index = files.IndexOf(PMS.Default.Bac_PrefFileName);
else
if (files.Contains(APS.Default.defaultFilename))
index = files.IndexOf(APS.Default.defaultFilename);
// Selected index Mods ^^^^^^^^^
var size = AUS.Default.OMA_FileSelect_Size;
var location = AUS.Default.OMA_FileSelect_Location;
var choice = SelectOne(files, ref size, ref location, "", index);
AUS.Default.OMA_FileSelect_Size = size;
AUS.Default.OMA_FileSelect_Location = location;
AUS.Default.Save();
if (string.IsNullOrEmpty(choice)
|| !File.Exists(dir + "\\" + choice)) return;
if (OPS.Default.dataListBoxItems.IndexOf(dir).Equals(1))
{ OPS.Default.PrefFileName = FileName = choice; }
RememberThis2(choice, dir);
if (!OPS.Default.MiniVerb) Feedback();
}
private static void Feedback()
{
const string
text = "Your Preferences Have Been Saved.";
MessageBox.Show(text);
}
/// <summary> Get List of strings of DataFile Names
/// That Exist on this particular Directory. Linq vers.
/// </summary>
/// <returns></returns>
public static Collection<string> GetDataFileList(string folder)
{
#region Was
//// optimized only after testing and noting original.
//var list = new List<string>();
//foreach (var file in Directory.EnumerateFiles(
// OPS.Default.PrefRootDir))
//{
// var name = Path.GetFileName(file);
// var extension = Path.GetExtension(file);
// if ( string.IsNullOrEmpty(extension)
// || string.IsNullOrEmpty(name)
// || !extension.Equals(APS.Default.Ext)
// || name.Contains(APS.Default._drf)
// || name.Equals(APS.Default.NewFile)
// || name.Contains("Bac_")) continue;
// list.Add(name);
//}
//return list;
//// Converted to Linq it's...
#endregion Was
return
new Collection<string>((from file in Directory.EnumerateFiles(folder)
let name = Path.GetFileName(file)
let extension = Path.GetExtension(file)
where !string.IsNullOrEmpty(extension)
&& !string.IsNullOrEmpty(name)
&& extension.Equals(APS.Default.Ext)
&& !name.Contains(APS.Default._drf)
&& !name.Equals(APS.Default.NewFile)
&& !name.Contains("Bac_")
select name).ToList());
}
// write file to dir indicating pref Filename for this Dir.
private static void RememberThis2(string filename, string dir)
{
var
contents =
filename +
"\n" + GetStoredReportsDirPref(dir) +
"\nOMA_RememberThis2();";
var
file = dir + "\\" + APS.Default.PrefFile;
File.WriteAllText(file, contents);
}
// Get it & put it right back in with different filename.
private static string GetStoredReportsDirPref(string dir)
{
var pref = OPS.Default.PrefReportsDir;
var file = dir + "\\" + APS.Default.PrefFile;
if (File.Exists(file))
{
var path = File.ReadAllText(file).Split('\n')[1];
// grabs second line of file only.
if (!path.Contains("()")
&& !path.Contains(";")
&& Directory.Exists(path)
) pref = path;
}
return pref;
}
// v4.6.9.67 Mar 27 2017
private void SelectReportsFolderToolStrip1MenuItemClick
(object sender, EventArgs e)
{
if (!OPS.Default.MiniVerb && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(
"Select a Reports Folder" +
" for this Data Folder?")) return;
var dir = dataListBox.SelectedItem.ToString();
var list = OPS.Default.reportsListBoxItems;
var relist = new Collection<string>(); // <-= v4.6.9.77!
foreach (var path in list) // Convert from Specialized String Collection
{ relist.Add(path); } // to a Generic ObjectModel.Collection<T>
// SelectorForm Use and Example thereof.
// v4.7.3.95 Index Mods extended to these.
var index = 0;
var test = GetStoredReportsDirPref(dir);
if (relist.Contains(test))
index = relist.IndexOf(test);
else
if (relist.Contains(OPS.Default.PrefReportsDir))
index = relist.IndexOf(OPS.Default.PrefReportsDir);
else
if (relist.Contains(PMS.Default.ReportsFolder))
index = relist.IndexOf(PMS.Default.ReportsFolder);
// else default to the index[0] default.
// ^ v4.7.3.93 May 30 2017
const string text = "Select a Reports Folder:";
var size = AUS.Default.OMA_ReportsSelect_Size;
var locate = AUS.Default.OMA_ReportsSelect_Location;
var selected = SelectOne(relist, ref size, ref locate, text, index);
AUS.Default.OMA_ReportsSelect_Size = size;
AUS.Default.OMA_ReportsSelect_Location = locate;
AUS.Default.Save();
if (string.IsNullOrEmpty(selected)) return;
// v4.6.9.87 Apr 04 2017 - All Four Possibles Tested.
// If it's the default data dir it moves the pref reports
// folder to the 2nd-position* or leaves it alone if it's the
// default or pref reports dir already. (*2nd in the list, index[1].)
if (dir.Equals(OPS.Default.PrefRootDir))
{
if (selected != list[0])
{
MoveExistingItemTo2NdInList(selected, false);
PopulateListBoxes();
}
ReportsTextBox.Text =
PreviouslySelectedDir2 =
OPS.Default.PrefReportsDir = selected;
}
RememberThis3(selected, dir);
if (!OPS.Default.MiniVerb) Feedback();
}
// write file to dataDir indicating selected ^
private void RememberThis3
(string selectedReportsDir, string dataDir)
{
var
contents = GetPrefFileName(dataDir) +
"\n" + selectedReportsDir +
"\n" + "OMA_RememberThis3();";
var
prefFile = dataDir + "\\" +
APS.Default.PrefFile;
File.WriteAllText(prefFile, contents);
}
// Get it & put it right back in ^ with different Reports Pref.
private string GetPrefFileName(string dir)
{
var pref = FileName; // as default value.
var file = dir + "\\" + APS.Default.PrefFile;
if (File.Exists(file))
{
var name = File.ReadAllText(file).Split('\n')[0];
// Reads First Line of File Only. ^
if (!string.IsNullOrEmpty(name)
&& File.Exists(dir + "\\" + name)) pref = name;
}
return pref;
}
#endregion v4.6.9.67 Mar 27 2017
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Upgrade 4.6.9.87 Apr 04 2017
/* Upgrade adds two context menu items, to each context menu,
* For Move-Up & Move-Down of selected item. 1st item cannot
* be moved. 2nd Item cannot be moved. If 3rd item is moved to 2nd
* then we prompt them to make this the prefFolder or back out,
* leaving things be. Only if 3rd item is moved up AND made the pref
* does the 2nd (Pref) item fall to 3rd. Nothing can be moved higher than
* 2nd, the default stays on top no matter what. The pref is 2nd no matter
* what, except if default path. The bottom item cannot be moved down.
* Folder must exist. Data folders must contain data files.
*/
/// <summary> The ProtoType For All The Below.
/// Event handler for the Move Up Context Menus. Item
/// selected is moved up the list unless already 1st or 2nd.
/// If 3rd is moved up it requires approval to become Pref.
///
/// See Called Methods below, some shared and so forth.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MoveUpToolStrip1MenuItemClick(object sender, EventArgs e)
{ // Data Collection
if (dataListBox.Items.Count < 3)
{
MessageBox.Show(ORS.OMA_MoveItem);
return; // Remove Short Lists from the equation.
}
var dir = dataListBox.SelectedItem.ToString();
if (!Directory.Exists(dir) || !HasDataFiles(dir))
{
OPS.Default.dataListBoxItems.Remove(dir);
PopulateListBoxes();
MessageBox.Show(string.Format(
"The Directory:\n{0}\n\nDoes NOT Exist, or Data Files\n" +
" could no longer be found on it.\n\n" +
"It was removed from the list.", dir));
return; // Eliminate Non Existent Folders.
}
var index = OPS.Default.dataListBoxItems.IndexOf(dir);
if (index < 2)
{ MessageBox.Show(ORS.OMA_Cannot); return; }
if (index.Equals(2))
{ // 3rd Item needs approval to move up.
if (!MakeThisThePreference(dir, true)) return;
}
// A Last Chance to Abort.
if ( !OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure
&& !index.Equals(2))
if (!AST.YesNoDialog(ORS.OMA_Up)) return;
// Now do it!
MoveData(true, index);
if (index.Equals(2))
{
// Make it the Pref
folderBrowser.SelectedPath = dir;
DataChanges();
}
else
PopulateListBoxes();
}
private void MoveUpToolStrip2MenuItemClick(object sender, EventArgs e)
{
// Reports Collection
if (reportsListBox.Items.Count < 3)
{
MessageBox.Show(ORS.OMA_MoveItem);
return; // Remove Short Lists from the equation.
}
var dir = reportsListBox.SelectedItem.ToString();
if (!Directory.Exists(dir))
{
OPS.Default.reportsListBoxItems.Remove(dir);
PopulateListBoxes();
MessageBox.Show(string.Format(
"The Directory:\n{0}\n\n" +
"Does NOT Exist and was removed from the list.", dir));
return; // Eliminate Non Existent Folders.
}
var index = OPS.Default.reportsListBoxItems.IndexOf(dir);
if (index < 2) { MessageBox.Show(ORS.OMA_Cannot); return; }
if (index.Equals(2))
{ // 3rd Item needs approval to move up.
if (!MakeThisThePreference(dir, false)) return;
}
// A Last Chance to Abort.
if ( !OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure
&& !index.Equals(2))
if (!AST.YesNoDialog(ORS.OMA_Up)) return;
// Now do it!
MoveReports(true, index);
if (index.Equals(2))
{
// Making it the Pref if now 2nd in List.
folderBrowser.SelectedPath = dir;
ReportsChanges();
}
else
PopulateListBoxes();
}
/// <summary> Event Handler for Move Down Context Menu Item
/// This version for the Data List. Clone below for Reports.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MoveDownToolStrip1MenuItemClick(object sender, EventArgs e)
{
// Data Collection
var count = dataListBox.Items.Count;
if (count < 3)
{ // Remove Short Lists from the equation.
MessageBox.Show(ORS.OMA_MoveItem);
return;
}
var dir = dataListBox.SelectedItem.ToString();
if (!Directory.Exists(dir) || !HasDataFiles(dir))
{
OPS.Default.dataListBoxItems.Remove(dir);
MessageBox.Show(string.Format(
"The Directory:\n{0}\n\nDoes NOT Exist, or Data Files\n" +
" could no longer be found on it.\n\n" +
"It was removed from the list.", dir));
return; // Eliminate Non Existent Folders.
}
var index = OPS.Default.dataListBoxItems.IndexOf(dir);
if (index < 2)
{
MessageBox.Show(ORS.OMA_Cannot);
return; // Remove Items 1 and 2 from the equation. ^
}
if (index + 1 == count)
{
MessageBox.Show(ORS.OMA_Last);
return; // Can't Move Last item Down Msg.
}
if (!OPS.Default.MiniVerb && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(ORS.OMA_Down)) return;
// Last Chance to BackOut.
// And finally, if everything above checks out, Move it.
MoveData(false, index);
PopulateListBoxes();
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// Design Algorithm - Graphic for Move Down visualization.
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// index[0] = item1 can't be moved. ***Handled***
// index[1] = item2 can't be moved. ***Handled***
// index[2] = item3 can be moved down, by removing and inserting.
// index[N] = itemN etc, etc. ^^^ ^^^^^^^^^^^^^^^^^^
// index[N] = by removing and inserting ***Handled*** v
// index[N] by removing and inserting ***Handled*** v for N iterations.
// index[x] = item-x 3rd from End can be moved, by removing and inserting.
// index[y] = item-y 2nd from End can be moved, by removing & ADDING ONLY! ***OK***
// index[z] = item-z Last item can't be moved down. ***Handled***
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
private void MoveDownToolStrip2MenuItemClick(object sender, EventArgs e)
{
// Reports Collection
var count = reportsListBox.Items.Count;
if (count < 3)
{ // Remove Short Lists from the equation.
MessageBox.Show(ORS.OMA_MoveItem);
return;
} // <-= Show msg, do Nothing. ^
var dir = reportsListBox.SelectedItem.ToString();
if (!Directory.Exists(dir))
{
OPS.Default.reportsListBoxItems.Remove(dir);
MessageBox.Show(string.Format(
"The Directory:\n{0}\n\nDoes NOT Exist, or Data Files\n" +
" could no longer be found on it.\n\n" +
"It was removed from the list.", dir));
return; // Eliminate Non Existent Folders.
}
var index = OPS.Default.reportsListBoxItems.IndexOf(dir);
if (index < 2)
{
MessageBox.Show(ORS.OMA_Cannot);
return; // Remove Items 1 and 2 from the equation.
}
if (index + 1 == count)
{
MessageBox.Show(ORS.OMA_Last);
return; // Can't Move Last item Down Msg.
}
if (!OPS.Default.MiniVerb && !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(ORS.OMA_Down)) return;
// Last Chance to BackOut if Not MiniVerb or AYS.
// And finally, if everything above checks out, Move it.
MoveReports(false, index);
PopulateListBoxes();
}
/// <summary> Moves Data List Items Up or Down.
/// Clone below does the same for the Reports List.
/// </summary>
/// <param name="up"></param>
/// <param name="index"></param>
private static void MoveData(bool up, int index)
{
var add = false;
var dir = OPS.Default.dataListBoxItems[index];
var count = OPS.Default.dataListBoxItems.Count;
OPS.Default.dataListBoxItems.RemoveAt(index);
if (up) index--;
else
{ // if down...
if (index + 2 == count) add = true;
index++; // ^ 2nd to last has to be added not inserted. v
}
if (add) OPS.Default.dataListBoxItems.Add(dir);
else OPS.Default.dataListBoxItems.Insert(index, dir);
}
private static void MoveReports(bool up, int index)
{
var add = false;
var dir = OPS.Default.reportsListBoxItems[index];
var count = OPS.Default.reportsListBoxItems.Count;
OPS.Default.reportsListBoxItems.RemoveAt(index);
if (up) index--;
else
{ // down...
if (index + 2 == count) add = true;
index++;
}
if (add) OPS.Default.reportsListBoxItems.Add(dir);
else OPS.Default.reportsListBoxItems.Insert(index, dir);
}
/// <summary> Specialized Dialog Gets Approval for Preference Setting.
/// Used by both Reports and Data Move Up Methods. Not needed in down.
/// </summary>
/// <param name="dir"></param>
/// <param name="data"></param>
/// <returns></returns>
private static bool MakeThisThePreference(string dir, bool data)
{
// New conditional v4.7.3.83
if (OPS.Default.MiniVerb) return true;
const string title =
"Make This the Preference?";
var text = "Your New Reports Directory Preference.";
if (data) text = "Your New Data-Directory-Preference.";
return
MessageBox.Show(string.Format(
"This will make:\n{0}\n\n" + text +
"\n\nAre You Sure?", dir), title,
MessageBoxButtons.YesNo,
MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2
).Equals(DialogResult.Yes);
}
#endregion Upgrade 4.6.9.87 Apr 04 2017
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Upgrade v4.7.1.23 Upgrade SubSection Apr 19 2017
private void RestoreOldPrefsClick(object sender, EventArgs e)
{
if (!OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(
"Bring Back All preference files?")) return;
var pref = APS.Default.PrefFile;
foreach (var item in
OPS.Default.dataListBoxItems)
{
if (!Directory.Exists(item)) continue;
var source = item + "\\" + "old" + pref;
if (!File.Exists(source)) continue;
var destin = item + "\\" + pref;
if (File.Exists(destin))
{
if ( !OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(
"Replace Existing preference file?"))
continue;
File.Delete(destin);
}
File.Move(source, destin);
}
}
private void WipePrefsClick(object sender, EventArgs e)
{
int mover;
bool preserver;
if (!OPS.Default.MiniVerb)// && !OPS.Default.AreYouSure)
{
const string
text1 = "Clear ALL preference files from entire\n" +
"Data Folder collection?",
text2 = "This is not recommended.\n\n" +
"Do you really need to start fresh?",
text3 = "Do you want to preserve the\n" +
"preferences for the default Directory?",
text4 = "Rename instead of Delete,\n" +
"So they can be restored if needed?";
if (!OPS.Default.AreYouSure)
if (!AST.YesNoDialog(text1)) return;
if (!AST.YesNoDialog(text2)) return;
preserver = OPS.Default.AreYouSure
|| AST.YesNoDialog(text3);
mover = AST.YesNoDialog(text4) ? 1 : 0;
} // v made reUsable v4.7.1.23br
else { preserver = true; mover = 1; }
BackupPreferences(preserver, mover, false);
}
private void
BackupAllPrefsToolStripMenuItemClick
(object sender, EventArgs e)
{
if (!OPS.Default.MiniVerb)
if (!AST.YesNoDialog(
"Backup ALL preference files,\nOver Writing " +
"any previous backups...\n\nAre You Sure?")) return;
BackupPreferences(false, 2, true);
ShowResult(2);
}
/// <summary> This 1 overload is not really connected
/// to the others of nearly the same name here, which are,
/// for the most part, interconnected and cross dependant.
/// </summary>
/// <param name="moveIt"></param>
private static void ShowResult(int moveIt)
{
if (OPS.Default.MiniVerb) return;
var msg = "";
if (moveIt < 0
|| moveIt > 2) msg = "Error in OMA!";
if (moveIt.Equals(0)) msg = "All Preference Files Have Been Deleted.";
if (moveIt.Equals(1)) msg = "All Preference Files Have Been ReNamed.";
if (moveIt.Equals(2)) msg = "All Preference Files Have Been Backed up.";
MessageBox.Show(msg);
}
/// <summary> ReWritten to accomodate both of the above calls, etc.
/// v4.7.1.23 Apr 19 2017 Could be called elsewhere:
/// Also Called from Restore3() if Scheduled Maint is due.
/// </summary>
/// <param name="preserve"></param>
/// <param name="moveIt"></param>
/// <param name="auto"></param>
public static void
BackupPreferences(bool preserve, int moveIt, bool auto)
{
var pref = APS.Default.PrefFile;
foreach (var dir in OPS.Default
.dataListBoxItems.Cast<string>()
.Where(Directory.Exists))
{
if (preserve.Equals(true))
{ preserve = false; continue; }
var source = dir + "\\" + pref;
var destin = dir + "\\" + "old" + pref;
if (!File.Exists(source)) continue;
if (File.Exists(destin))
{
if ( !OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure
&& !auto)
if (!AST.YesNoDialog(
"Delete old preference backup?"))
continue;
File.Delete(destin);
}
if (moveIt == 0) File.Delete(source);
if (moveIt == 1) File.Move(source, destin);
if (moveIt == 2) File.Copy(source, destin);
}
if (!auto) ShowResult(moveIt);
}
#endregion subregion v4.7.1.23 Upgrade SubSection
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Upgrade 4.7.3.73 Updates older & adds new "View-All Options".
// ContextMenuStrip1 Item for Data Dirs.
private void ViewPrefsToolStrip1MenuItemClick(object sender, EventArgs e)
{
const string
text1 = "The Reports Folder Associated with this Data Folder is:",
text2 = "The File Name Associated with this Data Folder is:";
string
dir = dataListBox.SelectedItem.ToString(),
text3 = "",
test1 = OPS.Default.PrefRootDir,
filename = GetPrefFileName(dir),
reports = GetStoredReportsDirPref(dir);
if (dir.Equals(test1)) text3 =
"\nThis is your Currently Preferred Folder and Data File.";
var msg = string.Format(
text1 + "\n{0}\n\n" + text2 + "\n{1}\n" + text3,
reports, filename);
DisplayResults(msg,"");
}
// Upgrade v4.7.3.71 May 17 2017,
// Similar to above but foreach item in DataListBox.
private void ViewAllPrefsClick(object sender, EventArgs e)
{
const string
title = "View ALL Preferences:",
text1 = "The Reports Folder Associated with this Data Folder is:",
text2 = "The File Name Associated with this Data Folder is:";
var text = "";
var pref = OPS.Default.PrefRootDir;
var list = OPS.Default.dataListBoxItems;
foreach (var dir in list)
{
var top = string.Format("Results for:\n{0}\n\n", dir);
var msg = "";
if (dir.Equals(pref)) msg =
"This is your Currently Preferred Folder and Data File.\n\n";
msg = top + msg;
text += string.Format(msg + text1 +
"\n{0}\n\n" + text2 + "\n{1}\n\n\n",
GetStoredReportsDirPref(dir), GetPrefFileName(dir));
}
var size = AUS.Default.OMA_D1_Size;
var loca = AUS.Default.OMA_D1_Loca;
DisplayResults(text, title, ref size, ref loca);
AUS.Default.OMA_D1_Size = size;
AUS.Default.OMA_D1_Loca = loca;
AUS.Default.Save();
}
/// <summary> These are an interconnected group of
/// overloaded methods to handle various needs.
/// This one defaults to a Title of "View Preferences"
/// and calls the next one down and so on.
/// Combines: DisplayResult, DisplayResults & DisplayOutCome.
/// if title is empty default as shown.
/// This one has it's own Settings for Form Size & Location.
/// </summary>
/// <param name="text"></param>
/// <param name="title"></param>
private static void DisplayResults(string text, string title)
{
if (string.IsNullOrEmpty(title)) title = "View Preferences:";
var size = AUS.Default.OMA_DOC_Size;
var loca = AUS.Default.OMA_DOC_Loc;
DisplayResults(text, title, ref size, ref loca);
AUS.Default.OMA_DOC_Size = size;
AUS.Default.OMA_DOC_Loc = loca;
AUS.Default.Save();
}
/// <summary> Original v4.6.9.95 Apr 07 2017
/// Given a List of two strings, each, in a Generic Dictionary Collection,
/// Call the common GetDisplayString() and then the DisplayResults();
/// Rebuilt with OverLoads above for ViewAllAssociations v4.7.3.73 May 15
/// It directly calls the Mother Method of them all below the next one,
/// As does the next one.
/// </summary>
/// <param name="dic"></param>
private void DisplayResults(Dictionary<string, string> dic)
{
var dir = reportsListBox.SelectedItem.ToString();
var text = GetDisplayString(dic, dir);
var size = AUS.Default.OMA_Display_Size;
var loca = AUS.Default.OMA_Display_Loc;
const string title = "";
DisplayResults(text, title, ref size, ref loca);
AUS.Default.OMA_Display_Size = size;
AUS.Default.OMA_Display_Loc = loca;
AUS.Default.Save();
}
/// <summary> This one accepts the Collection of Dictionaries for
/// ViewAllAssociations(); Has it's own special Size & Location Settings.
/// It directly calls the Mother Method of them all below this one.
/// NOTE: "var x = ..." below does a ton of work,
/// & faster because instead of a loop it's a LINQ query!
/// </summary>
/// <param name="listOfLists"></param>
private static void DisplayResults
(IEnumerable<Dictionary<string, string>> listOfLists)
{
#region was
//var i = 0;
//var x = "";
//foreach (var dic in listOfLists)
// x += GetDisplayString(dic, OPS.Default.reportsListBoxItems[i++]);
#endregion was
var i = 0;
var x = listOfLists.Aggregate("", (current, dic) => current +
GetDisplayString(dic, OPS.Default.reportsListBoxItems[i++]) +
"========================");
const string t = "";
var s = AUS.Default.OMA_D4_S;
var l = AUS.Default.OMA_D4_L;
DisplayResults(x, t, ref s, ref l);
AUS.Default.OMA_D4_S = s;
AUS.Default.OMA_D4_L = l;
AUS.Default.Save();
}
/// <summary> This overload is where all end up.
/// It allows for total flexibility of usages for all args.
/// While providing critical defaults to reduce duplicity.
/// if title is empty it defaults to:
/// "Folder Associations Information:"
/// </summary>
/// <param name="x"></param>
/// <param name="t"></param>
/// <param name="s"></param>
/// <param name="l"></param>
private static void DisplayResults
(string x, string t, ref Size s, ref Point l)
{
if (string.IsNullOrEmpty(t)) t =
"Folder Associations Information:";
using (var f = new ShowMeForm(x, t))
{
f.Size = s;
f.Location = l;
f.ShowDialog();
l = f.Location;
s = f.Size;
}
}
/// <summary> This was split out so it can be used by both
/// the View2Associations and the ViewAllAssociations: v4.7.3.75
/// Added the string dir arg to the sig to interface it with both.
/// </summary>
/// <param name="dic"></param>
/// <param name="dir"></param>
/// <returns></returns>
private static string GetDisplayString
(Dictionary<string, string> dic, string dir)
{ // Sweet! Great integration.
#region Was
//foreach (var pair in list)
//{
// // Concatenate the text string and show it.
// text += "The Data Folder:\n" + pair.Key +
// "\n\nWhich is set to the Data file: \n" +
// pair.Value + "\n\n";
//}
#endregion Was
var
text = string.Format("\nResults for: {0}\n\n" +
"The following currently use this Reports Folder:\n\n", dir);
return
dic.Aggregate(text, (current, pair) => current +
("The Data Folder:\n" + pair.Key +
"\n\nWhich is set to the Data file: \n" +
pair.Value + "\n\n"));
}
/// <summary> Upgrade v4.7.3.96 May 30 2017
/// Similar to the View2Ass but foreach item in ReportsListBox.
/// Design hopped up the Engine below for usage here by splitting
/// the existing EventHandler v into two parts,
/// the 2nd of which (the engine) I can reuse here.
/// NOTE use of Collection of Dictionaries. Very powerful and
/// especially when you consider that Dictionaries are Generic!
/// this calls a special overload of DisplayResults(list);
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ViewAllAssociationsClick(object sender, EventArgs e)
{
var none = new Collection<string>();
var list = new Collection<Dictionary<string, string>>();
var dirs = OPS.Default.reportsListBoxItems;
foreach (var dir in dirs.Cast<string>()
.Where(dir => !string.IsNullOrEmpty(dir)
&& Directory.Exists(dir)))
{
var dict = new Dictionary<string, string>();
View2AssociationsEngine(dir, ref dict, true);
if (dict.Count < 1)
{
#region Rev Doc
// collect the unused paths HERE and do the Yes/No-remove
// later after this loop. The "true" in the call to the engine
// (above View2Ass) skips that in there now. v4.7.3.72 -JpE-
#endregion Rev Doc
none.Add(dir);
continue;
}
list.Add(dict);
}
if (list.Count > 0) DisplayResults(list);
if (none.Count > 0) BatchRemove(none);
}
private void BatchRemove(ICollection<string> unused)
{
#region was
//foreach (var path in unused)
//{
// if (OPS.Default.reportsListBoxItems.IndexOf(path) < 1) continue;
// var text = ORS.OMA_ViewAss + "\n\nPath:\n" + path;
// if (MessageBox.Show(text, ORS.OMA_ViewAssTitle,
// MessageBoxButtons.YesNo, MessageBoxIcon.Question,
// MessageBoxDefaultButton.Button2)
// != DialogResult.Yes) continue;
// if (path.Equals(OPS.Default.PrefReportsDir))
// {
// var target =
// OPS.Default.reportsListBoxItems.IndexOf(path) + 1;
// // if Pref Adopt next in List automatically as new Pref.
// if (target == unused.Count) target = 0;
// ReportsTextBox.Text = WhatWasItB2 =
// OPS.Default.PrefReportsDir =
// OPS.Default.reportsListBoxItems[target];
// if (target < 1) continue;
// }
// OPS.Default.reportsListBoxItems.Remove(path);
//}
#endregion was
foreach
(var path in from path in unused
where OPS.Default.reportsListBoxItems.IndexOf(path) >= 1
let text = ORS.OMA_ViewAss + "\n\nPath:\n" + path
where AST.YesNoDialog(text, ORS.OMA_ViewAssTitle)
|| OPS.Default.MiniVerb
//|| OPS.Default.AreYouSure
select path)
{
if (path.Equals(OPS.Default.PrefReportsDir))
{
var target =
OPS.Default.reportsListBoxItems.IndexOf(path) + 1;
// if Pref Adopt next in List automatically as new Pref.
if (target == unused.Count) target = 0;
ReportsTextBox.Text = WhatWasItB2 =
OPS.Default.PrefReportsDir =
OPS.Default.reportsListBoxItems[target];
if (target < 1) continue;
}
OPS.Default.reportsListBoxItems.Remove(path);
}
PopulateListBoxes();
}
/// <summary> ContextMenuStrip2 Item for Reports Dirs. This one was funner,
/// it will flip through the data folder list and get the prefs info for
/// Reports Folder and Collate a list of those that use the Selected Reports Folder
/// and the pref filename for each. plagarized from myself in this reWrite for
/// Collections.Generic.Dictionary: v4.6.9.94 Apr 06 2017 -JpE-
/// Split into this and the Engine below for ViewAll mods v4.7.3.73 May 15 2017
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void View2AssociationsToolStrip2MenuItemClick(object sender, EventArgs e)
{
var dir = reportsListBox.SelectedItem.ToString();
var dic = new Dictionary<string, string>();
View2AssociationsEngine(dir, ref dic, false); // !all = single path
if (dic.Count > 0) DisplayResults(dic);
}
/// <summary> Split from the above for ReUse with ViewAllAss Mods v4.7.3.74
/// NOTE that if all == true then it cuts short at the comment defering removals.
/// Hand crafted to work with ViewAllAssociationsClick(); -JpE- May 17 2017
/// </summary>
/// <param name="selected"></param>
/// <param name="dirFileNameList"></param>
/// <param name="all"></param>
private void View2AssociationsEngine
(string selected, ref Dictionary<string, string> dirFileNameList, bool all)
{
var invalid = new Collection<string>();
var nth = 0;
try
{
foreach (var dataPath in OPS.Default.dataListBoxItems)
{
if (!Directory.Exists(dataPath)) { invalid.Add(dataPath); continue; }
if (!selected.Equals(GetStoredReportsDirPref(dataPath))) continue;
// else it found one...
var key = string.Format("{0}) ", ++nth) + dataPath;
var prefsFilesName = GetPrefFileName(dataPath);
if (string.IsNullOrEmpty(prefsFilesName))
{ prefsFilesName = "None Associated"; }
dirFileNameList.Add(key, prefsFilesName);
}
} // <-= End of Loop.
catch (ArgumentException exception)
{
if (IF.Testing)
MessageBox.Show(exception.ToString()); return;
}
if (invalid.Count > 0) RemoveInvalidFolders(true, invalid); // Apt identifiers.
// v reworked to do a BatchRemove call in ViewAllAss v72...
if (all || dirFileNameList.Count > 0) return;
// ^ ...& defer removes when "all" arg is true.
// ViewALL returns here skipping the rest each iteration. So...
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region View2 call only sees the rest of this.
if (!AST.YesNoDialog(ORS.OMA_ViewAss, ORS.OMA_ViewAssTitle)) return;
if (OPS.Default.reportsListBoxItems.IndexOf(selected) < 1)
{ MessageBox.Show(ORS.OF_Remove); return; }
if (selected.Equals(OPS.Default.PrefReportsDir))
{
var target = OPS.Default
.reportsListBoxItems.IndexOf(selected) + 1;
if (target == OPS.Default.reportsListBoxItems.Count)
target = 0;
// if Pref, Adopt next in List automatically as new Pref.
ReportsTextBox.Text = WhatWasItB2 =
OPS.Default.PrefReportsDir =
OPS.Default.reportsListBoxItems[target];
if (target == 0) return;
}
// either way, it's history...
OPS.Default.reportsListBoxItems.Remove(selected);
PopulateListBoxes();
#endregion View2 call only section.
}
// v4.7.3.70 May 14 2017
// Took these to a ShowMe calling DisplayResults()
private void ViewBackupDataList(object sender, EventArgs e)
{
var flag = false;
var text = "There is no Backup for this List.";
if (PMS.Default.Bac_dataCollection != null
&& PMS.Default.Bac_dataCollection.Count > 0)
{
flag = true;
text =
PMS.Default.Bac_dataCollection.Cast<string>()
.Aggregate("Data Collection:\n\n",
(current, dir) => current + (dir + "\n"));
}
if (!flag) { MessageBox.Show(text); return; }
const string title = "Backup Data Folder List";
var size = AUS.Default.OMA_D2_Size;
var loca = AUS.Default.OMA_D2_Loca;
DisplayResults(text, title, ref size, ref loca);
AUS.Default.OMA_D2_Size = size;
AUS.Default.OMA_D2_Loca = loca;
AUS.Default.Save();
}
private void ViewBackupReportsList(object sender, EventArgs e)
{
var flag = false;
var text = "There is no Backup for this List.";
if (PMS.Default.Bac_reportsCollection != null
&& PMS.Default.Bac_reportsCollection.Count > 0)
{
flag = true;
text =
PMS.Default.Bac_reportsCollection.Cast<string>()
.Aggregate("Reports Collection:\n\n",
(current, dir) => current + (dir + "\n"));
}
if (!flag) { MessageBox.Show(text); return; }
const string title = "Backup Reports Folder List";
var size = AUS.Default.OMA_D3_Size;
var loca = AUS.Default.OMA_D3_Loca;
DisplayResults(text, title, ref size, ref loca);
AUS.Default.OMA_D3_Size = size;
AUS.Default.OMA_D3_Loca = loca;
AUS.Default.Save();
}
#endregion Upgrade 4.7.3.73 Updates to existing and new.
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region v4.7.5.25 14Jun17 -=[ THE BIG 2 ]=-
/* Upgrade Adds The Context Menu Items to Backup & Restore
* The Lists Which are already Saved in PrintMasterSettings.
* The Save and Restore of Lists is already in & tested. -JpE-
* Retain/Revert/Cancel is in and tested. The Big 2 methods here
* are the EventHandlers for these Context Menu Options in each ListBox.
* They are known here, affectionately, as the Big 2. Each Full Featured.
*
* The rest of the NEXT #region is the various ReUsable Methods that support
* the Big 2. I wanted to make everything modular and these support methods are
* very flexible and get used by all 4 of the EventHandlers. Each support method
* has at least 2 code paths (data true or false) and most have 4 for each occasion.
* BackupDataList, BackupReportsList, RestoreDataList & RestoreReportsList.
* I was practicing making things compact and reusable and reducing total code.
* Updated v4.7.5.28 Jun 16 2017 for the AutoBackup and everything called from
* AppCode2.Restore4(); for Maintenance.
*
*/
#region Backup & Backup Specific
/// <summary> BackupDataList Context Menu EventHandler
/// Split out & consolidated to BackupLists which
/// now does both. v4.7.5.21 12Jun17
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackupDataList(object sender, EventArgs e)
{
const bool
data = true,
auto = false;
BackupLists(data, auto);
}
/// <summary> AutoMode Tricks. v4.7.5.15 10Jun17
/// v4.7.5.12.3 Jun 08 17 Mods adds BackupListsAuto();
/// to Restore3, Scheduler Call. Setting sender here
/// makes it auto-mode there.
/// So... sig is (bool data, bool auto)
/// v4.7.5.19 Perfected and Final Testing. 12Jun17
/// Constructor in OF makes this possible though
/// it is not static, through an instantiation.
/// </summary>
public void BackupListsAuto()
{
//BackupLists( data, auto); // por exemplar
BackupLists( true, true); // datafolders
BackupLists(false, true); // reportsfolders
}
/// <summary> BackupReportsList Context Menu EventHandler
/// Split out & consolidated to BackupLists which
/// now does both. v4.7.5.21 12Jun17
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackupReportsList(object sender, EventArgs e)
{
const bool
data = false,
auto = false;
BackupLists(data, auto);
}
/// <summary> All-In-One Backup Module
/// RetroFit for automode v4.7.5.23
/// 12-Jun-2017
/// </summary>
/// <param name="data"></param>
/// <param name="auto"></param>
private void BackupLists(bool data, bool auto)
{
if (!AskUser(data, auto)) return;
const bool backup = true;
var merge = false;
StringCollection unique;
if (HasUniquePath(data, out unique, backup))
{ // Backup has something unique.
if (auto) merge = true;
else
merge = OPS.Default.MiniVerb
|| AST.YesNoDialog(ORS.OMA_B1, 1);
}
var what = 0;
var both = BothHaveBoth(ref what, data);
if (!merge && unique.Count > 0)
{
var r = AST.YesNoCancel(ORS.OMA_B2, 1);
if (r == 3) return; // Cancel Clicked.
if (r == 1)
{
DontMerge(data);
what = 1;
both = false;
unique.Clear();
}
if (r == 2) merge = true;
}
var rr = 0;
if (!auto)
if (both && merge)
rr = RetainRevert(ORS.OMA_B3);
if (rr > 2) return;
var retain = rr < 2;
if (!both)
{
if (what < 2) retain = true;
if (what == 2) retain = false;
}
// what == 1 (is) only in OS, 2 only in PMS, 0 == Neither.
if (what < 1 && !auto)
{
if (data) SoWhat(); // and here
else SoWhatElse();
}
Merger(retain, unique, backup, data, auto); // replace 2nd true for data var inside.
OPS.Default.Save();
PMS.Default.Save();
if (OPS.Default.MiniVerb || auto) return;
ShowBackupResult(true, merge, retain);
}
/// <summary> Ask for for User Input to Proceed.
/// but there is no more Big Four it's the Big two now LoL
/// The Big two each ate one of the Big 4 but didn't grow.
/// </summary>
/// <param name="data"></param>
/// <param name="auto"></param>
/// <returns></returns>
private static bool AskUser(bool data, bool auto)
{
// Split out from BackupLists v4.7.5.21
if (data)
{
if (OPS.Default.dataListBoxItems.Count < 1)
{
if (!auto) MessageBox.Show(ORS.OMA_E2);
return false;
}
if (!OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure
&& !auto)
if (!AST.YesNoDialog(ORS.OMA_BDL))
return false;
}
else // if not data it is reports calling.
{
if (OPS.Default.reportsListBoxItems.Count < 1)
{
if (!auto) MessageBox.Show(ORS.OMA_E3);
return false;
}
if (!OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure && !auto)
if (!AST.YesNoDialog(ORS.OMA_BRL))
return false; // Skips in AutoMode.
}
return true;
}
/// <summary> Straight Backup No Merge.
/// Split out from BackupLists v4.7.5.24
/// June 13 2017
/// </summary>
/// <param name="data"></param>
private static void DontMerge(bool data)
{
if (data)
{
PMS.Default.Bac_PrefRootDir =
OPS.Default.PrefRootDir;
PMS.Default.Bac_PrefFileName =
OPS.Default.PrefFileName;
}
else
{
PMS.Default.ReportsFolder =
OPS.Default.PrefReportsDir;
}
PMS.Default.Save();
}
/// <summary> Display results of Backup
/// Works for either List retrofit and
/// Split out v4.7.5.24 June 13 2017
/// </summary>
/// <param name="data"></param>
/// <param name="merge"></param>
/// <param name="retain"></param>
private static void
ShowBackupResult(bool data, bool merge, bool retain)
{
// Skip-All Setting & AutoMode skip Display Msg.
var text = ORS.OMA_DLB; // only this var varies.
if (!data) text = ORS.OMA_RLB;
if (merge)
{
text = retain
// True/False, Left to Right as assignment.
? ORS.OMA_B4 : ORS.OMA_B5;
text += "\n\n" + ORS.OMA_B6;
}
MessageBox.Show(text);
}
#endregion Backup & Backup Specific
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Restore & Restore Specific
/* Early Analysis and Design Notes:
*
* 1) Which methods from DataList are reUseable?
* a) Houston()
* b) Obviously, YesNoDialog() LoL
* c) HasUniquePath(false, out unique) is it. (false is Reports)
* d) RetainRevert & the RetainRevertCancel Object are very reUsable.
* e) AddUnique() is reUsable with false for reports.
* f) A Reports-Folder-Select thingy exists somewhere in this source code file.
*
* 2) Which are not, AND which will be needed? (ie. rewritten for Reports.)
* a) BothHaveBoth can be BothHaveIt() for reports List.
* b) Merger(), RevertPrefs and MergeLists() will all have to be at-least
* edited for ReportsList. Maybe modified to do both or cloned out to it's own method.
* c) A desperate call to SoWhat() may be needed. The else branch of
* the DataList version seems reUsable enough maybe?
* d) SelectRootDir() can be cloned and edited easily enough.
*
* 3) Which are not, but will not be needed?
* b) I'm not sure ReCheck() in any form will be needed. Maybe something else?
*
* 4) What methods will be completely new in ReportsList?
* a) All of them LOL, they evolved to be 4 function each for backups and restores
* b) and for data and reports. Most go all four ways LoL. v4.7.3.65 May 11 2017
* By:
* John.P.Edwards dba Global Access Software Intl.
* Designed, Produced, Coded, Tested and Developed by -JpE- (C) 2011-2026
*/
private void RestoreDataList(object sender, EventArgs e)
{
const bool data = true;
RestoreLists(data);
}
private void RestoreReportsList(object sender, EventArgs e)
{
const bool data = false;
RestoreLists(data);
}
private void RestoreLists(bool data)
{
// Store & Retrieve PrefRoot, Reports and FileName as well.
// Retain members of this list that do not appear in the backup?
if (!AskUser2(data)) return;
const bool backup = false, auto = false;
var merge = false;
StringCollection unique;
if (HasUniquePath(data, out unique, backup))
merge = OPS.Default.MiniVerb
|| AST.YesNoDialog(ORS.OMA_R1, 1);
var what = 0;
var both = BothHaveBoth(ref what, data);
// if (!both && which == 1 = only in OS, 2 = only in PMS,
// 0 = Neither has needed Info.
if (!merge && unique.Count > 0)
{
// v added v4.7.2.55 May 05
var r = AST.YesNoCancel(ORS.OMA_R2, 1);
if (r == 3) return;
if (r == 1)
{
DontMerge2(data);
what = 2;
both = false;
unique.Clear();
}
if (r == 2) merge = true;
}
var rr = 0; // Retain the Preferred Folders
// ...and FileName or revert to backup?
if (both && merge) rr = RetainRevert();
// ^ returns 1 if retain & 2 if revert, 3 if Cancel.
if (rr > 2) return; // Cancel.
// Which leaves only 0, 1 & 2 on the table.
var retain = rr < 2;// == 1;
// retain = true is retain, false is revert.
if (!both)
{
if (what < 2) retain = true;
if (what == 2) retain = false;
}
if (what.Equals(0))
{
if (data) SoWhat();
else SoWhatElse();
}
// All set, let's do it!
Merger(retain, unique, backup, data, auto);
Changes(data);
// And now that it is restored...
if (OPS.Default.MiniVerb) return;
ShowRestoreResult(data, merge, retain);
}
private void Changes(bool data)
{
if (data)
{
folderBrowser.SelectedPath =
OPS.Default.PrefRootDir;
DataChanges();
}
else
{
folderBrowser.SelectedPath =
OPS.Default.PrefReportsDir;
ReportsChanges();
}
}
private static void DontMerge2(bool data)
{
if (data)
{
OPS.Default.PrefFileName = PMS.Default.Bac_PrefFileName;
OPS.Default.PrefRootDir = PMS.Default.Bac_PrefRootDir;
OPS.Default.PrefReportsDir = PMS.Default.ReportsFolder;
}
else
OPS.Default.PrefReportsDir = PMS.Default.ReportsFolder;
}
private static bool AskUser2(bool data)
{
if (Houston())
{ // aka We have a problem!
MessageBox.Show(ORS.OMA_E1);
return false;
}
var msg = ORS.OMA_RDL;
if (!data) msg = ORS.OMA_RRL;
if ( !OPS.Default.MiniVerb
&& !OPS.Default.AreYouSure)
if (!AST.YesNoDialog(msg)) return false;
return true;
}
private static void ShowRestoreResult
(bool data, bool merge, bool retain)
{
var text = ORS.OMA_DLR;
if (!data) text = ORS.OMA_RLR;
if (merge)
{
text = retain ? ORS.OMA_R3 : ORS.OMA_R4;
text += "\n\n" + ORS.OMA_R5;
}
MessageBox.Show(text);
}
#endregion Restore & Restore Specific
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#endregion v4.7.2.56-65 May 06-11 2017 -=[ THE BIG 2 ]=-
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Supporting Methods FOR 4 way w/ -=[ THE BIG 2 ]=-
// NOTE: retain == true to retain, false to revert.
// what == 1 means only in OS, 2 means only in PMS,
// (retain defaults to true if what==1, false if what==2)
// both == true means Both Have BOTH PrefRootDir & PrefFileName.
/// <summary> Quad Function Router for the Big 2 Method Groups:
/// BackupDataList, RestoreDataList, BackupReports & RestoreReports.
/// Retain and Revert Logic Switched up on Backups and Worded differently
/// in the RetainRevert() call. Feature adds full functionality for Lists.
/// 4 code paths for backup and data, true or false as illustrated.
/// backup true - data true, backup true - data false, backup false - data true,
/// and backup false - data false. Are all covered here for the Big 4 Methods.
/// And further switched herein by retain. For 8 possible code paths in one here.
/// auto is only true if this is an Automatic-Backup of either List.
/// v4.7.5.25 Compatible, nothing changed down here, just in the Big 2 above.
/// </summary>
/// <param name="retain"></param>
/// <param name="unique"></param>
/// <param name="backup"></param>
/// <param name="data"></param>
/// <param name="auto"></param>
private void Merger(
bool retain, StringCollection unique,
bool backup, bool data, bool auto)
{
if (!backup) { if (!retain) RevertPrefs(data); }
// if retain we're already set.
else
{ // backup == true
if (retain)
{
if (data)
{ // DataList, Backup, Retain.
PMS.Default.Bac_PrefRootDir = OPS.Default.PrefRootDir;
PMS.Default.Bac_PrefFileName = OPS.Default.PrefFileName;
}
else PMS.Default.ReportsFolder = OPS.Default.PrefReportsDir; // Rprts.
}
else
{ // if (!retain && backup) Revert Backup to Backup Prefs.
var c = unique.Count;
if (data)
{ // Data List, Backup, Revert. (True/False v)
var dir = c > 0 ? unique[0] : PMS.Default.Bac_PrefRootDir;
if (Directory.Exists(dir)) PMS.Default.Bac_PrefRootDir = dir;
else if (!auto) SoWhat();
var fn = GetPrefFileName(dir);
if (File.Exists(dir + "\\" + fn))
PMS.Default.Bac_PrefFileName = fn;
else if (!auto) SoWhat();
}
else
{ // Reports List Backup, Revert.
var dir = c > 0 ? unique[0] : PMS.Default.ReportsFolder;
if (Directory.Exists(dir)) PMS.Default.ReportsFolder = dir;
else if (!auto) SoWhatElse();
}
} // Then just flip it on Backups, for best affect. ;-)
retain = !retain;
}
// Now Merge them according to retain, backup & data.
if (data) MergeDataLists(retain, unique, backup);
else MergeReportsLists(retain, unique, backup);
// ^ Data/Reports Differs here+Backup/Restore ^ differs there.
}
/// <summary> Runs only from the 2 Restore Tasks.
/// Reverts the Current Prefs to the Backup Prefs.
/// data == true is Data LIst, false is Reports.
/// </summary>
/// <param name="data"></param>
private void RevertPrefs(bool data)
{
if (data)
{
// Use Prefs from PMS.
var dir = DataTextBox.Text = WhatWasItB4 =
OPS.Default.PrefRootDir = PMS.Default.Bac_PrefRootDir;
var fnp = GetPrefFileName(dir);
var rec = GetStoredReportsDirPref(dir);
var tea = false;
if (!File.Exists(dir + "\\" + fnp)) { SoWhat(); tea = true; }
if (!Directory.Exists(rec)) { SoWhatElse(); tea = true; }
if (tea) return;// tea time, bye!
// ^^^^ I bet flow never gets to either, but Justin Case.
OPS.Default.PrefFileName = fnp;
ReportsTextBox.Text = OPS.Default.PrefReportsDir = rec;
}
else
{
var or = OPS.Default.PrefReportsDir;
var pr = PMS.Default.ReportsFolder;
if (Directory.Exists(pr)) ReportsTextBox.Text =
OPS.Default.PrefReportsDir = WhatWasItB2 = pr;
else
{
if (Directory.Exists(or)) return;
SoWhatElse();
if (Directory.Exists(OPS.Default.PrefReportsDir)) return;
var ok = ReportsTextBox.Text = OPS.Default.PrefReportsDir =
OPS.Default.PrefRootDir + "\\" +
PMS.Default.Reports;
if (!Directory.Exists(ok))
Directory.CreateDirectory(ok);
}
}
}
/// <summary> if backup == false then it's a Restore Task.
/// If Revert, it tacks the diffs on the end, (retain==false)
/// if Retain, it puts them up top. NOTE: Reversed for Backups!
/// if backup == true then it's a little different logic circuit:
/// Retain puts the diffs from backup at the bottom, keeping the Current.
/// Revert puts the diffs from backup at the Top of the List.
/// Merges the two Data Folder Lists.
/// </summary>
/// <param name="retain"></param>
/// <param name="unique"></param>
/// <param name="backup"></param>
private static void MergeDataLists
(bool retain, IEnumerable unique, bool backup)
{
if (backup) // We're backing up the Current List.
{
if (PMS.Default.Bac_dataCollection == null)
PMS.Default.Bac_dataCollection = new StringCollection();
var _default = OPS.Default.dataListBoxItems[0];
PMS.Default.Bac_dataCollection.Clear();
PMS.Default.Bac_dataCollection.Add(_default);
var enumerable = unique as object[]
?? unique.Cast<object>().ToArray();
if (retain) AddUnique(true, enumerable, true);
foreach (var dir in OPS.Default
.dataListBoxItems.Cast<string>()
.Where(Directory.Exists)
.Where(dir => !dir.Equals(_default)))
PMS.Default.Bac_dataCollection.Add(dir);
if (!retain) AddUnique(true, enumerable, true);
}
else // It's a Restore Task.
{
// Either way, We will clear and refill the List.
// But grab the default and keep it up Top always.
if (PMS.Default.Bac_dataCollection == null)
PMS.Default.Bac_dataCollection = new StringCollection();
var _default = OPS.Default.dataListBoxItems[0];
OPS.Default.dataListBoxItems.Clear();
OPS.Default.dataListBoxItems.Add(_default);
// if Retain, Put the diffs up Top.
var enumerable = unique as object[]
?? unique.Cast<object>().ToArray();
if (retain) AddUnique(true, enumerable, false);
foreach (var dir in PMS.Default
.Bac_dataCollection.Cast<string>()
.Where(Directory.Exists)
.Where(dir => !dir.Equals(_default)))
OPS.Default.dataListBoxItems.Add(dir);
// Else, Tack diffs on the end.
if (!retain) AddUnique(true, enumerable, false);
}
}
/// <summary> if backup == false then it's a Restore Task.
/// If Revert, it tacks the diffs on the end, (retain==false)
/// if Retain, it puts them up top. NOTE: Reversed for Backups!
/// if backup == true then it's a little different logic circuit:
/// Retain puts the diffs from backup at the bottom, keeping the Current.
/// Revert puts the diffs from backup at the Top of the List.
/// Merges the two Reports Folder Lists.
/// </summary>
/// <param name="retain"></param>
/// <param name="unique"></param>
/// <param name="backup"></param>
private static void MergeReportsLists
(bool retain, IEnumerable unique, bool backup)
{
if (backup) // it's a Backup Task.
{
if (PMS.Default.Bac_reportsCollection.Equals(null))
PMS.Default.Bac_reportsCollection = new StringCollection();
var d = OPS.Default.reportsListBoxItems[0];
PMS.Default.Bac_reportsCollection.Clear();
PMS.Default.Bac_reportsCollection.Add(d);
var e = unique as object[]
?? unique.Cast<object>().ToArray();
if (retain) AddUnique(false, e, true);
foreach (var dir in OPS.Default
.reportsListBoxItems.Cast<string>()
.Where(Directory.Exists)
.Where(dir => !dir.Equals(d)))
PMS.Default.Bac_reportsCollection.Add(dir);
if (!retain) AddUnique(false, e, true);
}
else // it's a restore task. (already tested below)
{
if (PMS.Default.Bac_reportsCollection.Equals(null))
PMS.Default.Bac_reportsCollection = new StringCollection();
var d = OPS.Default.reportsListBoxItems[0];
OPS.Default.reportsListBoxItems.Clear();
OPS.Default.reportsListBoxItems.Add(d);
var e = unique as object[]
?? unique.Cast<object>().ToArray();
if (retain) AddUnique(false, e, false);
foreach (var dir in PMS.Default
.Bac_reportsCollection.Cast<string>()
.Where(Directory.Exists)
.Where(dir => !dir.Equals(d)))
OPS.Default.reportsListBoxItems.Add(dir);
if (!retain) AddUnique(false, e, false);
}
}
/// <summary> Adds the unique paths to the appropriate collection:
/// if data == true then it's Data Folders, if false it's Reports.
/// if backup == true it's a backup Task, if false it's a Restore Task.
/// NOTE: The if (backup) lines and their else makes it quad function.
/// </summary>
/// <param name="data"></param>
/// <param name="unique"></param>
/// <param name="backup"></param>
private static void AddUnique
(bool data, IEnumerable unique, bool backup)
{
if (data) // Data List.
{
foreach (var dir in unique.Cast<string>()
.Where(dir => Directory.Exists(dir)
&& HasDataFiles(dir)))
{
// if added to make universal v4.7.2.58
if (backup) PMS.Default.Bac_dataCollection.Add(dir);
else OPS.Default.dataListBoxItems.Add(dir);
}
}
else // Reports List.
{
foreach (var dir in unique.Cast<string>()
.Where(Directory.Exists))
{
// if added to make universal v4.7.2.58
if (backup) PMS.Default.Bac_reportsCollection.Add(dir);
else OPS.Default.reportsListBoxItems.Add(dir);
}
}
}
/// <summary> 1 = only in OS, 2 = only in PMS, 0 = Neither.
/// What's up with what: True = Yes, Both. what = 0; in call btw.
/// Just Check; that current and backup collections both have;
/// both PrefFileName and PrefRootDir. (BothHaveBoth!)
/// For Reports (data==false); it Checks if Both Have IT.
/// (PrefReportsDir) Same Logic. And Same for Backup & Restore.
/// So that doesn't matter here. All 4 of the Big 4 call this method.
/// It's results are just interpreted differently during a Backup
/// back in the calling methods. No differentiation here for that.
/// </summary>
/// <param name="what"></param>
/// <param name="data"></param>
/// <returns></returns>
private bool BothHaveBoth(ref int what, bool data)
{
var result = false;
if (!data)
{
var or = OPS.Default.PrefReportsDir;
var pr = PMS.Default.ReportsFolder;
var ol = OPS.Default.reportsListBoxItems;
var pl = PMS.Default.Bac_reportsCollection;
if (Directory.Exists(or) && ol.Contains(or)) what = 1;
if (Directory.Exists(pr) && pl.Contains(pr))
{
if (what == 1) result = true;
what = 2;
}
return result;
} // else it is Data...
var osF = OPS.Default.PrefFileName;
var osR = OPS.Default.PrefRootDir;
var psF = PMS.Default.Bac_PrefFileName;
var psR = PMS.Default.Bac_PrefRootDir;
if (Directory.Exists(osR))
{ if (File.Exists(osR + "\\" + osF)) what = 1;}
if (Directory.Exists(psR))
{
if (File.Exists(psR + "\\" + psF))
{
if (what.Equals(1)) result = true;
what = 2;
}
} // If one does not, try to use the pref.lbs before final assessment.
if (what == 1) // (2) pms does not. Backup does not. False.
{ if (ReCheck(false)) result = true; }
if (what == 2 && result.Equals(false)) // (1) os does not. True.
// Fat chance but I'll cover it anyway. LoL.
{ if (ReCheck(true)) result = true; }
return result;
}
// os false is re check pms,
// os true is re check os. Hello!!!
// (not likely, but covered anyway.)
private bool ReCheck(bool ops)
{
var found1 = false;
if (ops) found1 = ReCheckOps();
else
{ // pms
var list = PMS.Default.Bac_dataCollection;
int count = list.Count,
index = 1;
if (count < 1) return false;
for (; index < count; ++index)
{
var dir = list[index];
var filename = FileName;
FileName = "";
var file = GetPrefFileName(dir);
FileName = filename;
var path = PMS.Default.ReportsFolder;
PMS.Default.ReportsFolder = "";
var repo = GetStoredReportsDirPref(dir);
PMS.Default.ReportsFolder = path;
if (!Directory.Exists(dir) || !HasDataFiles(dir)
|| !File.Exists(dir + "\\" + file)
|| string.IsNullOrEmpty(file)
|| string.IsNullOrEmpty(repo)) continue;
PMS.Default.Bac_PrefFileName = file;
PMS.Default.Bac_PrefRootDir = dir;
found1 = true;
if (Directory.Exists(repo))
PMS.Default.ReportsFolder = repo;
else
{
var test = OPS.Default.PrefReportsDir;
if (Directory.Exists(test))
{
PMS.Default.ReportsFolder = test;
}
else
{
test = AUS.Default.RootDir;
if (Directory.Exists(test))
PMS.Default.ReportsFolder = test;
else
{
var check = AUS.Default.AppDir +
"\\" + APS.Default.Home +
"\\" + PMS.Default.Reports;
if (Directory.Exists(check))
PMS.Default.ReportsFolder = check;
else found1 = false;
}
}
}
break;
} // end of For Loop.
}
return found1;
}
private bool ReCheckOps()
{
var found = false;
var list = OPS.Default.dataListBoxItems;
var count = list.Count;
if (count < 1) return false;
var index = 1;
for (;index < count; ++index)
{
var dir = list[index];
var filename = FileName;
FileName = "";
var file = GetPrefFileName(dir);
FileName = filename;
var path = OPS.Default.PrefReportsDir;
OPS.Default.PrefReportsDir = "";
var repo = GetStoredReportsDirPref(dir);
OPS.Default.PrefReportsDir = path;
if (!Directory.Exists(dir) || !HasDataFiles(dir)
|| !File.Exists(dir + "\\" + file)
|| string.IsNullOrEmpty(file)
|| string.IsNullOrEmpty(repo)) continue;
OPS.Default.PrefFileName = file;
OPS.Default.PrefRootDir = dir;
found = true;
if (Directory.Exists(repo))
OPS.Default.PrefReportsDir = repo;
else
{
var test = OPS.Default.PrefReportsDir;
if (Directory.Exists(test))
OPS.Default.PrefReportsDir = test;
else
{
test = AUS.Default.RootDir;
if (Directory.Exists(test))
OPS.Default.PrefReportsDir = test;
else
{
var check =
AUS.Default.AppDir +
"\\" + APS.Default.Home +
"\\" + PMS.Default.Reports;
if (Directory.Exists(check))
OPS.Default.PrefReportsDir = check;
else found = false;
}
}
}
break;
} // end of For Loop.
return found;
}
private void SoWhat()
{
var x = OPS.Default.dataListBoxItems.Count < 2 ? 0 : 1;
var d = OPS.Default.PrefRootDir = OPS.Default.dataListBoxItems[x];
// this ^ one has already been tested for Dir.Exists and HasDataFiles.
if (string.IsNullOrEmpty(d) // All 3 If Needed <-= v
|| !Directory.Exists(d)) d = SelectRootDir(); // <-= TestsWell!
var f = GetPrefFileName(d);
var r = GetStoredReportsDirPref(d);
var t = false;
if (File.Exists(d + "\\" + f))
{
t = true; // true testswell, false too.
OPS.Default.PrefFileName = f;
}
if (!t)
{
var size = AUS.Default.OMA_FileSelect_Size;
var location = AUS.Default.OMA_FileSelect_Location;
var list = GetDataFileList(d);
// v4.7.3.93 index mods
var index = 0;
var test = GetPrefFileName(OPS.Default.PrefRootDir);
if (list.Contains(test))
index = list.IndexOf(test);
else
if (list.Contains(OPS.Default.PrefFileName))
index = list.IndexOf(OPS.Default.PrefFileName);
else
if (list.Contains(PMS.Default.Bac_PrefFileName))
index = list.IndexOf(PMS.Default.Bac_PrefFileName);
else
if (list.Contains(AUS.Default.FileName))
index = list.IndexOf(AUS.Default.FileName);
else
if (list.Contains(APS.Default.defaultFilename))
index = list.IndexOf(APS.Default.defaultFilename);
// else default to the index[0] default.
// ^ v4.7.3.93 May 30 2017
var choice = SelectOne(list, ref size, ref location, "", index); // <-=/\/\/\/\/\
AUS.Default.OMA_FileSelect_Size = size;
AUS.Default.OMA_FileSelect_Location = location;
AUS.Default.Save();
if (string.IsNullOrEmpty(choice)) choice = list[index];
OPS.Default.PrefFileName = choice;
}
if (Directory.Exists(r)) OPS.Default.PrefReportsDir = r;
else SoWhatElse();
}
/// <summary> Split out and ReUsed by RestoreReportsList() v4.7.2.51
/// This was the else portion of SoWhat() btw. LoL
/// Aptly named therefor.
/// </summary>
private void SoWhatElse()
{
var list7 = OPS.Default.reportsListBoxItems;
var list8 = new Collection<string>();
const string title = "Select a Reports Folder:";
foreach (var path in list7.Cast<string>()
.Where(Directory.Exists)) list8.Add(path);
// vvvvvvvvvv v4.7.3.93 May 30 2017
var index = 0;
var test = GetStoredReportsDirPref(OPS.Default.PrefRootDir);
if (list8.Contains(test)) index = list8.IndexOf(test);
else
if (list8.Contains(OPS.Default.PrefReportsDir))
index = list8.IndexOf(OPS.Default.PrefReportsDir);
else
if (list8.Contains(PMS.Default.ReportsFolder))
index = list8.IndexOf(PMS.Default.ReportsFolder);
// else default to the index[0] default.
// ^ v4.7.3.93 May 30 2017
var size = AUS.Default.OMA_ReportsSelect_Size;
var locate = AUS.Default.OMA_ReportsSelect_Location;
var report = SelectOne(list8, ref size, ref locate, title, index); // <-=/\/\/\/\/\
AUS.Default.OMA_ReportsSelect_Size = size;
AUS.Default.OMA_ReportsSelect_Location = locate;
AUS.Default.Save();
if (string.IsNullOrEmpty(report)) report = list8[index];
OPS.Default.PrefReportsDir = report;
}
private string SelectRootDir()
{
var d = AUS.Default.AppDir + "\\" + APS.Default.Home;
var c = OPS.Default.dataListBoxItems.Count;
if (c == 1) d = OPS.Default.dataListBoxItems[0];
if (c < 2) return d;
// So, whereever there are two or more.
var list = new Collection<string>();
foreach (var dir in OPS.Default.dataListBoxItems
.Cast<string>().Where(dir => Directory.Exists(dir)
&& HasDataFiles(dir))) list.Add(dir);
if (list.Count < 2) return list.Count == 1 ? list[0] : d;
// vvvvvvvvvv v4.7.3.93
var index = 0;
var test = OPS.Default.PrefRootDir;
if (list.Contains(test))
index = list.IndexOf(test);
else
if (list.Contains(AUS.Default.RootDir))
index = list.IndexOf(AUS.Default.RootDir);
else
if (list.Contains(PMS.Default.Bac_PrefRootDir))
index = list.IndexOf(PMS.Default.Bac_PrefRootDir);
// else default to the index[0] default.
// ^^^^^ v4.7.3.93 May 30 2017
const string title = "Please Select a Data Folder:";
var s = AUS.Default.OMA_ReportsSelect_Size;
var l = AUS.Default.OMA_ReportsSelect_Location;
var a = SelectOne(list, ref s, ref l, title, index); // <<=====<<
AUS.Default.OMA_ReportsSelect_Location = l;
AUS.Default.OMA_ReportsSelect_Size = s;
AUS.Default.Save();
if (string.IsNullOrEmpty(a)
|| !Directory.Exists(a)) a = list[index];
return a;
}
/// <summary> See if the Current List has anything Unique,
/// / Not in the Backup. Adds these to the unique Collection.
/// bool = true is Data Folders, false is Reports folder lists.
/// </summary>
/// <param name="data"></param>
/// <param name="unique"></param>
/// <param name="backup"> </param>
/// <returns></returns>
private bool HasUniquePath
(bool data, out StringCollection unique, bool backup)
{
CheckPrefs();
unique = new StringCollection();
var list1 = OPS.Default.dataListBoxItems;
var list2 = PMS.Default.Bac_dataCollection;
if (!data) // Defaults ^ to Data, false for Reports Collection.
{
list1 = OPS.Default.reportsListBoxItems;
list2 = PMS.Default.Bac_reportsCollection;
}
if (backup) // Then just...
{
foreach (var path in from string path in list2
where !list1.Contains(path)
where Directory.Exists(path)
select path) unique.Add(path);
}
else // Below Well Tested Restore Mods.
{
foreach (var path in from string path in list1
where !list2.Contains(path)
where Directory.Exists(path)
select path) unique.Add(path);
}
return unique.Count > 0;
}
/// <summary> Check for any Problems
/// with the Collections & PrefFileName, etc.
/// </summary>
/// <returns></returns>
private static bool Houston()
{ // Justin Case it's a WipEd RuN.
if (PMS.Default.Bac_dataCollection.Equals(null))
PMS.Default.Bac_dataCollection = new StringCollection();
if (PMS.Default.Bac_reportsCollection.Equals(null))
PMS.Default.Bac_reportsCollection = new StringCollection();
return
PMS.Default.Bac_dataCollection.Count < 1
|| PMS.Default.Bac_reportsCollection.Count < 1
|| string.IsNullOrEmpty(PMS.Default.Bac_PrefFileName)
|| string.IsNullOrEmpty(PMS.Default.Bac_PrefRootDir)
|| string.IsNullOrEmpty(PMS.Default.ReportsFolder);
// Check for string.nullorempty ^ in which case: show msg.
}
/// <summary> returns 1 if Retain, 2 if Revert, 3 if Cancel.
/// Send it the public Properties LabelText, FormLocation,
/// FormForeColor, FormBackColor. LabelText is Optional as
/// are the others of course. TestsWell! v4.7.1.38
/// </summary>
/// <returns></returns>
private int RetainRevert()
{
const string txt = "";
return RetainRevert(txt);
}
private int RetainRevert(string txt)
{
int chosen;
using (var rrc = new RetainRevertCancel())
{ // ReUsable Custom Class ^ Object Instantiation.
rrc.LabelText = txt; // default if empty.
rrc.FormLocation = AUS.Default.RRC_Location;
rrc.FormForeColor = TabForeColor;
rrc.FormBackColor = TabBackColor;
rrc.ShowDialog(); // <-=/\/\/\/\/\/\/\/\/\/****
AUS.Default.RRC_Location = rrc.Location;
AUS.Default.Save();
chosen = rrc.ButtonClicked;
}
return chosen;
}
#endregion Supporting Methods for the Big 2 Above.
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#endregion Context Menu Items
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#region Upgrade 4.7.0.07 Apr 13 2017
/// <summary> Checks for a pref.lbs and gets the pref Reports folder from it.
/// Then AddsToPathCollection(path, false) or whatever.
///
/// Called only in OptionsFormLoad(); on entry.
/// </summary>
private void CheckReportsCollection()
{
var invalid = new List<string>();
var missing = new List<string>();
foreach (var dataPath in OPS.Default.dataListBoxItems)
{
if (!Directory.Exists(dataPath)) { invalid.Add(dataPath); continue; }
// else...
var reports = GetStoredReportsDirPref(dataPath);
if (!OPS.Default.reportsListBoxItems.Contains(reports)
&& Directory.Exists(reports)
&& !missing.Contains(reports)) { missing.Add(reports); }
} // Last line here ^ should fix dup reports dirs. v4.7.0.05 Apr 13
if (missing.Count > 0)
{
if (AST.YesNoDialog("Add Missing Reports Folders to the Collection?"))
{
var _default = AUS.Default.AppDir + "\\" +
APS.Default.Home + "\\" + PMS.Default.Reports;
var count = OPS.Default.reportsListBoxItems.Count;
if (count < 2
|| !OPS.Default.reportsListBoxItems.Contains(_default))
{
if (OPS.Default.reportsListBoxItems.Contains(_default)
&& OPS.Default.reportsListBoxItems.IndexOf(_default) > 0)
{
OPS.Default.reportsListBoxItems.Remove(_default);
--count;
}
if (!OPS.Default.reportsListBoxItems.Contains(_default))
{
if (count.Equals(0)) OPS.Default.reportsListBoxItems.Add(_default);
else OPS.Default.reportsListBoxItems.Insert(0, _default);
}
}
if (missing.Contains(_default)) missing.Remove(_default);
foreach (var dir in missing)
{
OPS.Default.reportsListBoxItems.Add(dir);
}
}
}
RemoveInvalidFolders(true, invalid);
}
/// <summary> Stores everything in OMA Settings Wise on FormLoad.
/// so it can be brought back on Cancel/Abort/Red-X.
/// </summary>
private void SaveInitialSettings()
{
CreateNewDetectionStrings();
// ^ Added v4.7.0.07
_data.Clear();
foreach (var str in OPS.Default.dataListBoxItems)
{ _data.Add(str); }
_reports.Clear();
foreach (var str in OPS.Default.reportsListBoxItems)
{ _reports.Add(str); }
if (!OPS.Default.Schedule1
|| OPS.Default.Scheduled1 < DateTime.Now.AddYears(-1))
{ // wipe bugg fixed ^v v4.7.2.44 Apr 29 2017
OPS.Default.Schedule1 = true;
OPS.Default.Scheduled1 = DateTime.Now;
OPS.Default.Save();
}
_scheduler[0] = OPS.Default.Schedule1;
_scheduler[1] = OPS.Default.Schedule3;
_scheduler[2] = OPS.Default.Schedule5;
if (_scheduler[0]) _scheduled[0] = OPS.Default.Scheduled1;
if (_scheduler[1]) _scheduled[1] = OPS.Default.Scheduled3;
if (_scheduler[2]) _scheduled[2] = OPS.Default.Scheduled5;
CheckPrefs(); // <-= WipeSchedule Bugg Fixed v4.7.2.44
// v v4.7.0.07 Scheduler Upgrade Apr 14 2017
DayOfWeekCheckBox.Checked = DayOfWeek = OPS.Default.DoW;
Change = false;
}
private void CreateNewDetectionStrings()
{
Data = OPS.Default.dataListBoxItems.Cast<string>()
.Aggregate((current, str) => current + str);
Reports = OPS.Default.reportsListBoxItems.Cast<string>()
.Aggregate((current, str) => current + str);
}
/// <summary> Then comes back here from FormClosing for the Below.
/// Because of Change == false; above, But only if !ForReal == true;
/// If (ForReal == true) then nothing needs to be brought back at-all.
/// </summary>
private void AbortChanges()
{
OPS.Default.dataListBoxItems.Clear();
foreach (var str in _data)
{ OPS.Default.dataListBoxItems.Add(str); }
OPS.Default.reportsListBoxItems.Clear();
foreach (var str in _reports)
{ OPS.Default.reportsListBoxItems.Add(str); }
OPS.Default.Schedule1 = _scheduler[0];
OPS.Default.Schedule3 = _scheduler[1];
OPS.Default.Schedule5 = _scheduler[2];
OPS.Default.Scheduled1 = _scheduled[0];
OPS.Default.Scheduled3 = _scheduled[1];
OPS.Default.Scheduled5 = _scheduled[2];
if (!string.IsNullOrEmpty(PrefFilename))
OPS.Default.PrefFileName = PrefFilename;
if (!string.IsNullOrEmpty(PrefRootDir))
OPS.Default.PrefRootDir = PrefRootDir;
if (!string.IsNullOrEmpty(PrefReports))
OPS.Default.PrefReportsDir = PrefReports;
OPS.Default.DoW = DayOfWeek;
OPS.Default.Save();
}
/// <summary> returns true if anything changed this run.
/// </summary>
/// <returns></returns>
private bool SettingsChanged()
{
if (CheckPrefs()) return true;
bool
s1 = _scheduler[0],
s3 = _scheduler[1],
s5 = _scheduler[2];
DateTime
t1 = _scheduled[0],
t3 = _scheduled[1],
t5 = _scheduled[2];
return
!s1.Equals(OPS.Default.Schedule1)
|| !s3.Equals(OPS.Default.Schedule3)
|| !s5.Equals(OPS.Default.Schedule5)
|| s1 && !t1.Equals(OPS.Default.Scheduled1)
|| s3 && !t3.Equals(OPS.Default.Scheduled3)
|| s5 && !t5.Equals(OPS.Default.Scheduled5)
|| CheckCollections()
|| !PrefFilename.Equals(OPS.Default.PrefFileName)
|| !PrefRootDir .Equals(OPS.Default.PrefRootDir)
|| !PrefReports .Equals(OPS.Default.PrefReportsDir)
|| !DayOfWeek .Equals(OPS.Default.DoW);
}
// Added v4.7.2.44 Apr 29 2017
private bool CheckPrefs()
{
var result = false;
if (string.IsNullOrEmpty(PrefFilename))
{
result = true;
var pf = AUS.Default.FileName;
if (!string.IsNullOrEmpty(pf)
&& File.Exists(AUS.Default.RootDir + "\\" + pf))
PrefFilename = OPS.Default.PrefFileName = pf;
else
PrefFilename = OPS.Default.PrefFileName =
APS.Default.defaultFilename;
}
if (string.IsNullOrEmpty(PrefRootDir))
{
result = true;
var pr = AUS.Default.RootDir;
if (!string.IsNullOrEmpty(pr)
&& Directory.Exists(pr))
PrefRootDir = OPS.Default.PrefRootDir = pr;
else
PrefRootDir = OPS.Default.PrefRootDir =
AUS.Default.AppDir + "\\" + APS.Default.Home;
}
if (string.IsNullOrEmpty(PrefReports))
{
result = true;
var rp = PMS.Default.ReportsFolder;
if (!string.IsNullOrEmpty(rp)
&& Directory.Exists(rp))
PrefReports = OPS.Default.PrefReportsDir = rp;
else
PrefReports = OPS.Default.PrefReportsDir =
AUS.Default.AppDir + "\\" + APS.Default.Home +
"\\" + PMS.Default.Reports;
}
if (PMS.Default.Bac_dataCollection.Equals(null))
{
result = true;
PMS.Default.Bac_dataCollection = new StringCollection();
}
if (PMS.Default.Bac_reportsCollection.Equals(null))
{
result = true;
PMS.Default.Bac_reportsCollection = new StringCollection();
}
if (result) OPS.Default.Save();
return result;
}
// ^v Both Return true if anything has changed.
private bool CheckCollections()
{
var line1 = Data;
var line2 = Reports;
CreateNewDetectionStrings();
return !line1.Equals(Data) || !line2.Equals(Reports);
}
#endregion Upgrade 4.7.0.07 Apr 13 2017
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
#endregion Alternate Folder Finder
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
}
}
Comments
0 B
|👍
/👎