Changeset 3386 for trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphVisualization/OperatorGraphVisualizationInfo.cs

Timestamp:

04/17/10 23:50:05 (14 years ago)

Author:

mkommend

Message:

completly refactored the graph visualization (ticket #867)

Location:

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphVisualization

Files:

• . (added)
• OperatorGraphVisualizationInfo.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/GraphVisualizationInfo.cs) (12 diffs)

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphVisualization/OperatorGraphVisualizationInfo.cs

@@ -29 +29 @@
 using HeuristicLab.Collections;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
   [StorableClass]
-  public sealed class GraphVisualizationInfo : DeepCloneable {
+  public sealed class OperatorGraphVisualizationInfo : GraphVisualizationInfo {
+    [Storable]
     private BidirectionalLookup<IOperator, IOperatorShapeInfo> operatorShapeInfoMapping;
-    [Storable]
-    private BidirectionalLookup<IOperator, IOperatorShapeInfo> OperatorShapeInfoMappingStore {
-      get { return this.operatorShapeInfoMapping; }
-      set {
-        IOperator op;
-        IOperatorShapeInfo shapeInfo;
-        foreach (KeyValuePair<IOperator, IOperatorShapeInfo> pair in value.FirstEnumerable) {
-          op = pair.Key;
-          shapeInfo = pair.Value;
-          shapeInfo.Icon = new Bitmap(op.ItemImage);
-          this.RegisterOperatorEvents(op);
-          this.operatorParameterCollectionMapping.Add(op, pair.Key.Parameters);
-          this.operatorShapeInfoMapping.Add(op, shapeInfo);
-          this.shapeInfos.Add(shapeInfo);
-        }
-
-        foreach (IOperator oper in value.FirstValues) {
-          foreach (IParameter param in oper.Parameters) {
-            this.parameterOperatorMapping.Add(param, oper);
-            IValueParameter<IOperator> opParam = param as IValueParameter<IOperator>;
-            if (opParam != null) {
-              this.RegisterOperatorParameterEvents(opParam);
-              shapeInfo = this.operatorShapeInfoMapping.GetByFirst(oper);
-              if (opParam.Value != null) {
-                this.connections.Add(new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, param.Name), this.operatorShapeInfoMapping.GetByFirst(opParam.Value));
-              }
-            } else
-              this.RegisterParameterEvents(param);
-          }
-        }
-      }
-    }
-
     private BidirectionalLookup<IOperator, IObservableKeyedCollection<string, IParameter>> operatorParameterCollectionMapping;
     private Dictionary<IParameter, IOperator> parameterOperatorMapping;
 
-    private GraphVisualizationInfo() {
+    private OperatorGraphVisualizationInfo()
+      : base() {
       this.operatorShapeInfoMapping = new BidirectionalLookup<IOperator, IOperatorShapeInfo>();
       this.operatorParameterCollectionMapping = new BidirectionalLookup<IOperator, IObservableKeyedCollection<string, IParameter>>();
       this.parameterOperatorMapping = new Dictionary<IParameter, IOperator>();
-
-      this.shapeInfos = new ObservableSet<IOperatorShapeInfo>();
-      this.connections = new ObservableDictionary<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>();
-    }
-
-    public GraphVisualizationInfo(OperatorGraph operatorGraph)
+    }
+
+    [StorableConstructor]
+    private OperatorGraphVisualizationInfo(bool deserializing)
+      : base() {
+      this.operatorParameterCollectionMapping = new BidirectionalLookup<IOperator, IObservableKeyedCollection<string, IParameter>>();
+      this.parameterOperatorMapping = new Dictionary<IParameter, IOperator>();
+    }
+
+    public OperatorGraphVisualizationInfo(OperatorGraph operatorGraph)
       : this() {
-      this.OperatorGraph = operatorGraph;
+      this.operatorGraph = operatorGraph;
+      this.RegisterOperatorGraphEvents();
 
       foreach (IOperator op in operatorGraph.Operators)
-        if (!this.operatorShapeInfoMapping.ContainsFirst(op))
+        if (!this.operatorShapeInfoMapping.ContainsFirst(op))  //could be added by referencing parameters
           this.AddOperator(op);
 
@@ -90 +65 @@
     }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void DeserializationHook() {
+      this.operatorGraph.DeserializationFinished += new EventHandler(operatorGraph_DeserializationFinished);
+
+      IOperator op;
+      IOperatorShapeInfo shapeInfo;
+      foreach (KeyValuePair<IOperator, IOperatorShapeInfo> pair in this.operatorShapeInfoMapping.FirstEnumerable) {
+        op = pair.Key;
+        shapeInfo = pair.Value;
+        shapeInfo.Icon = new Bitmap(op.ItemImage);
+        this.RegisterOperatorEvents(op);
+        this.operatorParameterCollectionMapping.Add(op, op.Parameters);
+      }
+
+      foreach (IOperator oper in this.operatorShapeInfoMapping.FirstValues) {
+        foreach (IParameter param in oper.Parameters) {
+          this.parameterOperatorMapping.Add(param, oper);
+          IValueParameter<IOperator> opParam = param as IValueParameter<IOperator>;
+          if (opParam != null)
+            this.RegisterOperatorParameterEvents(opParam);
+          else
+            this.RegisterParameterEvents(param);
+        }
+      }
+    }
+
+    private void operatorGraph_DeserializationFinished(object sender, EventArgs e) {
+      this.RegisterOperatorGraphEvents();
+      if (this.operatorGraph.InitialOperator != null) {
+        IOperatorShapeInfo newInitialShapeInfo = this.operatorShapeInfoMapping.GetByFirst(this.operatorGraph.InitialOperator);
+        if (newInitialShapeInfo != null) {
+          oldInitialShapeColor = newInitialShapeInfo.Color;
+          newInitialShapeInfo.Color = Color.LightGreen;
+        }
+        oldInitialShape = this.InitialShape;
+        this.OnInitialShapeChanged();
+      }
+      this.operatorGraph.DeserializationFinished -= new EventHandler(operatorGraph_DeserializationFinished);
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
-      GraphVisualizationInfo clone = new GraphVisualizationInfo();
-      cloner.RegisterClonedObject(this, clone);
+      OperatorGraphVisualizationInfo clone = (OperatorGraphVisualizationInfo)base.Clone(cloner);
       clone.operatorGraph = (OperatorGraph)cloner.Clone(this.operatorGraph);
+      clone.RegisterOperatorGraphEvents();
       clone.oldInitialShape = (IOperatorShapeInfo)cloner.Clone(this.oldInitialShape);
       clone.oldInitialShapeColor = this.oldInitialShapeColor;
@@ -105 +120 @@
         clone.operatorParameterCollectionMapping.Add(op, pair.Key.Parameters);
         clone.operatorShapeInfoMapping.Add(op, shapeInfo);
-        clone.shapeInfos.Add(shapeInfo);
       }
 
@@ -112 +126 @@
           clone.parameterOperatorMapping.Add(param, oper);
           IValueParameter<IOperator> opParam = param as IValueParameter<IOperator>;
-          if (opParam != null) {
+          if (opParam != null)
             clone.RegisterOperatorParameterEvents(opParam);
-            shapeInfo = clone.operatorShapeInfoMapping.GetByFirst(oper);
-            if (opParam.Value != null) {
-              clone.connections.Add(new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, param.Name), clone.operatorShapeInfoMapping.GetByFirst(opParam.Value));
-            }
-          } else
+          else
             clone.RegisterParameterEvents(param);
         }
       }
