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

Timestamp:

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

Author:

mkommend

Message:

completly refactored the graph visualization (ticket #867)

Location:

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

Files:

• . (added)
• IOperatorShapeInfo.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/IOperatorShapeInfo.cs)
• OperatorGraphView.Designer.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphView.Designer.cs)
• OperatorGraphView.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphView.cs) (3 diffs)
• OperatorGraphVisualizationInfo.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/GraphVisualizationInfo.cs) (12 diffs)
• OperatorShape.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/OperatorShape.cs)
• OperatorShapeInfo.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/OperatorShapeInfo.cs) (5 diffs)
• OperatorShapeInfoFactory.cs (copied) (copied from trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/ShapeInfoFactory.cs) (2 diffs)

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

@@ -66 +66 @@
       bool createdVisualizationInfo = false;
       if (this.VisualizationInfo == null) {
-        this.VisualizationInfo = new GraphVisualizationInfo(this.Content);
+        this.VisualizationInfo = new OperatorGraphVisualizationInfo(this.Content);
         createdVisualizationInfo = true;
       }
@@ -108 +108 @@
     } 
 
-    private GraphVisualizationInfo VisualizationInfo {
-      get { return Content.VisualizationInfo as GraphVisualizationInfo; }
+    private OperatorGraphVisualizationInfo VisualizationInfo {
+      get { return Content.VisualizationInfo as OperatorGraphVisualizationInfo; }
       set { this.Content.VisualizationInfo = value; }
     }
@@ -228 +228 @@
       if (e.Effect != DragDropEffects.None) {
         IOperator op = e.Data.GetData("Value") as IOperator;
-        IOperatorShapeInfo shapeInfo = Factory.CreateOperatorShapeInfo(op);
+        IOperatorShapeInfo shapeInfo = OperatorShapeInfoFactory.CreateOperatorShapeInfo(op);
         Point mouse = new Point(MousePosition.X, MousePosition.Y);
         Point screen = this.graphVisualizationInfoView.PointToScreen(new Point(0, 0));

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

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

@@ -29 +29 @@
 using System.Windows.Forms;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
   [StorableClass]
   internal class OperatorShapeInfo : ShapeInfo, IOperatorShapeInfo {
-    [Storable]
-    private List<string> connectorNames;
     [Storable]
     private List<string> labels;
@@ -57 +56 @@
 
     public void AddConnector(string connectorName) {
-      if (!this.connectorNames.Contains(connectorName) && connectorName != "Successor") {
+      if (!this.connectorNames.Contains(connectorName)) {
         this.connectorNames.Add(connectorName);
         this.OnChanged();
@@ -73 +72 @@
       this.labels = new List<string>(labels);
       this.OnChanged();
+    }
+
+    [Storable]
+    private List<string> connectorNames;
+    public override IEnumerable<string> Connectors {
+      get { return this.connectorNames; }
     }
 
@@ -163 +168 @@
     public override void UpdateShape(IShape shape) {
       base.UpdateShape(shape);
-      OperatorShape operatorShape = shape as OperatorShape;
-      if (operatorShape != null) {
-        operatorShape.Title = this.Title;
-        operatorShape.Color = this.Color;
-        operatorShape.LineColor = this.LineColor;
-        operatorShape.LineWidth = this.LineWidth;
-        operatorShape.Icon = this.Icon;
-        operatorShape.Collapsed = this.Collapsed;
-
-        int i = 0;
-        int j = 0;
-        //remove old connectors and skip correct connectors
-        List<string> oldConnectorNames = operatorShape.AdditionalConnectorNames.ToList();
-        while (i < this.connectorNames.Count && j < oldConnectorNames.Count) {
-          if (this.connectorNames[i] != oldConnectorNames[j]) {
-            operatorShape.RemoveConnector(oldConnectorNames[j]);
-          } else
-            i++;
-          j++;
-        }
-        //remove remaining old connectors
-        for (; j < oldConnectorNames.Count; j++)
+      OperatorShape operatorShape = (OperatorShape)shape;
+      operatorShape.Title = this.Title;
+      operatorShape.Color = this.Color;
+      operatorShape.LineColor = this.LineColor;
+      operatorShape.LineWidth = this.LineWidth;
+      operatorShape.Icon = this.Icon;
+      operatorShape.Collapsed = this.Collapsed;
+
+      int i = 0;
+      int j = 0;
+      //remove old connectors and skip correct connectors
+      List<string> oldConnectorNames = operatorShape.AdditionalConnectorNames.ToList();
+      while (i < this.connectorNames.Count && j < oldConnectorNames.Count) {
+        if (this.connectorNames[i] != oldConnectorNames[j]) {
           operatorShape.RemoveConnector(oldConnectorNames[j]);
-
-        //add new connectors
-        for (; i < this.connectorNames.Count; i++)
-          operatorShape.AddConnector(this.connectorNames[i]);
-
-        operatorShape.UpdateLabels(this.labels);
-      }
+        } else
+          i++;
+        j++;
+      }
+      //remove remaining old connectors
+      for (; j < oldConnectorNames.Count; j++)
+        operatorShape.RemoveConnector(oldConnectorNames[j]);
+
+      //add new connectors
+      for (; i < this.connectorNames.Count; i++)
+        operatorShape.AddConnector(this.connectorNames[i]);
+
+      operatorShape.UpdateLabels(this.labels);
+    }
+
+    public override void UpdateShapeInfo(IShape shape) {
+      base.UpdateShapeInfo(shape);
+      OperatorShape operatorShape = (OperatorShape)shape;
+      this.Title = operatorShape.Title;
+      this.Color = operatorShape.Color;
+      this.LineColor = operatorShape.LineColor;
+      this.LineWidth = operatorShape.LineWidth;
+      this.Icon = operatorShape.Icon;
+      this.Collapsed = operatorShape.Collapsed;
+
+      //TODO update Connector and labels;
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      OperatorShapeInfo clone = (OperatorShapeInfo) base.Clone(cloner);
+      OperatorShapeInfo clone = (OperatorShapeInfo)base.Clone(cloner);
       clone.collapsed = this.collapsed;
       clone.color = this.color;
@@ -202 +218 @@
       clone.lineWidth = this.lineWidth;
       clone.title = this.title;
-      clone.icon = (Bitmap) this.icon.Clone();
+      clone.icon = (Bitmap)this.icon.Clone();
 
       clone.connectorNames = new List<string>(this.connectorNames);

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

@@ -30 +30 @@
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
-  public static class Factory {
-    private static LinePenStyle connectionPenStyle;
-
-    static Factory() {
-      connectionPenStyle = new LinePenStyle();
-      connectionPenStyle.EndCap = LineCap.ArrowAnchor;
-    }
-
+  internal static class OperatorShapeInfoFactory {
+    public const string PredecessorConnector = "Predecessor";
     public static IOperatorShapeInfo CreateOperatorShapeInfo(IOperator op) {
-      IEnumerable<string> operatorParameterNames = op.Parameters.Where(p => p is IValueParameter<IOperator> && p.Name != "Successor").Select(p => p.Name);
+      IEnumerable<string> operatorParameterNames = op.Parameters.Where(p => p is IValueParameter<IOperator>).Select(p => p.Name);
       IEnumerable<string> paramaterNameValues = op.Parameters.Where(p => !(p is IValueParameter<IOperator>)).Select(p => p.ToString());
 
-      OperatorShapeInfo operatorShapeInfo = new OperatorShapeInfo(operatorParameterNames,paramaterNameValues);
+      OperatorShapeInfo operatorShapeInfo = new OperatorShapeInfo(operatorParameterNames, paramaterNameValues);
+      operatorShapeInfo.AddConnector(PredecessorConnector);
       operatorShapeInfo.Collapsed = true;
       operatorShapeInfo.Title = op.Name;
@@ -52 +47 @@
       return operatorShapeInfo;
     }
-
-    public static IConnection CreateConnection(IConnector from, IConnector to) {
-      Connection connection = new Connection(from.Point, to.Point);
-      connection.From.AllowMove = false;
-      connection.To.AllowMove = false;
-      from.AttachConnector(connection.From);
-
-      to.AttachConnector(connection.To);
-      connection.PenStyle = connectionPenStyle;
-      return connection;
-    }
   }
 }