Store watch expressions between FD sessions.

Introduced a WatchManager class so plugin developers can work with watched expressions in a better way. Surely to get some changes when the hxcpp work gets finished.

Author: Neverbirth

External/Plugins/FlashDebugger/Controls/WatchUI.cs

@@ -1,7 +1,7 @@
 using System;
-using System.Collections.Generic;
 using System.Windows.Forms;
 using FlashDebugger.Controls.DataTree;
+using FlashDebugger.Debugger;
 using PluginCore;
 using PluginCore.Localization;
 using flash.tools.debugger;
@@ -12,20 +12,26 @@ namespace FlashDebugger.Controls
     public class WatchUI : DockPanelControl
     {
         private DataTreeControl treeControl;
-        private List<string> watches;
+        private WatchManager watchManager;
 
-        public WatchUI()
+        public WatchUI(WatchManager watchManager)
         {
             this.AutoKeyHandling = true;
-            watches = new List<string>();
-            treeControl = new DataTreeControl(true);
+            this.treeControl = new DataTreeControl(true);
             this.treeControl.Tree.BorderStyle = BorderStyle.None;
             this.treeControl.Resize += new EventHandler(this.TreeControlResize);
             this.treeControl.Tree.Font = PluginBase.Settings.DefaultFont;
             this.treeControl.Dock = DockStyle.Fill;
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
             this.Controls.Add(this.treeControl);
+
+            this.watchManager = watchManager;
+            this.watchManager.ExpressionAdded += WatchManager_ExpressionAdded;
+            this.watchManager.ExpressionRemoved += WatchManager_ExpressionRemoved;
+            this.watchManager.ExpressionReplaced += WatchManager_ExpressionReplaced;
+            this.watchManager.ExpressionsCleared += WatchManager_ExpressionsCleared;
+            this.watchManager.ExpressionsLoaded += WatchManager_ExpressionsLoaded;
         }
 
         private void TreeControlResize(Object sender, EventArgs e)
@@ -35,50 +41,63 @@ private void TreeControlResize(Object sender, EventArgs e)
             this.treeControl.Tree.Columns[1].Width = w - 8;
         }
 
