Created IMutable interface to propagate Changed event of variables

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1658 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj

@@ -383,6 +383,7 @@
     <Compile Include="Src\Variables\ObjectValue.cs" />
     <Compile Include="Src\Debugger\Util.cs" />
     <Compile Include="Src\Variables\Evals\Eval.NewObjectEval.cs" />
+    <Compile Include="Src\Debugger\IMutable.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="README.TXT" />

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/DebugeeState.cs

@@ -13,12 +13,28 @@ namespace Debugger
 	/// Unique identifier of the state of the debugee.
 	/// Changes when debuggee is stepped, but not when properity is evaluated.
 	/// </summary>
-	public class DebugeeState: IExpirable
+	public class DebugeeState: IExpirable, IMutable
 	{
+		NDebugger debugger;
 		bool hasExpired = false;
 		
 		public event EventHandler Expired;
 		
+		public event EventHandler<DebuggerEventArgs> Changed {
+			add {
+				debugger.DebuggeeStateChanged += value;
+			}
+			remove {
+				debugger.DebuggeeStateChanged -= value;
+			}
+		}
+		
+		public NDebugger Debugger {
+			get {
+				return debugger;
+			}
+		}
+		
 		public bool HasExpired {
 			get {
 				return hasExpired;
@@ -34,5 +50,10 @@ namespace Debugger
 				}
 			}
 		}
+		
+		public DebugeeState(NDebugger debugger)
+		{
+			this.debugger = debugger;
+		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/IMutable.cs

@@ -0,0 +1,16 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+
+namespace Debugger
+{
+	public interface IMutable
+	{
+		event EventHandler<DebuggerEventArgs> Changed;
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/NDebugger-StateControl.cs

@@ -166,7 +166,7 @@ namespace Debugger
 		internal void Pause()
 		{
 			if (PausedReason != PausedReason.EvalComplete) {
-				DebugeeState = new DebugeeState();
+				DebugeeState = new DebugeeState(this);
 			}
 			
 			OnDebuggingPaused();

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Exception.cs

@@ -45,6 +45,7 @@ namespace Debugger
 			                            "$exception",
 			                            Variable.Flags.Default,
 			                            new IExpirable[] {debugger.PauseSession},
+			                            new IMutable[] {},
 			                            delegate { return corValue; } ).Value;
 			runtimeValueException = ((ObjectValue)runtimeValue).GetClass("System.Exception");
 			message = runtimeValueException.SubVariables["_message"].Value.AsString;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs

@@ -382,6 +382,7 @@ namespace Debugger
 				                    "this",
 				                    Variable.Flags.Default,
 				                    new IExpirable[] {this},
+				                    new IMutable[] {},
 				                    delegate { return ThisCorValue; });
 			}
 		}
@@ -438,6 +439,7 @@ namespace Debugger
 			                    GetParameterName(index),
 			                    Variable.Flags.Default,
 			                    new IExpirable[] {this},
+			                    new IMutable[] {debugger.DebugeeState},
 			                    delegate { return GetArgumentCorValue(index); } );
 		}
 		
@@ -493,6 +495,7 @@ namespace Debugger
 			                    symVar.Name,
 			                    Variable.Flags.Default,
 			                    new IExpirable[] {this},
+			                    new IMutable[] {debugger.DebugeeState},
 			                    delegate { return GetCorValueOfLocalVariable(symVar); });
 		}
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Thread.cs

@@ -118,6 +118,7 @@ namespace Debugger
 				                    "thread" + id,
 				                    Variable.Flags.Default,
 				                    new IExpirable[] {debugger.PauseSession},
+				                    new IMutable[] {},
 				                    delegate { return corThread.Object;} ).Value;
 			}
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs

@@ -122,6 +122,7 @@ namespace Debugger
 			                    elementName,
 			                    Variable.Flags.Default,
 			                    new IExpirable[] {this.Variable},
+			                    new IMutable[] {this.Variable},
 			                    delegate { return GetCorValueOfItem(indices); });
 		}
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Evals/Eval.cs

@@ -47,7 +47,7 @@ namespace Debugger
 				if (Evaluated) {
 					debugeeStateOfResult = debugger.DebugeeState;
 				}
-				variablele.NotifyValueChange();
+				variablele.NotifyChange();
 			}
 		}
 		
@@ -81,11 +81,12 @@ namespace Debugger
 			                      String.Empty,
 			                      Variable.Flags.Default,
 			                      dependencies,
+			                      reevaluateAfterDebuggeeStateChange? new IMutable[] {debugger.DebugeeState}: new IMutable[0],
 			                      delegate { return GetCorValue(); });
 			
 			foreach(IExpirable dependency in dependencies) {
 				if (dependency is Variable) {
-					((Variable)dependency).ValueChanged += delegate { EvalState = EvalState.WaitingForRequest; };
+					((Variable)dependency).Changed += delegate { EvalState = EvalState.WaitingForRequest; };
 				}
 			}
 			if (reevaluateAfterDebuggeeStateChange) {

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValueClass.cs

@@ -142,6 +142,7 @@ namespace Debugger
 				                          (field.IsStatic ? Variable.Flags.Static : Variable.Flags.None) |
 				                          (field.IsPublic ? Variable.Flags.Public : Variable.Flags.None),
 				                          new IExpirable[] {this.objectValue.Variable},
+				                          new IMutable[] {this.objectValue.Variable},
 				                          delegate { return GetCorValueOfField(field); });
 			}
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PrimitiveValue.cs