-
+      if (this.operatorGraph.InitialOperator != null) {
+        IOperatorShapeInfo newInitialShapeInfo = this.operatorShapeInfoMapping.GetByFirst(this.operatorGraph.InitialOperator);
+        if (newInitialShapeInfo != null) {
+          oldInitialShapeColor = newInitialShapeInfo.Color;
+          newInitialShapeInfo.Color = Color.LightGreen;
+        }
+        oldInitialShape = this.InitialShape;
+        this.OnInitialShapeChanged();
+      }
       return clone;
     }
 
-    public event EventHandler InitialShapeChanged;
+    internal IOperator GetOperatorForShapeInfo(IOperatorShapeInfo shapeInfo) {
+      return this.operatorShapeInfoMapping.GetBySecond(shapeInfo);
+    }
+
     private void operatorGraph_InitialOperatorChanged(object sender, EventArgs e) {
       this.UpdateInitialShape();
@@ -143 +164 @@
 
       oldInitialShape = this.InitialShape;
-      if (this.InitialShapeChanged != null)
-        this.InitialShapeChanged(this, new EventArgs());
-    }
-
-    [Storable]
-    private IOperatorShapeInfo oldInitialShape;
-    [Storable]
+      this.OnInitialShapeChanged();
+    }
+
+    private IShapeInfo oldInitialShape;
     private Color oldInitialShapeColor;