-        public bool AddElement(string item)
+        private void WatchManager_ExpressionAdded(Object sender, WatchExpressionArgs e)
+        {
+            treeControl.Nodes.Insert(e.Position, GetExpressionNode(e.Expression));
+            UpdateElements();
+        }
+
+        private void WatchManager_ExpressionRemoved(Object sender, WatchExpressionArgs e)
+        {
+            UpdateElements();
+        }
+
+        private void WatchManager_ExpressionReplaced(Object sender, WatchExpressionReplaceArgs e)
+        {
+            treeControl.Nodes[e.Position] = GetExpressionNode(e.NewExpression);
+        }
+
+        private void WatchManager_ExpressionsCleared(Object sender, EventArgs e)
+        {
+            treeControl.Nodes.Clear();
+        }
+
+        private void WatchManager_ExpressionsLoaded(Object sender, EventArgs e)
         {
-            if (watches.Contains(item)) return false;
-            watches.Add(item);
-            treeControl.Nodes.Insert(watches.Count - 1, GetExpressionNode(item));
             UpdateElements();
-            return true;
+        }
+
+        public bool AddElement(string item)
+        {
+            return watchManager.Add(item);
         }
 
         public void RemoveElement(string item)
         {
-            if (watches.Remove(item)) UpdateElements();
+            watchManager.Remove(item);
         }
 
         public void RemoveElement(int itemN)
         {
-            if (itemN < watches.Count) watches.RemoveAt(itemN);
-            treeControl.Nodes.RemoveAt(itemN);
+            watchManager.RemoveAt(itemN);
         }
 
         public bool ReplaceElement(string oldItem, string newItem)
         {
-            if (watches.Contains(newItem)) return false;
-            int itemN = watches.IndexOf(oldItem);
-            if (itemN == -1) AddElement(newItem);
-            else
-            {
-                watches[itemN] = newItem;
-                treeControl.Nodes[itemN] = GetExpressionNode(newItem);
-            }
-            return true;
+            return watchManager.Replace(oldItem, newItem);
         }
 
         public void Clear()
         {
-            watches.Clear();
-            treeControl.Nodes.Clear();
+            watchManager.ClearAll();
         }
 
         public void UpdateElements()
         {
             treeControl.Tree.BeginUpdate();
             treeControl.SaveState();
             treeControl.Nodes.Clear();
+            var watches = watchManager.Watches;
             foreach (string item in watches)
             {
                 treeControl.AddNode(GetExpressionNode(item));

External/Plugins/FlashDebugger/Debugger/WatchManager.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using PluginCore;
+using PluginCore.Helpers;
+using PluginCore.Utilities;
+
+namespace FlashDebugger.Debugger
+{
+    public class WatchManager
+    {
+        private IProject m_Project;
+        private string m_SaveFileFullPath;
+        private List<string> m_WatchList = new List<string>();
+
+        public event EventHandler<WatchExpressionArgs> ExpressionAdded;
+        public event EventHandler<WatchExpressionArgs> ExpressionRemoved;
+        public event EventHandler<WatchExpressionReplaceArgs> ExpressionReplaced;
+        public event EventHandler ExpressionsCleared;
+        public event EventHandler ExpressionsLoaded;
+
+        public IList<string> Watches
+        {
+            get { return m_WatchList.AsReadOnly(); }
+        }
+
+        public IProject Project
+        {
+            get { return m_Project; }
+            set
+            {
+                if (value != null)
+                {
+                    m_Project = value;
+                    this.ClearAll();
+                    m_SaveFileFullPath = GetWatchFile(m_Project.ProjectPath);
+                }
+            }
+        }
+
+        private string GetWatchFile(string path)
+        {
+            String dataDir = Path.Combine(PathHelper.DataDir, "FlashDebugger");
+            String cacheDir = Path.Combine(dataDir, "Watch");
+            if (!Directory.Exists(cacheDir)) Directory.CreateDirectory(cacheDir);
+            String hashFileName = HashCalculator.CalculateSHA1(path);
+            return Path.Combine(cacheDir, hashFileName + ".xml");
+        }
+
+        public void ClearAll()
+        {
+            m_WatchList.Clear();
+            OnExpressionsCleared(EventArgs.Empty);
+        }
+
+        public bool Add(string expr)
+        {
+            if (m_WatchList.Contains(expr)) return false;
+            m_WatchList.Add(expr);
+            OnExpressionAdded(expr, m_WatchList.Count - 1);
+            return true;
+        }
+
+        public void InsertAt(int index, string expr)
+        {
+            m_WatchList.Insert(index, expr);
+            OnExpressionAdded(expr, index);
+        }
+
+        public bool Remove(string expr)
+        {
+            int index = m_WatchList.IndexOf(expr);
+            if (index > -1)
+            {
+                m_WatchList.RemoveAt(index);
+                OnExpressionRemoved(expr, index);
+                return true;
+            }
+            return false;
+        }
+
+        public bool RemoveAt(int index)
+        {
+            if (index >= m_WatchList.Count || index < 0)
+                return false;
+
+            string expr = m_WatchList[index];
+            m_WatchList.RemoveAt(index);
+            OnExpressionRemoved(expr, index);
+            return true;
+        }
+
+        public bool Replace(string oldItem, string newItem)
+        {
+            if (m_WatchList.Contains(newItem)) return false;
+            int itemN = m_WatchList.IndexOf(oldItem);
+            if (itemN == -1) Add(newItem);
+            else
+            {
+                m_WatchList[itemN] = newItem;
+                OnExpressionReplaced(oldItem, newItem, itemN);
+            }
+            return true;
+        }
+
+        public void Save()
+        {
+            Save(m_SaveFileFullPath);
+        }
+
+        public void Save(string filePath)
+        {
+            if (m_Project != null)
+            {
+                Util.SerializeXML<List<string>>.SaveFile(filePath, m_WatchList);
+            }
+        }
+
+        public void Load()
+        {
+            Load(m_SaveFileFullPath);
+        }
+
+        public void Load(string filePath)
+        {
+            if (File.Exists(filePath))
+            {
+                m_WatchList = Util.SerializeXML<List<string>>.LoadFile(filePath);
+            }
+            else
+            {
+                m_WatchList = new List<string>();
+            }
+            OnExpressionsLoaded(EventArgs.Empty);
+        }
+
+        protected void OnExpressionAdded(string expr, int index)
+        {
+            if (ExpressionAdded != null)
+            {
+                ExpressionAdded(this, new WatchExpressionArgs(expr, index));
+            }
+        }
+
+        protected void OnExpressionRemoved(string expr, int index)
+        {
+            if (ExpressionRemoved != null)
+            {
+                ExpressionRemoved(this, new WatchExpressionArgs(expr, index));
+            }
+        }
+
+        protected void OnExpressionReplaced(string oldExpr, string newExpr, int index)
+        {
+            if (ExpressionReplaced != null)
+            {
+                ExpressionReplaced(this, new WatchExpressionReplaceArgs(oldExpr, newExpr, index));
+            }
+        }
+
+        protected void OnExpressionsCleared(EventArgs e)
+        {
+            if (ExpressionsCleared != null)
+            {
+                ExpressionsCleared(this, e);
+            }
+        }
+
+        protected void OnExpressionsLoaded(EventArgs e)
+        {
+            if (ExpressionsLoaded != null)
+            {
+                ExpressionsLoaded(this, e);
+            }
+        }
+    }
+
+    public class WatchExpressionArgs : EventArgs
+    {
+        public string Expression { get; internal set; }
+
+        public int Position { get; internal set; }
+
+        public WatchExpressionArgs(string expression, int position)
+        {
+            this.Expression = expression;
+            this.Position = position;
+        }
+    }
+
+    public class WatchExpressionReplaceArgs : EventArgs
+    {
+        public string NewExpression { get; internal set; }
+
+        public string OldExpression { get; internal set; }
+
+        public int Position { get; internal set; }
+
+        public WatchExpressionReplaceArgs(string oldExpression, string newExpression, int position)
+        {
+            this.OldExpression = oldExpression;
+            this.NewExpression = newExpression;
+            this.Position = position;
+        }
+    }
+}

External/Plugins/FlashDebugger/FlashDebugger.csproj

@@ -147,6 +147,7 @@
     <Compile Include="Debugger\ExpressionContext.cs" />
     <Compile Include="Debugger\FlashInterface.cs" />
     <Compile Include="Debugger\VariableFacade.cs" />
+    <Compile Include="Debugger\WatchManager.cs" />
     <Compile Include="Helpers\DataTreeExporterFactory.cs" />
     <Compile Include="Helpers\DefaultDataTreeExporter.cs" />
     <Compile Include="Helpers\IDataTreeExporter.cs" />

External/Plugins/FlashDebugger/Helpers/PanelsHelper.cs

@@ -45,7 +45,7 @@ public PanelsHelper(PluginMain pluginMain, Image pluginImage)
             stackframePanel = PluginBase.MainForm.CreateDockablePanel(stackframeUI, stackframeGuid, pluginImage, DockState.DockLeft);
             stackframePanel.Hide();
 
-            watchUI = new WatchUI();
+            watchUI = new WatchUI(PluginMain.watchManager);
             watchUI.Text = TextHelper.GetString("Title.Watch");
             watchPanel = PluginBase.MainForm.CreateDockablePanel(watchUI, watchGuid, pluginImage, DockState.DockLeft);
             watchPanel.Hide();