Audio alerts for agent missions

Automatic full data refresh
Continued attempts to mitigate crash on login
Method of disabling login alerts
Attempt to detect some odd edge cases in agent data
Icon for viewer

Author: Earthfiredrake

App/Clockwatcher.csproj

@@ -51,9 +51,13 @@
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>Resources\CWIcon.ico</ApplicationIcon>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Core" />
@@ -125,5 +129,13 @@
       <Install>false</Install>
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\CWIcon.ico" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="sfx\AgentAlert.wav">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

App/Dataset.cs

@@ -15,41 +15,45 @@
 using System.Xml.Linq;
 
 namespace Clockwatcher {
-    internal class Dataset {
+    internal sealed class Dataset {
         internal Dataset() {
-            ClearReadyCommand = new CommandWrapper(o => ClearReady(), o => true);
-            RefreshCommand = new CommandWrapper(o => Refresh(true), o => true);
-            RefreshTimer.Elapsed += (sender, e) => Refresh(false);
-            Refresh(true);
+            TabPanels.Add(Settings);
+
+            RefreshTimer.Elapsed += (sender, e) => Refresh();
+
+            Refresh();
         }
 
-        private void Refresh(bool reload) {
+        private void Refresh() {
             RefreshTimer.Enabled = false;
-            if (reload) { // Load settings files
+            try {
+                // Load settings files
                 foreach (var charFile in FindCharacterFiles()) {
                     var charData = ExtractCharacterMissions(charFile);
                     if (charData != null) {
                         var existing = (from e in CharacterMissionLists
-                                        where e.CharName == charData.CharName
+                                        where e.TabName == charData.TabName
                                         select e).SingleOrDefault();
                         if (existing != null) { // Merge with existing character record
                             existing.Merge(charData.TimerList);
                         } else { // Add new character
                             CharacterMissionLists.Add(charData);
+                            TabPanels.Insert(TabPanels.Count - 1, charData);
                         }
                     }
                 }
-            }
-            // Update time displays
-            foreach (var m in from c in CharacterMissionLists
-                              from m in c.TimerList
-                              select m) { m.Refresh(reload); }
-            RefreshTimer.Enabled = true;
-        }
 
-        private void ClearReady() {
-            foreach (var character in CharacterMissionLists) {
-                character.ClearReady();
+                // Update time displays and trigger alert states
+                if ((from c in CharacterMissionLists
+                     from m in c.TimerList
+                     where m.Refresh(Settings.AlertFilter)
+                     select m).ToList().Any()) {
+                    RaiseAlert?.Invoke(this, EventArgs.Empty);
+                }
+            } finally {
+                // Unhandled exceptions were causing the refresh timer to stop
+                // A bit of an issue now that there's no way to restart it
+                RefreshTimer.Enabled = true;
             }
         }
 
@@ -62,23 +66,25 @@ from character in Directory.EnumerateDirectories(account, CharDirFilter)
         private CharacterTimers ExtractCharacterMissions(string settingsFilePath) {
             Debug.Assert(File.Exists(settingsFilePath));
             try {
-                var trackerData = (from e in XElement.Load(settingsFilePath).Elements("Archive")
-                                   where (string)e.Attribute("name") == CWArchiveName
-                                   select e).SingleOrDefault();
-                // Mod not in use on this character (no mod archive), no tab required
-                // Characters who only lack mission entries, are listed to show they have no cooldowns active
-                if (trackerData == null) { return null; }
-                // Character name should be in saved data, otherwise use the Char# folder name which isn't so informative
-                var charName = ((string)(from e in trackerData.Elements("String")
-                                         where (string)e.Attribute("name") == "CharName"
-                                         select e).SingleOrDefault()?.Attribute("value"))?.Trim('"')
-                                ?? Directory.GetParent(settingsFilePath).Name;
-                // Coerce the serialization difference between a single and multi element array into a single IEnumerable
-                var missions = from e in EnumerateArchiveEntry(trackerData, "MissionCD")
-                               select new MissionTimer(((string)e.Attribute("value")).Trim('"'));
-                var agents = from e in EnumerateArchiveEntry(trackerData, "AgentCD")
-                             select new AgentTimer(((string)e.Attribute("value")).Trim('"'));
-                return new CharacterTimers(charName, Enumerable.Empty<TimerEntry>().Concat(missions).Concat(agents));
+                using (Stream file = new FileStream(settingsFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
+                    var trackerData = (from e in XElement.Load(file).Elements("Archive")
+                                       where e.Attribute("name").Value == CWArchiveName
+                                       select e).SingleOrDefault();
+                    // Mod not in use on this character (no mod archive), no tab required
+                    // Characters who only lack mission entries, are listed to show they have no cooldowns active
+                    if (trackerData == null) { return null; }
+                    // Character name should be in saved data, otherwise use the Char# folder name which isn't so informative
+                    var charName = (from e in trackerData.Elements("String")
+                                    where e.Attribute("name").Value == "CharName"
+                                    select e).SingleOrDefault()?.Attribute("value").Value?.Trim('"')
+                                    ?? Directory.GetParent(settingsFilePath).Name;
+                    // Coerce the serialization difference between a single and multi element array into a single IEnumerable
+                    var missions = from e in EnumerateArchiveEntry(trackerData, "MissionCD")
+                                   select new MissionTimer((e.Attribute("value").Value).Trim('"'));
+                    var agents = from e in EnumerateArchiveEntry(trackerData, "AgentCD")
+                                 select new AgentTimer((e.Attribute("value").Value).Trim('"'));
+                    return new CharacterTimers(charName, Enumerable.Empty<TimerEntry>().Concat(missions).Concat(agents));
+                }
             } catch (IOException) {
                 // File in use or other issue... either way no data from this one, so skip it
                 return null;
@@ -95,9 +101,13 @@ private IEnumerable<XElement> EnumerateArchiveEntry(XElement archive, string tag
                         select e);
         }
 
-        public ICollection<CharacterTimers> CharacterMissionLists { get; } = new ObservableCollection<CharacterTimers>();
+        public ConfigPanel Settings { get; } = new ConfigPanel();
+        public IList<TabPanelData> TabPanels { get; } = new ObservableCollection<TabPanelData>();
         public ICommand RefreshCommand { get; }
-        public ICommand ClearReadyCommand { get; }
+
+        public event EventHandler RaiseAlert;
+
+        private ICollection<CharacterTimers> CharacterMissionLists = new List<CharacterTimers>();
         private readonly Timer RefreshTimer = new Timer(5000);
 
         private static readonly string PrefsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Funcom", "SWL", "Prefs");
@@ -107,19 +117,77 @@ private IEnumerable<XElement> EnumerateArchiveEntry(XElement archive, string tag
         private const string CWArchiveName = "efdClockwatcherMissionList";
     }
 
-    // Nested data
+    internal abstract class TabPanelData : INotifyPropertyChanged {
+        protected internal TabPanelData(string name) {
+            TabName = name;
+        }
+
+        public string TabName { get; }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+        protected virtual void RaisePropertyChanged(string propertyName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
 
-    internal class CharacterTimers : INotifyPropertyChanged {
-        internal CharacterTimers(string charName, IEnumerable<TimerEntry> timers) {
-            CharName = charName;
+    internal sealed class ConfigPanel : TabPanelData {
+        internal ConfigPanel() : base("Settings") {
+            LoadConfig();
+        }
+
+        private void LoadConfig() {
+            var settingsFile = Path.Combine(SettingsDir, SettingsFile);
+            if (File.Exists(settingsFile)) {
+                using (var stream = new FileStream(settingsFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
+                    var settings = XElement.Load(stream);
+                    EnableAudioAlerts = Boolean.Parse(settings.Element("AgentAudioAlert").Attribute("Enabled").Value);
+                }
+            }
+        }
 
-            TimerList = new ObservableCollection<TimerEntry>(timers);
+        private void SaveConfig() {
+            var settings = new XElement("Settings",
+                new XElement("AgentAudioAlert",
+                    new XAttribute("Enabled", EnableAudioAlerts)
+                ));
+            Directory.CreateDirectory(SettingsDir);
+            settings.Save(Path.Combine(SettingsDir, SettingsFile));
+        }
+
+        protected override sealed void RaisePropertyChanged(string propertyName) {
+            base.RaisePropertyChanged(propertyName);
+            SaveConfig();
+        }
+
+        public bool EnableAudioAlerts {
+            get { return _EnableAudioAlerts; }
+            set {
+                if (value != _EnableAudioAlerts) {
+                    _EnableAudioAlerts = value;
+                    RaisePropertyChanged(nameof(EnableAudioAlerts));
+                }
+            }
+        }
+        public string AlertSoundFileName { get; } = "sfx\\AgentAlert.wav";
+
+        internal TimerClass AlertFilter { get; } = TimerClass.Agent;
+
+        private bool _EnableAudioAlerts = true;
+        private string SettingsDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Funcom", "SWL", "Mods", "Clockwatcher");
+        private string SettingsFile = "ViewerSettings.xml";
+    }
+
+    // Nested data
+
+    internal sealed class CharacterTimers : TabPanelData {
+        internal CharacterTimers(string charName, IEnumerable<TimerEntry> timers) :
+            base(charName) {
 
             var view = CollectionViewSource.GetDefaultView(TimerList);
             view.SortDescriptions.Add(new SortDescription(nameof(TimerEntry.RemainingTime), ListSortDirection.Ascending));
             ((ICollectionViewLiveShaping)view).IsLiveSorting = true;
 
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(TimerList)));
+            foreach (var timer in timers) { TimerList.Add(timer); }
+
+            ClearReadyCommand = new CommandWrapper(o => ClearReady(), o => true);
         }
 
         internal void Merge(IEnumerable<TimerEntry> other) {
@@ -128,25 +196,33 @@ internal void Merge(IEnumerable<TimerEntry> other) {
                 if (existing != null) {
                     existing.UnlockTime = t.UnlockTime;
                     if (existing.Class != t.Class) { existing.ChangeTimerClass(t.Class); }
-                } else { TimerList.Add(t); }
+                } else if (!t.IsReady) {
+                    App.Current.Dispatcher.Invoke(() => TimerList.Add(t));
+                }
             }
         }
 
-        internal void ClearReady() {
+        private void ClearReady() {
             foreach (var tReady in (from t in TimerList
-                               where t.IsReady
-                               select t).ToList()) {
+                                    where t.IsReady
+                                    select t).ToList()) {
                 TimerList.Remove(tReady);
             }
         }
 
-        public event PropertyChangedEventHandler PropertyChanged;
-
-        public string CharName { get; }
-        public ICollection<TimerEntry> TimerList { get; }
+        public ICommand ClearReadyCommand { get; }
+        public ICollection<TimerEntry> TimerList { get; } = new ObservableCollection<TimerEntry>();
     }
 
-    internal enum TimerClass { AgentMission, AgentRecovery, Lair, Mission }
+    [Flags]
+    internal enum TimerClass {
+        None = 0,
+        AgentMission = 1,
+        AgentRecovery = 2,
+        Agent = AgentMission | AgentRecovery,
+        Lair = 4,
+        Mission = 8
+    }
 
     internal abstract class TimerEntry : INotifyPropertyChanged {
 
@@ -157,7 +233,11 @@ protected internal TimerEntry(string entryData) {
             UnlockTime = DateTimeOffset.FromUnixTimeSeconds(long.Parse(dataFields[1])).LocalDateTime;
         }
 
-        internal void Refresh(bool reload) => RaisePropertyChanged(nameof(RemainingTime));
+        internal bool Refresh(TimerClass alertFilter) {
+            RaisePropertyChanged(nameof(RemainingTime));
+            return IsReady != AlertDone ? (AlertDone = IsReady) && ((alertFilter & Class) != TimerClass.None) : false;
+        }
+
         internal abstract void ChangeTimerClass(TimerClass newClass);
 
         internal int ID { get; }
@@ -167,12 +247,14 @@ protected internal TimerEntry(string entryData) {
         internal bool IsReady => RemainingTime.TotalSeconds <= 0;
 
         public event PropertyChangedEventHandler PropertyChanged;
-        protected void RaisePropertyChanged(string propertyName) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); }
+        protected void RaisePropertyChanged(string propertyName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
 
         public abstract TimerClass Class { get; }
+
+        private bool AlertDone = false;
     }
 
-    internal class AgentTimer : TimerEntry, INotifyPropertyChanged {
+    internal sealed class AgentTimer : TimerEntry, INotifyPropertyChanged {
         internal AgentTimer(string agentInfo) : base(agentInfo) {
             IsRecovering = Boolean.Parse(agentInfo.Split('|')[3]);
         }
@@ -186,18 +268,18 @@ internal override void ChangeTimerClass(TimerClass newClass) {
         public override TimerClass Class => IsRecovering ? TimerClass.AgentRecovery : TimerClass.AgentMission;
     }
 
-    internal class MissionTimer : TimerEntry {
+    internal sealed class MissionTimer : TimerEntry {
         internal MissionTimer(string missionInfo) : base(missionInfo) { }
 
         // Mission classes are unique by ID, they should not change
-        internal override void ChangeTimerClass(TimerClass newClass) { throw new NotSupportedException(); }
+        internal override void ChangeTimerClass(TimerClass newClass) => throw new NotSupportedException();
 
         public override TimerClass Class => ID > 0 ? TimerClass.Mission : TimerClass.Lair;
     }
 
     // Helper classes
 
-    internal class CommandWrapper : ICommand {
+    internal sealed class CommandWrapper : ICommand {
         public event EventHandler CanExecuteChanged;
 
         internal CommandWrapper(Action<object> execute, Func<object, bool> canExecute) {