public List <WorkerItem> GetWorkers(FilterFile filterFile = null, LogFile logFile = null)
{
SetStatus(string.Format("GetWorkers:enter:{0}, {1}",
filterFile == null ? "null" : filterFile.Tag,
logFile == null ? "null" : logFile.Tag));
List <WorkerItem> workerItems = new List <WorkerItem>();
if (filterFile != null && logFile != null)
{
workerItems = _workerManager.BGWorkers.Where(x => x.FilterFile == filterFile && x.LogFile == logFile).ToList();
if (workerItems.Count > 1)
{
SetStatus("Error:Getworkers:duplicate workers");
}
}
else if (filterFile != null)
{
workerItems = _workerManager.BGWorkers.Where(x => x.FilterFile == filterFile).ToList();
}
else if (logFile != null)
{
workerItems = _workerManager.BGWorkers.Where(x => x.LogFile == logFile).ToList();
}
else
{
workerItems = _workerManager.BGWorkers.ToList();
}
SetStatus("Getworkers:return:worker count:" + workerItems.Count);
return(workerItems);
}
private void FilterNotesExecuted()
{
if (CurrentFile() == null)
{
return;
}
FilterFile filterFile = (FilterFile)CurrentFile();
FilterNotesDialog dialog = new FilterNotesDialog(filterFile.FilterNotes);
dialog.Title = string.Format("{0} version:{1}", filterFile.FileName, filterFile.FilterVersion);
dialog.DialogCanSave = !filterFile.IsReadOnly;
filterFile.FilterNotes = dialog.WaitForResult();
if (!filterFile.IsReadOnly & !filterFile.IsNew)
{
FilterFile tempFilterFile = (FilterFile)ViewManager.ReadFile(filterFile.Tag);
tempFilterFile.FilterNotes = filterFile.FilterNotes;
tempFilterFile.Tag = filterFile.Tag;
// save only new notes to file.
((FilterFileManager)ViewManager).SaveFile(tempFilterFile.Tag, tempFilterFile);
}
else if (!filterFile.IsReadOnly & filterFile.IsNew)
{
// save new notes to current filter
filterFile.FilterNotes = filterFile.FilterNotes;
filterFile.Modified = true;
}
}
public override IFile <FilterFileItem> OpenFile(string fileName)
{
FilterFile filterFile = new FilterFile();
try
{
SetStatus("OpenFile:enter: " + fileName);
if (FileManager.Exists(x => String.Compare(x.Tag, fileName, true) == 0))
{
SetStatus("file already open:" + fileName);
return(filterFile);
}
filterFile = (FilterFile)ReadFile(fileName);
ManageFilterFileItem(filterFile);
ManageFileProperties(fileName, filterFile);
FileManager.Add(filterFile);
Settings.AddFilterFile(fileName);
OnPropertyChanged("FilterFileManager");
SetStatus("OpenFile:exit: " + fileName);
return(filterFile);
}
catch (Exception e)
{
SetStatus(string.Format("error opening filter file:{0}:{1}", fileName, e.ToString()));
return(filterFile);
}
}
public void InsertFilterItemExecuted(object sender)
{
SetStatus("InsertFilterItemExecuted");
FilterFile filterFile = (FilterFile)CurrentFile();
if (filterFile != null)
{
int filterIndex = 0;
if (CurrentTab().Viewer != null)
{
filterIndex = ((Selector)CurrentTab().Viewer).SelectedIndex;
}
// add content from logfileitem to new filter
if (sender is TextBox)
{
filterIndex = filterFile.ContentItems.Max(x => x.Index);
TextBox textBox = (sender as TextBox);
FilterFileItem fileItem = new FilterFileItem()
{
Enabled = true,
Index = -1,
Notes = textBox.Text,
Filterpattern = string.IsNullOrEmpty(textBox.SelectedText) ? textBox.Text : textBox.SelectedText
};
filterFile.ContentItems.Add(((FilterFileManager)ViewManager).SetFilterItemColors(filterFile, fileItem));
// set filterindex to -1 to add new filter item at beginning of list
filterIndex = -1;
}
((FilterFileManager)ViewManager).ManageFilterFileItem(filterFile, filterIndex);
VerifyIndex();
}
}
public void RemoveWorkersByFilterFile(FilterFile filterFile)
{
foreach (WorkerItem item in GetWorkers(filterFile))
{
RemoveWorker(item);
SetStatus(string.Format("RemoveWorkersByFilterFile:Removed worker:{0}", item.FilterFile == null ? "null" : item.FilterFile.Tag));
}
}
public override IFile <FilterFileItem> NewFile(string LogName, ObservableCollection <FilterFileItem> fileItems = null)
{
FilterFile filterFile = new FilterFile();
ManageFilterFileItem(filterFile);
FileManager.Add(ManageFileProperties(LogName, filterFile));
Settings.AddFilterFile(LogName);
OnPropertyChanged("FilterFileManager");
return(filterFile);
}
private void SyncFilterFiles()
{
foreach (FilterFile filterFile in CurrentFilterFiles())
{
if (!_previousFilterFiles.Exists(x => x == filterFile))
{
SetStatus("SyncFilterFiles:Adding entry");
_previousFilterFiles.Add(filterFile);
_workerManager.AddWorkersByWorkerItemFilterFile(new WorkerItem()
{
FilterFile = filterFile
});
}
}
foreach (FilterFile filterFile in CurrentFilterFiles())
{
if (_previousFilterFiles.Exists(x => x.Tag == filterFile.Tag))
{
FilterFile previousVersionFilterFile = _previousFilterFiles.First(x => x.Tag == filterFile.Tag);
// update list
_previousFilterFiles.Remove(previousVersionFilterFile);
}
SetStatus("SyncFilterFiles:saving entry for compare.");
FilterFile file = new FilterFile()
{
ContentItems = filterFile.ContentItems,
FileName = filterFile.FileName,
FilterNotes = filterFile.FilterNotes,
FilterVersion = filterFile.FilterVersion,
IsNew = filterFile.IsNew,
IsReadOnly = filterFile.IsReadOnly,
Modified = filterFile.Modified,
Tag = filterFile.Tag
};
_previousFilterFiles.Add(file);
}
foreach (FilterFile filterFile in new List <FilterFile>(_previousFilterFiles))
{
if (!CurrentFilterFiles().Exists(x => x == filterFile))
{
SetStatus("SyncFilterFiles:Removing entry");
_previousFilterFiles.Remove(filterFile);
_workerManager.RemoveWorkersByFilterFile(filterFile);
}
}
}
private void RemoveFilterItemExecuted(object sender)
{
SetStatus("RemoveeFilterItemExecuted");
FilterFile filterFile = (FilterFile)CurrentFile();
if (filterFile != null)
{
int filterIndex = 0;
filterIndex = ((Selector)CurrentTab().Viewer).SelectedIndex;
((FilterFileManager)ViewManager).ManageFilterFileItem(filterFile, filterIndex, true);
VerifyIndex();
}
}
public override List <IFile <FilterFileItem> > OpenFiles(string[] files)
{
List <IFile <FilterFileItem> > filterFileItems = new List <IFile <FilterFileItem> >();
foreach (string file in files)
{
FilterFile filterFile = new FilterFile();
if (String.IsNullOrEmpty((filterFile = (FilterFile)OpenFile(file)).Tag))
{
continue;
}
filterFileItems.Add(filterFile);
}
return(filterFileItems);
}
private void ViewManager_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
SetStatus("FilterViewModel.ViewManager_PropertyChanged: " + e.PropertyName);
if (sender is FilterFileItem)
{
FilterFile filterFile = (FilterFile)CurrentFile();
if (filterFile != null)
{
((FilterFileManager)ViewManager).ManageFilterFileItem(filterFile);
if (e.PropertyName == FilterFileItemEvents.Index)
{
VerifyIndex((sender as FilterFileItem));
}
SetCurrentStatus(CurrentStatusSetting.enter_to_filter);
}
}
//OnPropertyChanged(sender, e);
}
internal bool VerifyAndOpenFile(string fileName)
{
SetStatus(string.Format("checking filter file:{0}", fileName));
if (((FilterFileManager)ViewManager).FilterFileVersion(fileName) == FilterFileManager.FilterFileVersionResult.NotAFilterFile)
{
return(false);
}
FilterFile filterFile = new FilterFile();
if (String.IsNullOrEmpty((filterFile = (FilterFile)ViewManager.OpenFile(fileName)).Tag))
{
return(false);
}
AddTabItem(filterFile);
return(true);
}
public void DisplayAllDialogExecuted(object sender)
{
SetStatus("DisplayAllDialogExecuted");
try
{
LogFile lFile = ((LogFile)_LogViewModel.CurrentFile());
FilterFile fFile = null;
int index = 0;
if (((Selector)CurrentTab().Viewer).SelectedItem != null)
{
if (typeof(T) == typeof(LogFileItem))
{
index = (int?)((LogFileItem)((Selector)CurrentTab().Viewer).SelectedItem).FilterIndex ?? 0;
}
else
{
index = (int?)((FilterFileItem)((Selector)CurrentTab().Viewer).SelectedItem).Index ?? 0;
}
}
if (_FilterViewModel.CurrentFile() != null)
{
fFile = ((FilterFile)_FilterViewModel.CurrentFile());
}
if (lFile != null)
{
DisplayAllFile dialog = new DisplayAllFile(lFile, fFile, index.ToString());
dialog.Show();
}
else
{
SetStatus("DisplayAllExecuted:current file null!");
}
}
catch (Exception e)
{
SetStatus("Exception:DisplayAllDialogExecuted: " + e.ToString());
}
}
public override void SaveFileExecuted(object sender)
{
ITabViewModel <FilterFileItem> tabItem;
if (sender is TabItem)
{
tabItem = (ITabViewModel <FilterFileItem>)(sender as TabItem);
}
else
{
if (IsValidTabIndex())
{
tabItem = (ITabViewModel <FilterFileItem>)TabItems[SelectedIndex];
}
else
{
// can get here by having no filters and hitting save file.
// todo: disable save file if no tab items
return;
}
}
SetStatus(string.Format("FilterViewModel.SaveFileExecuted:header: {0} tag: {1}", tabItem.Header, tabItem.Tag, tabItem.Name));
//if (string.IsNullOrEmpty(tabItem.Tag) || Regex.IsMatch(tabItem.Tag, _tempTabNameFormatPattern, RegexOptions.IgnoreCase))
if (tabItem.IsNew)
{
// if saving new file
SaveFileAsExecuted(tabItem);
}
else
{
FilterFile file = (FilterFile)CurrentFile();
if (file != null)
{
tabItem.IsNew = false;
file.ContentItems = tabItem.ContentList;
ViewManager.SaveFile(tabItem.Tag, file);
}
}
}
public DisplayAllFile(LogFile logFile, FilterFile filterFile = null, string selectedIndex = "0")
{
LogFile = logFile;
FilterFile = filterFile;
Items = new ObservableCollection <LogFileItem>(logFile.ContentItems.Where(x => x.FilterIndex == Convert.ToInt32(selectedIndex)));
//FilterFileIndex = new ObservableCollection<string>() { "0", "1" };
FilterFileIndex.Add(selectedIndex);
Owner = Application.Current.MainWindow;
DataContext = this;
InitializeComponent();
_initialMessage = logFile.FileName;
Title = string.Format("{0} - {1}", _initialMessage, logFile.Tag);
UpdateLayout();
//https://stackoverflow.com/questions/11420500/applying-datatemplate-to-a-grid
//https://stackoverflow.com/questions/13246602/datatemplate-in-a-separate-resourcedictionary
//https://wpftutorial.net/DataViews.html
//http://mark-dot-net.blogspot.com/2008/12/list-filtering-in-wpf-with-m-v-vm.html
//https://stackoverflow.com/questions/20888619/proper-way-to-use-collectionviewsource-in-viewmodel
}
public override IFile <FilterFileItem> NewFile(string fileName, ObservableCollection <FilterFileItem> fileItems = null)
{
SetStatus("NewFile:enter: " + fileName);
FilterFile file = new FilterFile();
// make temp file
string tempFilePath = Path.GetTempFileName();
file.Tag = tempFilePath;
if (fileItems != null)
{
file.ContentItems = fileItems;
}
SaveFile(tempFilePath, file);
ManageFilterFileItem(file);
FileManager.Add(ManageFileProperties(fileName, file));
file.Tag = tempFilePath;
file.IsNew = true;
Settings.AddFilterFile(fileName);
OnPropertyChanged("FilterFileManager");
return(file);
}
private void VerifyIndex(FilterFileItem filterFileItem = null)
{
bool lockTaken = false;
try
{
_spinLock.TryEnter(ref lockTaken);
FilterFile filterFile = new FilterFile();
filterFile = (FilterFile)CurrentFile();
ObservableCollection <FilterFileItem> contentList = TabItems[SelectedIndex].ContentList;
// filterFile.EnablePatternNotifications(false);
ObservableCollection <FilterFileItem> contentItems = filterFile.ContentItems;
List <FilterFileItem> sortedFilterItems = new List <FilterFileItem>(contentItems.OrderBy(x => x.Index));
SetStatus(string.Format("VerifyIndex: contentList count: {0} contentItems count: {1}", contentList.Count, contentItems.Count));
if (filterFileItem != null)
{
SetStatus(string.Format("VerifyIndex: filterFileItem index: {0} pattern: {1}", filterFileItem.Index, filterFileItem.Filterpattern));
}
bool dupes = false;
bool needsSorting = false;
bool needsReIndexing = false;
List <int> indexList = new List <int>();
for (int i = 0; i < sortedFilterItems.Count; i++)
{
int orderedFilterItemIndex = sortedFilterItems[i].Index;
if (orderedFilterItemIndex != contentItems[i].Index)
{
// original index does not equal sorted index
needsSorting = true;
}
if (!indexList.Contains(orderedFilterItemIndex))
{
// add filter item to temp list for compare
indexList.Add(orderedFilterItemIndex);
}
else
{
// item already exists in temp list based on filter index
dupes = true;
}
if (i != orderedFilterItemIndex)
{
needsReIndexing = true;
}
}
// does index need to be modified?
if (!needsSorting && !dupes && !needsReIndexing)
{
// do nothing
return;
}
else
{
filterFile.EnablePatternNotifications(false);
// needs sorting or has dupes or needs reindexing
if (filterFileItem != null && sortedFilterItems.Count(x => x.Index == filterFileItem.Index) > 1)
{
// new / modifed filteritem index remove and insert selected item in list at
// lowest position in index of dupes
sortedFilterItems.RemoveAt(sortedFilterItems.IndexOf(filterFileItem));
sortedFilterItems.Insert((int)(sortedFilterItems.IndexOf(sortedFilterItems.First(x => x.Index == filterFileItem.Index))), filterFileItem);
}
// sync contentList
for (int i = 0; i < sortedFilterItems.Count; i++)
{
Debug.Print(string.Format("VerifyIndex:sync:sortedFilterItems index: {0} filterpattern: {1}", i, sortedFilterItems[i].Filterpattern));
Debug.Print(string.Format("VerifyIndex:sync:contentList index: {0} filterpattern: {1}", i, contentList[i].Filterpattern));
Debug.Print(string.Format("VerifyIndex:sync:contentItems index: {0} filterpattern: {1}", i, contentItems[i].Filterpattern));
contentList[i] = sortedFilterItems[i];
contentItems[i] = sortedFilterItems[i];
contentList[i].Index = i;
contentItems[i].Index = i;
}
filterFile.EnablePatternNotifications(true);
}
}
catch (LockRecursionException)
{
SetStatus("VerifyIndex:reentrant:skipping");
}
catch (Exception ex)
{
SetStatus("VerifyIndex:exception:" + ex.ToString());
}
finally
{
if (lockTaken)
{
_spinLock.Exit();
}
}
}
private WorkerItem ModifiedFilterFile()
{
SetStatus("Parser:ModifiedFilterFile:enter");
List <IFile <FilterFileItem> > currentFilterFiles = CurrentFilterFiles();
FilterFile currentFilterFile = CurrentFilterFile();
//LogFile currentLog = (LogFile)_logViewModel.CurrentFile();
if (currentFilterFiles == null) // || currentFilterFile == null)
{
// SyncFilterFiles();
return(new WorkerItem());
}
if (currentFilterFiles.Count > 0 && _previousFilterFiles.Count == currentFilterFiles.Count)
{
SetStatus("Parser:ModifiedFilterFile:same count");
WorkerItem filterFileWorkerItem = new WorkerItem()
{
WorkerModification = WorkerItem.Modification.Unknown,
FilterFile = currentFilterFile,
LogFile = (LogFile)_logViewModel.CurrentFile()
};
FilterNeed filterNeed = FilterNeed.Unknown;
//if (_previousFilterFiles.Contains(currentFilterFile))
if (_previousFilterFiles.Exists(x => x.Tag == currentFilterFile.Tag))
{
SetStatus("Parser:ModifiedFilterFile:have previous version");
FilterFile previousVersionFilterFile = _previousFilterFiles.First(x => x.Tag == currentFilterFile.Tag);
filterNeed = _FilterViewModel.CompareFilterList(previousVersionFilterFile.ContentItems.ToList());
}
else
{
filterNeed = FilterNeed.Filter;
}
if (currentFilterFile != _filterFilePrevious)
{
SetStatus("Parser:ModifiedFilterFile:current filter file changed");
filterFileWorkerItem.WorkerModification = WorkerItem.Modification.FilterIndex;
filterNeed = FilterNeed.Filter;
_filterFilePrevious = currentFilterFile;
}
switch (filterNeed)
{
case FilterNeed.Unknown:
case FilterNeed.ShowAll:
case FilterNeed.Filter:
case FilterNeed.ApplyColor:
filterFileWorkerItem.FilterNeed = filterNeed;
filterFileWorkerItem.WorkerModification = WorkerItem.Modification.FilterModified;
return(filterFileWorkerItem);
case FilterNeed.Current:
SetStatus("Parser:ModifiedFilterFile:current");
filterFileWorkerItem.FilterNeed = FilterNeed.Current;
filterFileWorkerItem.WorkerModification = WorkerItem.Modification.Unknown;
return(filterFileWorkerItem);
default:
break;
}
}
else if (_previousFilterFiles.Count < currentFilterFiles.Count)
{
SetStatus("Parser:ModifiedFilterFile:filter file added");
SyncFilterFiles();
EnableFilterFileMonitoring(true);
// todo : re parse current log with new filter
return(new WorkerItem()
{
FilterFile = CurrentFilterFile(),
FilterNeed = FilterNeed.Filter,
WorkerModification = WorkerItem.Modification.FilterAdded
});
}
else
{
SetStatus("Parser:ModifiedFilterFile:filter file removed");
SyncFilterFiles();
EnableFilterFileMonitoring(false);
// todo : re parse current log with new filter
return(new WorkerItem()
{
FilterFile = CurrentFilterFile(),
FilterNeed = FilterNeed.Filter,
WorkerModification = WorkerItem.Modification.FilterRemoved
});
}
return(new WorkerItem()
{
FilterNeed = FilterNeed.Unknown,
WorkerModification = WorkerItem.Modification.Unknown
});
}
public override void SaveFileAsExecuted(object sender)
{
ITabViewModel <FilterFileItem> tabItem;
if (sender is TabItem)
{
tabItem = (ITabViewModel <FilterFileItem>)(sender as TabItem);
}
else
{
if (IsValidTabIndex())
{
tabItem = (ITabViewModel <FilterFileItem>)TabItems[SelectedIndex];
}
else
{
return;
}
}
bool silent = (sender is string && !String.IsNullOrEmpty(sender as string)) ? true : false;
string logName = string.Empty;
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.DefaultExt = ".rvf";
dlg.Filter = "Filter Files (*.rvf;*.xml)|*.rvf;*.xml|Tat Files (*.tat)|*.tat|All Files (*.*)|*.*";
dlg.InitialDirectory = Path.GetDirectoryName(tabItem.Tag) ?? Settings.FilterDirectory;
string extension = string.IsNullOrEmpty(Path.GetExtension(tabItem.Tag)) ? ".rvf" : Path.GetExtension(tabItem.Tag);
string fileName = Path.GetFileNameWithoutExtension(tabItem.Tag) + extension;
dlg.FileName = fileName;
Nullable <bool> result = false;
// Show save file dialog box
if (silent)
{
result = true;
logName = (sender as string);
}
else
{
result = dlg.ShowDialog();
logName = dlg.FileName;
if (string.IsNullOrEmpty(logName))
{
return;
}
}
// Process save file dialog box results
if (result == true)
{
// Save document
SetStatus(string.Format("saving file:{0}", logName));
RenameTabItem(logName);
// SaveFileExecuted(null);
FilterFile file = (FilterFile)CurrentFile();
if (file != null)
{
tabItem.IsNew = false;
file.ContentItems = tabItem.ContentList;
ViewManager.SaveFile(tabItem.Tag, file);
}
}
return;
}
public void ManageFilterFileItem(FilterFile filterFile, int filterIndex = -1, bool remove = false)
{
// add blank new item so defaults / modifications can be set some type of bug
IEnumerable <FilterFileItem> results = null;
int indexMax = -1;
SetStatus("ManageNewFilterFileItem:" + filterFile.FileName);
results = filterFile.ContentItems.Where(x => x.Enabled == false &&
x.Exclude == false &&
x.Regex == false &&
string.IsNullOrEmpty(x.Filterpattern) &&
string.IsNullOrEmpty(x.Notes));
if (filterFile.ContentItems.Count > 0)
{
// valid enabled filter count
indexMax = filterFile.ContentItems.Max(x => x.Index);
}
if (results == null | results != null && results.Count() == 0 | filterIndex >= 0)
{
// no empty / new filter item or index ge 0 (insert or remove)
FilterFileItem fileItem = new FilterFileItem();
filterFile.EnablePatternNotifications(false);
fileItem.Index = indexMax + 1;
SetStatus("ManageNewFilterFileItem:adding new line");
if (filterIndex >= 0 && !remove)
{
// insert in new enabled filter item at specified index
fileItem.Enabled = true;
fileItem.Index = filterIndex;
fileItem = SetFilterItemColors(filterFile, fileItem);
filterFile.AddPatternNotification(fileItem, true);
filterFile.ContentItems.Insert(filterIndex, fileItem);
}
else if (filterIndex >= 0 && remove)
{
// remove old filter item at specified index
filterFile.AddPatternNotification(fileItem, false);
filterFile.ContentItems.RemoveAt(filterIndex);
}
else
{
// add at end
fileItem = SetFilterItemColors(filterFile, fileItem);
filterFile.AddPatternNotification(fileItem, true);
filterFile.ContentItems.Add(fileItem);
}
filterFile.EnablePatternNotifications(true);
}
else if (results.Count() == 1)
{
if (results.ToList()[0].Index != indexMax)
{
filterFile.EnablePatternNotifications(false);
results.ToList()[0].Index = indexMax + 1;
filterFile.EnablePatternNotifications(true);
}
return;
}
else
{
for (int i = 0; i < results.Count() - 1; i++)
{
filterFile.ContentItems.Remove(results.ToList()[i]);
}
}
}
public FilterFileItem SetFilterItemColors(FilterFile filterFile, FilterFileItem fileItem)
{
if (!Settings.AutoPopulateColors)
{
return(fileItem);
}
// string backgroundColor = fileItem.BackgroundColor;
string backgroundColor = TextFilterSettings.Settings.BackgroundColorString; // Settings.GetColorNames().ElementAt(new Random().Next(Settings.WebColors.Count - 1));
bool preferredColors = true;
List <string> backgroundColors = new List <string>();
while (backgroundColor != null)
{
List <string> contrastColors = TextFilterSettings.Settings.GetContrastingColors(TextFilterSettings.Settings.GetColor(backgroundColor), preferredColors);
foreach (FilterFileItem item in filterFile.ContentItems)
{
Debug.Print("SetFilterItemColors:checking background colors: filterFileItem:{0} backgroundColor:{1}", item.BackgroundColor, backgroundColor);
if (item.BackgroundColor == backgroundColor)
{
Debug.Print("SetFilterItemColors:checking foreground colors: filterFileItem:{0} contrastColors:{1}", item.ForegroundColor, contrastColors.Contains(item.ForegroundColor));
if (contrastColors.Contains(item.ForegroundColor))
{
contrastColors.Remove(item.ForegroundColor);
}
}
}
if (contrastColors.Count > 0)
{
//TextFilterSettings.Settings.FilterBackgroundColorDefaultString = backgroundColor;
fileItem.BackgroundColor = backgroundColor;
fileItem.ForegroundColor = contrastColors
.ToList()
.ElementAtOrDefault((new Random()
.Next(contrastColors.Count - 1)));
filterFile.Modified = true;
break;
}
backgroundColors.Add(backgroundColor);
if (!backgroundColors.Contains(TextFilterSettings.Settings.ForegroundColorString))
{
// use foreground color after background color
backgroundColor = TextFilterSettings.Settings.ForegroundColorString;
}
else
{
// use contrasting color
backgroundColor = TextFilterSettings.Settings
.GetContrastingColors(TextFilterSettings.Settings.GetColor(backgroundColor), preferredColors)
.ToList()
.Where(x => !backgroundColors.Contains(x))
.FirstOrDefault();
}
if (backgroundColor == null && !preferredColors)
{
break;
}
else if (backgroundColor == null && preferredColors)
{
preferredColors = false;
backgroundColor = TextFilterSettings.Settings
.GetContrastingColors(TextFilterSettings.Settings.GetColor(backgroundColor), preferredColors)
.ToList()
.Where(x => !backgroundColors.Contains(x))
.FirstOrDefault();
}
}
return(fileItem);
}
public override bool SaveFile(string fileName, IFile <FilterFileItem> file)
{
FilterFile filterFile = (FilterFile)file;
filterFile.IsNew = false;
SetStatus("SaveFile:enter: " + fileName);
if (string.IsNullOrEmpty(fileName))
{
fileName = filterFile.FileName;
}
try
{
SetStatus("saving file:" + fileName);
if (Path.GetExtension(fileName).ToLower().Contains("tat"))
{
if (SaveTatFile(fileName, filterFile.ContentItems))
{
return(true);
}
else
{
return(false);
}
}
XmlTextWriter xmlw = new XmlTextWriter(fileName, System.Text.Encoding.UTF8);
xmlw.Formatting = Formatting.Indented;
xmlw.WriteStartDocument();
xmlw.WriteStartElement("filterinfo");
xmlw.WriteStartElement("filterversion");
xmlw.WriteString(DateTime.Now.ToString("yy-MM-dd-hh-mm-ss"));
xmlw.WriteEndElement();
xmlw.WriteStartElement("filternotes");
xmlw.WriteString(filterFile.FilterNotes);
xmlw.WriteEndElement();
xmlw.WriteStartElement("filters");
foreach (FilterFileItem item in filterFile.ContentItems)
{
xmlw.WriteStartElement("filter");
xmlw.WriteStartElement("filterpattern");
xmlw.WriteString(item.Filterpattern);
xmlw.WriteEndElement();
xmlw.WriteStartElement("backgroundcolor");
xmlw.WriteString(item.BackgroundColor);
xmlw.WriteEndElement();
xmlw.WriteStartElement("foregroundcolor");
xmlw.WriteString(item.ForegroundColor);
xmlw.WriteEndElement();
xmlw.WriteStartElement("casesensitive");
xmlw.WriteString(item.CaseSensitive.ToString());
xmlw.WriteEndElement();
xmlw.WriteStartElement("index");
xmlw.WriteString(item.Index.ToString());
xmlw.WriteEndElement();
xmlw.WriteStartElement("enabled");
xmlw.WriteString(item.Enabled.ToString());
xmlw.WriteEndElement();
xmlw.WriteStartElement("exclude");
xmlw.WriteString(item.Exclude.ToString());
xmlw.WriteEndElement();
xmlw.WriteStartElement("regex");
xmlw.WriteString(item.Regex.ToString());
xmlw.WriteEndElement();
xmlw.WriteStartElement("notes");
xmlw.WriteString(item.Notes.ToString());
xmlw.WriteEndElement();
xmlw.WriteEndElement();
}
xmlw.WriteEndElement();
xmlw.WriteEndElement();
xmlw.WriteEndDocument();
xmlw.Close();
SetStatus("SaveFile:exit: " + fileName);
return(true);
}
catch (UnauthorizedAccessException ex)
{
filterFile.IsReadOnly = true;
SetStatus("Fatal:SaveFile:exception" + ex.ToString());
return(false);
}
catch (Exception e)
{
SetStatus("Fatal:SaveFile:exception: " + e.ToString());
return(false);
}
}
public override IFile <FilterFileItem> ReadFile(string fileName)
{
FilterFile filterFile = new FilterFile();
try
{
SetStatus("ReadFile:enter: " + fileName);
filterFile.FileName = Path.GetFileName(fileName);
if (Path.GetExtension(fileName).ToLower().Contains("tat"))
{
filterFile.ContentItems = new ObservableCollection <FilterFileItem>(ReadTatFile(fileName));
filterFile.IsNew = false;
return(filterFile);
}
FilterFileVersionResult filterFileVersion = FilterFileVersion(fileName);
if (filterFileVersion == FilterFileVersionResult.NotAFilterFile)
{
return(filterFile);
}
XmlDocument doc = new XmlDocument();
doc.Load(fileName);
// see if file is readonly
try
{
doc.Save(fileName);
}
catch
{
filterFile.IsReadOnly = true;
}
XmlNode root = doc.DocumentElement;
// for v2 documentelement is filterInfo
if (filterFileVersion != FilterFileVersionResult.Version1)
{
filterFile.FilterVersion = ReadStringNodeItem(root, "filterversion");
filterFile.FilterNotes = ReadStringNodeItem(root, "filternotes");
}
if (root.Name.ToLower() != "filters")
{
foreach (XmlNode node in root.ChildNodes)
{
if (node.Name.ToLower() == "filters")
{
root = node;
break;
}
}
}
filterFile.IsNew = false;
filterFile.ContentItems = new ObservableCollection <FilterFileItem>();
for (int i = 0; i < root.ChildNodes.Count; i++)
{
FilterFileItem fileItem = new FilterFileItem();
fileItem.Count = 0;
if (string.IsNullOrEmpty(ReadStringNodeChildItem(root, "backgroundcolor", i))
& string.IsNullOrEmpty(ReadStringNodeChildItem(root, "foregroundcolor", i)))
{
if (_FilterViewModel != null)
{
fileItem = SetFilterItemColors(filterFile, fileItem);
}
}
if (!string.IsNullOrEmpty(ReadStringNodeChildItem(root, "backgroundcolor", i)))
{
fileItem.BackgroundColor = ReadStringNodeChildItem(root, "backgroundcolor", i);
}
fileItem.CaseSensitive = ReadBoolNodeChildItem(root, "casesensitive", i);
fileItem.Enabled = ReadBoolNodeChildItem(root, "enabled", i);
fileItem.Exclude = ReadBoolNodeChildItem(root, "exclude", i);
fileItem.Regex = ReadBoolNodeChildItem(root, "regex", i);
fileItem.Filterpattern = ReadStringNodeChildItem(root, "filterpattern", i);
if (!string.IsNullOrEmpty(ReadStringNodeChildItem(root, "foregroundcolor", i)))
{
fileItem.ForegroundColor = ReadStringNodeChildItem(root, "foregroundcolor", i);
}
fileItem.Index = ReadIntNodeChildItem(root, "index", i);
fileItem.Notes = ReadStringNodeChildItem(root, "notes", i);
filterFile.ContentItems.Add(fileItem);
}
SetStatus("ReadFile:exit: " + fileName);
return(filterFile);
}
catch (Exception e)
{
SetStatus("Fatal:Readfile:exception" + e.ToString());
return(filterFile);
}
}