@@ -47,7 +47,7 @@ namespace Debugger
 				} else {
 					(CorValue.CastTo<ICorDebugGenericValue>()).Value = newValue;
 				}
-				this.Variable.NotifyValueChange();
+				this.Variable.NotifyChange();
 			}
 		}
 

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Variable.cs

@@ -22,11 +22,8 @@ namespace Debugger
 	/// Expiration is permanet - once value expires it stays expired. 
 	/// Value expires when any object specified in constructor expires 
 	/// or when process exits.
-	/// 
-	/// ValueChange: ValueChange event is called whenever DebugeeState 
-	/// changes or when NotifyValueChange() is called.
 	/// </summary>
-	public class Variable: IExpirable
+	public class Variable: IExpirable, IMutable
 	{
 		/// <summary>
 		/// Delegate that is used to get value. This delegate may be called at any time and should never return null.
@@ -44,11 +41,12 @@ namespace Debugger
 		Flags flags;
 		CorValueGetter corValueGetter;
 		ValueGetter valueGetter;
+		IMutable[] mutateDependencies;
 		
 		bool isExpired = false;
 		
 		public event EventHandler Expired;
-		public event EventHandler<VariableEventArgs> ValueChanged;
+		public event EventHandler<DebuggerEventArgs> Changed;
 		
 		public NDebugger Debugger {
 			get {
@@ -132,33 +130,35 @@ namespace Debugger
 			}
 		}
 		
-		Variable(NDebugger debugger, string name, Flags flags, IExpirable[] dependencies)
+		public Variable(NDebugger debugger, string name, Flags flags, IExpirable[] expireDependencies, IMutable[] mutateDependencies, CorValueGetter corValueGetter)
 		{
 			this.debugger = debugger;
 			this.name = name;
-			this.flags = flags;
-			
 			if (name.StartsWith("<") && name.Contains(">") && name != "<Base class>") {
 				string middle = name.TrimStart('<').Split('>')[0]; // Get text between '<' and '>'
 				if (middle != "") {
 					this.name = middle;
 				}
 			}
+			this.flags = flags;
 			
-			foreach(IExpirable exp in dependencies) {
-				AddDependency(exp);
+			foreach(IExpirable exp in expireDependencies) {
+				AddExpireDependency(exp);
 			}
-			AddDependency(debugger.SelectedProcess);
-			debugger.DebuggeeStateChanged += NotifyValueChange;
-		}
-		
-		public Variable(NDebugger debugger, string name, Flags flags, IExpirable[] dependencies, CorValueGetter corValueGetter):this(debugger, name, flags, dependencies)
-		{
+			AddExpireDependency(debugger.SelectedProcess);
+			
+			this.mutateDependencies = mutateDependencies;
+			if (!this.HasExpired) {
+				foreach(IMutable mut in mutateDependencies) {
+					AddMutateDependency(mut);
+				}
+			}
+			
 			this.corValueGetter = corValueGetter;
 			this.valueGetter = delegate { return CreateValue(); };
 		}
 		
-		void AddDependency(IExpirable dependency)
+		void AddExpireDependency(IExpirable dependency)
 		{
 			if (dependency.HasExpired) {
 				MakeExpired();
@@ -167,31 +167,38 @@ namespace Debugger
 			}
 		}
 		
+		void AddMutateDependency(IMutable dependency)
+		{
+			dependency.Changed += DependencyChanged;
+		}
+		
 		void MakeExpired()
 		{
 			if (!isExpired) {
 				isExpired = true;
 				OnExpired(new VariableEventArgs(this));
-				debugger.DebuggeeStateChanged -= NotifyValueChange;
+				foreach(IMutable mut in mutateDependencies) {
+					mut.Changed -= DependencyChanged;
+				}
 			}
 		}
 		
-		void NotifyValueChange(object sender, DebuggerEventArgs e)
+		void DependencyChanged(object sender, DebuggerEventArgs e)
 		{
-			NotifyValueChange();
+			NotifyChange();
 		}
 		
-		internal void NotifyValueChange()
+		internal void NotifyChange()
 		{
 			if (!isExpired) {
-				OnValueChanged(new VariableEventArgs(this));
+				OnChanged(new VariableEventArgs(this));
 			}
 		}
 		
-		protected virtual void OnValueChanged(VariableEventArgs e)
+		protected virtual void OnChanged(DebuggerEventArgs e)
 		{
-			if (ValueChanged != null) {
-				ValueChanged(this, e);
+			if (Changed != null) {
+				Changed(this, e);
 			}
 		}
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/VariableEventArgs.cs

@@ -9,7 +9,7 @@ using System;
 
 namespace Debugger
 {
-	public class VariableEventArgs: EventArgs
+	public class VariableEventArgs: DebuggerEventArgs
 	{
 		Variable variable;
 		
@@ -19,7 +19,7 @@ namespace Debugger
 			}
 		}
 		
-		public VariableEventArgs(Variable variable)
+		public VariableEventArgs(Variable variable): base(variable.Debugger)
 		{
 			this.variable = variable;
 		}