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); } }