-    public IOperatorShapeInfo InitialShape {
+    public override IShapeInfo InitialShape {
       get {
         IOperator op = this.operatorGraph.InitialOperator;
@@ -161 +179 @@
         if (value == null)
           this.OperatorGraph.InitialOperator = null;
-        else
-          this.OperatorGraph.InitialOperator = this.operatorShapeInfoMapping.GetBySecond(value);
-      }
-    }
-
-
+        else {
+          IOperatorShapeInfo shapeInfo = (IOperatorShapeInfo)value;
+          this.OperatorGraph.InitialOperator = this.operatorShapeInfoMapping.GetBySecond(shapeInfo);
+        }
+      }
+    }
+
+    [Storable]
     private OperatorGraph operatorGraph;
-    [Storable]
     public OperatorGraph OperatorGraph {
       get { return this.operatorGraph; }
-      private set {
-        if (this.operatorGraph != null || value == null)
-          throw new InvalidOperationException("Could not set OperatorGraph");
-
-        this.operatorGraph = value;
-        this.operatorGraph.InitialOperatorChanged += new EventHandler(operatorGraph_InitialOperatorChanged);
-        this.operatorGraph.Operators.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
-        this.operatorGraph.Operators.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
-        this.operatorGraph.Operators.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_CollectionReset);
-      }
-    }
-
-    private ObservableSet<IOperatorShapeInfo> shapeInfos;
-    public INotifyObservableCollectionItemsChanged<IOperatorShapeInfo> ObserveableShapeInfos {
-      get { return this.shapeInfos; }
-    }
-    public IEnumerable<IOperatorShapeInfo> OperatorShapeInfos {
-      get { return this.shapeInfos; }
-    }
-    public IOperator GetOperatorForShapeInfo(IOperatorShapeInfo shapeInfo) {
-      return this.operatorShapeInfoMapping.GetBySecond(shapeInfo);
-    }
-
-    private ObservableDictionary<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> connections;
-    public INotifyObservableDictionaryItemsChanged<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> ObservableConnections {
-      get { return this.connections; }
-    }
-    public IEnumerable<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>> Connections {
-      get { return this.connections; }
+    }
+
+    private void RegisterOperatorGraphEvents() {
+      this.operatorGraph.InitialOperatorChanged += new EventHandler(operatorGraph_InitialOperatorChanged);
+      this.operatorGraph.Operators.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
+      this.operatorGraph.Operators.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
+      this.operatorGraph.Operators.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_CollectionReset);
+    }
+
+    private void DeregisterOperatorGraphEvents() {
+      this.operatorGraph.InitialOperatorChanged -= new EventHandler(operatorGraph_InitialOperatorChanged);
+      this.operatorGraph.Operators.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
+      this.operatorGraph.Operators.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
+      this.operatorGraph.Operators.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperator>(Operators_CollectionReset);
     }
 
@@ -215 +219 @@
     }
 
-    internal void RemoveShapeInfo(IOperatorShapeInfo shapeInfo) {
+    public override void RemoveShapeInfo(IShapeInfo shapeInfo) {
+      IOperatorShapeInfo opShapeInfo = (IOperatorShapeInfo)shapeInfo;
+      if (this.operatorShapeInfoMapping.ContainsSecond(opShapeInfo)) {
+        IOperator op = this.operatorShapeInfoMapping.GetBySecond(opShapeInfo);
+        this.operatorGraph.Operators.Remove(op);
+      }
+    }
+
+    public override void RemoveConnectionInfo(IConnectionInfo connectionInfo) {
+      IOperatorShapeInfo shapeInfo = (IOperatorShapeInfo)connectionInfo.From;
       IOperator op = this.operatorShapeInfoMapping.GetBySecond(shapeInfo);
-      this.operatorGraph.Operators.Remove(op);
-    }
-
-    internal void AddConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName, IOperatorShapeInfo shapeInfoTo) {
-      IOperator opFrom = this.operatorShapeInfoMapping.GetBySecond(shapeInfoFrom);
-      IOperator opTo = this.operatorShapeInfoMapping.GetBySecond(shapeInfoTo);
-
-      IValueParameter<IOperator> param = (IValueParameter<IOperator>)opFrom.Parameters[connectorName];
-      param.Value = opTo;
-    }
-
-    internal void ChangeConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName, IOperatorShapeInfo shapeInfoTo) {
-      IOperator opFrom = this.operatorShapeInfoMapping.GetBySecond(shapeInfoFrom);
-      IOperator opTo = this.operatorShapeInfoMapping.GetBySecond(shapeInfoTo);
-
-      IValueParameter<IOperator> param = (IValueParameter<IOperator>)opFrom.Parameters[connectorName];
-      param.Value = opTo;
-    }
-
-    internal void RemoveConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName) {
-      IOperator opFrom = this.operatorShapeInfoMapping.GetBySecond(shapeInfoFrom);
-      IValueParameter<IOperator> param = (IValueParameter<IOperator>)opFrom.Parameters[connectorName];
+      IValueParameter<IOperator> param = (IValueParameter<IOperator>)op.Parameters[connectionInfo.ConnectorFrom];
       param.Value = null;
     }
@@ -247 +239 @@
       if (!this.operatorShapeInfoMapping.ContainsFirst(op)) {
         this.RegisterOperatorEvents(op);
-        IOperatorShapeInfo shapeInfo = Factory.CreateOperatorShapeInfo(op);
+        IOperatorShapeInfo shapeInfo = OperatorShapeInfoFactory.CreateOperatorShapeInfo(op);
         this.operatorParameterCollectionMapping.Add(op, op.Parameters);
         this.operatorShapeInfoMapping.Add(op, shapeInfo);
@@ -255 +247 @@
       }
     }
-
     private void RemoveOperator(IOperator op) {
       this.DeregisterOperatorEvents(op);
@@ -333 +324 @@
       if (opParam != null) {
         this.RegisterOperatorParameterEvents(opParam);
-        IOperatorShapeInfo shapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
-        shapeInfo.AddConnector(param.Name);
+        IOperatorShapeInfo shapeInfoFrom = this.operatorShapeInfoMapping.GetByFirst(op);
+        shapeInfoFrom.AddConnector(param.Name);
 
         if (opParam.Value != null) {
           if (!this.operatorShapeInfoMapping.ContainsFirst(opParam.Value))
             this.AddOperator(opParam.Value);
-          this.connections.Add(new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, param.Name), this.operatorShapeInfoMapping.GetByFirst(opParam.Value));
+          IOperatorShapeInfo shapeInfoTo = this.operatorShapeInfoMapping.GetByFirst(opParam.Value);
+          this.connectionInfos.Add(new ConnectionInfo(shapeInfoFrom, param.Name, shapeInfoTo, OperatorShapeInfoFactory.PredecessorConnector));
         }
       } else
@@ -350 +342 @@
         this.DeregisterOperatorParameterEvents(opParam);
         IOperatorShapeInfo shapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
-        this.connections.Remove(new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, param.Name));
+        this.connectionInfos.RemoveWhere(c => c.From == shapeInfo && c.ConnectorFrom == param.Name);
+        this.connectionInfos.RemoveWhere(c => c.To == shapeInfo && c.ConnectorTo == param.Name);
         shapeInfo.RemoveConnector(param.Name);
       } else
@@ -360 +353 @@
     private void opParam_ValueChanged(object sender, EventArgs e) {
       IValueParameter<IOperator> opParam = (IValueParameter<IOperator>)sender;
-      if (opParam != null) {
-        IOperator op = this.parameterOperatorMapping[opParam];
-        IOperatorShapeInfo shapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
-        KeyValuePair<IOperatorShapeInfo, string> connectionFrom = new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, opParam.Name);
-
-        if (opParam.Value == null)
-          this.connections.Remove(connectionFrom);
-        else {
-          if (!this.operatorShapeInfoMapping.ContainsFirst(opParam.Value))
-            this.AddOperator(opParam.Value);
-          this.connections[connectionFrom] = this.operatorShapeInfoMapping.GetByFirst(opParam.Value);
-        }
+      IOperator op = this.parameterOperatorMapping[opParam];
+      IOperatorShapeInfo shapeInfoFrom = this.operatorShapeInfoMapping.GetByFirst(op);
+      KeyValuePair<IOperatorShapeInfo, string> connectionFrom = new KeyValuePair<IOperatorShapeInfo, string>(shapeInfoFrom, opParam.Name);
+
+      this.connectionInfos.RemoveWhere(c => c.From == shapeInfoFrom && c.ConnectorFrom == opParam.Name);
+      if (opParam.Value != null) {
+        if (!this.operatorShapeInfoMapping.ContainsFirst(opParam.Value))
+          this.AddOperator(opParam.Value);
+        IShapeInfo shapeInfoTo = this.operatorShapeInfoMapping.GetByFirst(opParam.Value);
+        this.AddConnectionInfo(new ConnectionInfo(shapeInfoFrom, opParam.Name, shapeInfoTo, OperatorShapeInfoFactory.PredecessorConnector));
       }
     }