Changeset 2934 for trunk/sources

Timestamp:

03/05/10 12:37:59 (14 years ago)

Author:

mkommend

Message:

added parameters, corrected drag and drop position (ticket #867)

Location:

trunk/sources

Files:

• HeuristicLab.ExtLibs/HeuristicLab.Netron/3.0.2672.12446/HeuristicLab.Netron-3.0.2672.12446/ExpandableIconMaterial.cs (added)
• HeuristicLab.ExtLibs/HeuristicLab.Netron/3.0.2672.12446/HeuristicLab.Netron-3.0.2672.12446/HeuristicLab.Netron-3.0.2672.12446.csproj (modified) (1 diff)
• HeuristicLab.ExtLibs/HeuristicLab.Netron/3.0.2672.12446/Netron.Diagramming.Core-3.0.2672.12446/Utils/Selection.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/BidirectionalLookup.cs (modified) (2 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/GraphVisualizationInfoView.cs (modified) (16 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/HeuristicLab.Operators.Views.GraphVisualization-3.3.csproj (modified) (2 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/GraphVisualizationInfo.cs (modified) (20 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/IOperatorShapeInfo.cs (added)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/IShapeInfo.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/OperatorShape.cs (modified) (3 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/OperatorShapeInfo.cs (modified) (10 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/ShapeInfo.cs (modified) (6 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/ShapeInfoFactory.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphView.Designer.cs (modified) (4 diffs)
• HeuristicLab.Operators.Views.GraphVisualization/3.3/OperatorGraphView.cs (modified) (11 diffs)

trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.Netron/3.0.2672.12446/HeuristicLab.Netron-3.0.2672.12446/HeuristicLab.Netron-3.0.2672.12446.csproj

@@ -82 +82 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ExpandableIconMaterial.cs" />
     <Compile Include="NetronVisualization.cs">
       <SubType>Component</SubType>

trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.Netron/3.0.2672.12446/Netron.Diagramming.Core-3.0.2672.12446/Utils/Selection.cs

@@ -153 +153 @@
       g.SmoothingMode = SmoothingMode.HighQuality;
       Bundle bundle = new Bundle(SelectedItems.Copy());
-      return ImageExporter.FromBundle(bundle, g);
+      return ImageExporter.FromBundle(bundle,g);
     }
 

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/BidirectionalLookup.cs

@@ -24 +24 @@
 using System.Linq;
 using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
   public class BidirectionalLookup<TFirst, TSecond> {
+    [Storable]
     private Dictionary<TFirst, TSecond> firstToSecond;
+    [Storable]
     private Dictionary<TSecond, TFirst> secondToFirst;
 
@@ -121 +124 @@
       this.secondToFirst.Clear();
     }
-
-
     #endregion
   }

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/GraphVisualizationInfoView.cs

@@ -42 +42 @@
   [Content(typeof(GraphVisualizationInfo), false)]
   public partial class GraphVisualizationInfoView : ContentView {
-    private BidirectionalLookup<IShapeInfo, IShape> shapeInfoShapeMapping;
-    private BidirectionalLookup<IShapeInfo, INotifyObservableDictionaryItemsChanged<string, IShapeInfo>> shapeInfoConnectionsMapping;
+    private BidirectionalLookup<IOperatorShapeInfo, IShape> shapeInfoShapeMapping;
+    private BidirectionalLookup<IOperatorShapeInfo, INotifyObservableDictionaryItemsChanged<string, IOperatorShapeInfo>> shapeInfoConnectionsMapping;
     private BidirectionalLookup<IConnection, KeyValuePair<IConnector, IConnector>> connectionConnectorsMapping;
 
@@ -50 +50 @@
       InitializeComponent();
       this.causedUpdateOfShapeInfo = false;
-      this.shapeInfoShapeMapping = new BidirectionalLookup<IShapeInfo, IShape>();
-      this.shapeInfoConnectionsMapping = new BidirectionalLookup<IShapeInfo, INotifyObservableDictionaryItemsChanged<string, IShapeInfo>>();
+      this.shapeInfoShapeMapping = new BidirectionalLookup<IOperatorShapeInfo, IShape>();
+      this.shapeInfoConnectionsMapping = new BidirectionalLookup<IOperatorShapeInfo, INotifyObservableDictionaryItemsChanged<string, IOperatorShapeInfo>>();
       this.connectionConnectorsMapping = new BidirectionalLookup<IConnection, KeyValuePair<IConnector, IConnector>>();
     }
@@ -75 +75 @@
 
     private void UpdateContent() {
-      foreach (IShapeInfo shapeInfo in this.shapeInfoShapeMapping.FirstValues)
+      foreach (IOperatorShapeInfo shapeInfo in this.shapeInfoShapeMapping.FirstValues)
         this.RemoveShapeInfo(shapeInfo);
 
@@ -82 +82 @@
       this.connectionConnectorsMapping.Clear();
 
-      foreach (IShapeInfo shapeInfo in this.Content.ShapeInfos)
+      foreach (IOperatorShapeInfo shapeInfo in this.Content.OperatorShapeInfos)
         if (!this.shapeInfoShapeMapping.ContainsFirst(shapeInfo))
           this.AddShapeInfo(shapeInfo);
 
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> connection in this.Content.Connections)
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> connection in this.Content.Connections)
         this.AddConnection(connection.Key.Key, connection.Key.Value, connection.Value);
 
@@ -93 +93 @@
 
     private void UpdateLayoutRoot() {
-      IShapeInfo shapeInfo = this.Content.InitialShape;
+      IOperatorShapeInfo shapeInfo = this.Content.InitialShape;
       if (shapeInfo != null)
         this.graphVisualization.Controller.Model.LayoutRoot = this.shapeInfoShapeMapping.GetByFirst(shapeInfo);
@@ -107 +107 @@
       base.RegisterContentEvents();
       this.Content.InitialShapeChanged += new EventHandler(VisualizationInfo_InitialShapeChanged);
-      this.Content.ObserveableShapeInfos.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IShapeInfo>(ShapeInfos_ItemsAdded);
-      this.Content.ObserveableShapeInfos.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IShapeInfo>(ShapeInfos_ItemsRemoved);
-      this.Content.ObserveableShapeInfos.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IShapeInfo>(ShapeInfos_CollectionReset);
-
-      this.Content.ObservableConnections.ItemsAdded += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_ItemsAdded);
-      this.Content.ObservableConnections.ItemsRemoved += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_ItemsRemoved);
-      this.Content.ObservableConnections.ItemsReplaced += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_ItemsReplaced);
-      this.Content.ObservableConnections.CollectionReset += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_CollectionReset);
+      this.Content.ObserveableShapeInfos.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperatorShapeInfo>(ShapeInfos_ItemsAdded);
+      this.Content.ObserveableShapeInfos.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperatorShapeInfo>(ShapeInfos_ItemsRemoved);
+      this.Content.ObserveableShapeInfos.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperatorShapeInfo>(ShapeInfos_CollectionReset);
+
+      this.Content.ObservableConnections.ItemsAdded += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_ItemsAdded);
+      this.Content.ObservableConnections.ItemsRemoved += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_ItemsRemoved);
+      this.Content.ObservableConnections.ItemsReplaced += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_ItemsReplaced);
+      this.Content.ObservableConnections.CollectionReset += new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_CollectionReset);
     }
 
@@ -120 +120 @@
       base.DeregisterContentEvents();
       this.Content.InitialShapeChanged -= new EventHandler(VisualizationInfo_InitialShapeChanged);
-      this.Content.ObserveableShapeInfos.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IShapeInfo>(ShapeInfos_ItemsAdded);
-      this.Content.ObserveableShapeInfos.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IShapeInfo>(ShapeInfos_ItemsRemoved);
-      this.Content.ObserveableShapeInfos.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IShapeInfo>(ShapeInfos_CollectionReset);
-
-      this.Content.ObservableConnections.ItemsAdded -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_ItemsAdded);
-      this.Content.ObservableConnections.ItemsRemoved -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_ItemsRemoved);
-      this.Content.ObservableConnections.ItemsReplaced -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_ItemsReplaced);
-      this.Content.ObservableConnections.CollectionReset -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>>(Connections_CollectionReset);
-    }
-
-    private void ShapeInfos_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IShapeInfo> e) {
-      foreach (IShapeInfo shapeInfo in e.OldItems)
+      this.Content.ObserveableShapeInfos.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperatorShapeInfo>(ShapeInfos_ItemsAdded);
+      this.Content.ObserveableShapeInfos.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperatorShapeInfo>(ShapeInfos_ItemsRemoved);
+      this.Content.ObserveableShapeInfos.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<IOperatorShapeInfo>(ShapeInfos_CollectionReset);
+
+      this.Content.ObservableConnections.ItemsAdded -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_ItemsAdded);
+      this.Content.ObservableConnections.ItemsRemoved -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_ItemsRemoved);
+      this.Content.ObservableConnections.ItemsReplaced -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_ItemsReplaced);
+      this.Content.ObservableConnections.CollectionReset -= new CollectionItemsChangedEventHandler<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>>(Connections_CollectionReset);
+    }
+
+    private void ShapeInfos_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IOperatorShapeInfo> e) {
+      foreach (IOperatorShapeInfo shapeInfo in e.OldItems)
         this.RemoveShapeInfo(shapeInfo);
-      foreach (IShapeInfo shapeInfo in e.Items)
+      foreach (IOperatorShapeInfo shapeInfo in e.Items)
         this.AddShapeInfo(shapeInfo);
     }
 
-    private void ShapeInfos_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IShapeInfo> e) {
-      foreach (IShapeInfo shapeInfo in e.Items)
+    private void ShapeInfos_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IOperatorShapeInfo> e) {
+      foreach (IOperatorShapeInfo shapeInfo in e.Items)
         this.AddShapeInfo(shapeInfo);
     }
 
-    private void ShapeInfos_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IShapeInfo> e) {
-      foreach (IShapeInfo shapeInfo in e.Items)
+    private void ShapeInfos_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<IOperatorShapeInfo> e) {
+      foreach (IOperatorShapeInfo shapeInfo in e.Items)
         this.RemoveShapeInfo(shapeInfo);
     }
 
-    private void AddShapeInfo(IShapeInfo shapeInfo) {
+    private void AddShapeInfo(IOperatorShapeInfo shapeInfo) {
       this.RegisterShapeInfoEvents(shapeInfo);
 
@@ -158 +158 @@
     }
 
-    private void RemoveShapeInfo(IShapeInfo shapeInfo) {
+    private void RemoveShapeInfo(IOperatorShapeInfo shapeInfo) {
       this.DeregisterShapeInfoEvents(shapeInfo);
       IShape shape = this.shapeInfoShapeMapping.GetByFirst(shapeInfo);
@@ -179 +179 @@
 
     private void RegisterShapeInfoEvents(IShapeInfo shapeInfo) {
-      shapeInfo.Changed += new ChangedEventHandler(shapeInfo_Changed);
+      shapeInfo.Changed += new EventHandler(shapeInfo_Changed);
     }
 
     private void DeregisterShapeInfoEvents(IShapeInfo shapeInfo) {
-      shapeInfo.Changed -= new ChangedEventHandler(shapeInfo_Changed);
-    }
-
-    private void Connections_CollectionReset(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>> e) {
+      shapeInfo.Changed -= new EventHandler(shapeInfo_Changed);
+    }
+
+    private void Connections_CollectionReset(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>> e) {
       IConnection connection;
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> pair in e.Items) {
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> pair in e.Items) {
         connection = this.GetConnection(pair.Key.Key, pair.Key.Value);
         this.RemoveConnection(connection);
       }
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> pair in e.Items)
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> pair in e.Items)
         this.AddConnection(pair.Key.Key, pair.Key.Value, pair.Value);
     }
 
-    private void Connections_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>> e) {
+    private void Connections_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>> e) {
       IConnection connection;
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> pair in e.Items) {
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> pair in e.Items) {
         connection = this.GetConnection(pair.Key.Key, pair.Key.Value);
         this.RemoveConnection(connection);
       }
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> pair in e.Items)
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> pair in e.Items)
         this.AddConnection(pair.Key.Key, pair.Key.Value, pair.Value);
     }
 
-    private void Connections_ItemsAdded(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>> e) {
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> pair in e.Items)
+    private void Connections_ItemsAdded(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>> e) {
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> pair in e.Items)
         this.AddConnection(pair.Key.Key, pair.Key.Value, pair.Value);
     }
 
-    private void Connections_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>> e) {
+    private void Connections_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>> e) {
       IConnection connection;
-      foreach (KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo> pair in e.Items) {
+      foreach (KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> pair in e.Items) {
         connection = this.GetConnection(pair.Key.Key, pair.Key.Value);
         this.RemoveConnection(connection);
@@ -219 +219 @@
     }
 
-    private void AddConnection(IShapeInfo shapeInfoFrom, string connectorName, IShapeInfo shapeInfoTo) {
+    private void AddConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName, IOperatorShapeInfo shapeInfoTo) {
       IShape shapeFrom = this.shapeInfoShapeMapping.GetByFirst(shapeInfoFrom);
       IShape shapeTo = this.shapeInfoShapeMapping.GetByFirst(shapeInfoTo);
@@ -234 +234 @@
     }
 
-    private IConnection GetConnection(IShapeInfo shapeInfoFrom, string connectorName) {
+    private IConnection GetConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName) {
       IShape shape = this.shapeInfoShapeMapping.GetByFirst(shapeInfoFrom);
       IConnector connector = shape.Connectors.Where(c => c.Name == connectorName).First();
@@ -245 +245 @@
     }
 
-    private void ChangeConnection(IShapeInfo shapeInfoFrom, string connectorName, IShapeInfo shapeInfoTo) {
+    private void ChangeConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName, IOperatorShapeInfo shapeInfoTo) {
       IConnection connection = this.GetConnection(shapeInfoFrom, connectorName);
       IShape shapeTo = this.shapeInfoShapeMapping.GetByFirst(shapeInfoFrom);
@@ -272 +272 @@
 
 
-    private void shapeInfo_Changed(object sender, ChangedEventArgs e) {
+    private void shapeInfo_Changed(object sender, EventArgs e) {
       if (this.causedUpdateOfShapeInfo)
         return;
 
-      IShapeInfo shapeInfo = (IShapeInfo)sender;
+      this.causedUpdateOfShapeInfo = true;
+      IOperatorShapeInfo shapeInfo = (IOperatorShapeInfo)sender;
       IShape shape = this.shapeInfoShapeMapping.GetByFirst(shapeInfo);
       shapeInfo.UpdateShape(shape);
       shape.Invalidate();
+      this.causedUpdateOfShapeInfo = false;
     }
 
 
     private void shape_OnEntityChange(object sender, EntityEventArgs e) {
+      if (this.causedUpdateOfShapeInfo)
+        return;
+
       this.causedUpdateOfShapeInfo = true;
       IShape shape = e.Entity as IShape;
-      IShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(shape);
-
+      IOperatorShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(shape);
       shapeInfo.Location = shape.Location;
-      shapeInfo.Size = new Size(shape.Width, shape.Height);
-
+
+      OperatorShape operatorShape = shape as OperatorShape;
+      if (operatorShape != null)
+        shapeInfo.Collapsed = operatorShape.Collapsed;
+      
       this.graphVisualization.Invalidate();
       this.causedUpdateOfShapeInfo = false;
@@ -302 +309 @@
         this.RemoveConnection(connection); //is added again by the model events
 
-        if (connectorFrom != null && connectorTo != null) {
+        if (connectorFrom != null && connectorTo != null && connectorFrom.Name != "Predecessor") {
           IShape shapeFrom = (IShape)connectorFrom.Parent;
           IShape shapeTo = (IShape)connectorTo.Parent;
-          IShapeInfo shapeInfoFrom = this.shapeInfoShapeMapping.GetBySecond(shapeFrom);
-          IShapeInfo shapeInfoTo = this.shapeInfoShapeMapping.GetBySecond(shapeTo);
+          IOperatorShapeInfo shapeInfoFrom = this.shapeInfoShapeMapping.GetBySecond(shapeFrom);
+          IOperatorShapeInfo shapeInfoTo = this.shapeInfoShapeMapping.GetBySecond(shapeTo);
           string connectorName = connectorFrom.Name;
 
@@ -317 +324 @@
       IShape shape = e.Entity as IShape;
       if (shape != null && this.shapeInfoShapeMapping.ContainsSecond(shape)) {
-        IShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(shape);
+        IOperatorShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(shape);
         this.Content.RemoveShapeInfo(shapeInfo);
       }
@@ -324 +331 @@
       if (connection != null && this.connectionConnectorsMapping.ContainsFirst(connection)) {
         IShape parentShape = (IShape)connection.From.AttachedTo.Parent;
-        IShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(parentShape);
+        IOperatorShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(parentShape);
         string connectorName = connection.From.AttachedTo.Name;
 

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/HeuristicLab.Operators.Views.GraphVisualization-3.3.csproj

@@ -104 +104 @@
       <DependentUpon>GraphVisualizationInfoView.cs</DependentUpon>
     </Compile>
+    <Compile Include="Model\IOperatorShapeInfo.cs" />
     <Compile Include="Model\OperatorShapeInfo.cs" />
     <Compile Include="Model\GraphVisualizationInfo.cs" />
@@ -163 +164 @@
       <Name>HeuristicLab.Parameters-3.3</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/GraphVisualizationInfo.cs

@@ -28 +28 @@
 using System.Drawing;
 using HeuristicLab.Collections;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
   public sealed class GraphVisualizationInfo : DeepCloneable {
-    private BidirectionalLookup<IOperator, IShapeInfo> shapeInfoMapping;
+    private BidirectionalLookup<IOperator, IOperatorShapeInfo> operatorShapeInfoMapping;
+    [Storable]
+    private BidirectionalLookup<IOperator, IOperatorShapeInfo> OperatorShapeInfoMappingStore {
+      get { return this.operatorShapeInfoMapping; }
+      set {
+        foreach (KeyValuePair<IOperator, IOperatorShapeInfo> pair in value.FirstEnumerable)
+          this.AddShapeInfo(pair.Key, pair.Value);
+      }
+    }
+
     private BidirectionalLookup<IOperator, IObservableKeyedCollection<string, IParameter>> operatorParameterCollectionMapping;
-    private Dictionary<IValueParameter<IOperator>, IOperator> parameterOperatorMapping;
+    private Dictionary<IParameter, IOperator> parameterOperatorMapping;
 
     private GraphVisualizationInfo() {
-      this.shapeInfoMapping = new BidirectionalLookup<IOperator, IShapeInfo>();
+      this.operatorShapeInfoMapping = new BidirectionalLookup<IOperator, IOperatorShapeInfo>();
       this.operatorParameterCollectionMapping = new BidirectionalLookup<IOperator, IObservableKeyedCollection<string, IParameter>>();
-      this.parameterOperatorMapping = new Dictionary<IValueParameter<IOperator>, IOperator>();
-
-      this.shapeInfos = new ObservableSet<IShapeInfo>();
-      this.connections = new ObservableDictionary<KeyValuePair<IShapeInfo, string>, IShapeInfo>();
+      this.parameterOperatorMapping = new Dictionary<IParameter, IOperator>();
+
+      this.shapeInfos = new ObservableSet<IOperatorShapeInfo>();
+      this.connections = new ObservableDictionary<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>();
     }
 
@@ -53 +63 @@
 
       foreach (IOperator op in operatorGraph.Operators)
-        if (!this.shapeInfoMapping.ContainsFirst(op))
+        if (!this.operatorShapeInfoMapping.ContainsFirst(op))
           this.AddOperator(op);
 
@@ -65 +75 @@
 
     private void UpdateInitialShape() {
-      OperatorShapeInfo old = this.oldInitialShape as OperatorShapeInfo;
+      IOperatorShapeInfo old = this.oldInitialShape as OperatorShapeInfo;
       if (old != null)
-        old.HeadColor = oldInitialShapeColor;
+        old.Color = oldInitialShapeColor;
 
       OperatorShapeInfo newInitialShapeInfo = this.InitialShape as OperatorShapeInfo;
       if (newInitialShapeInfo != null) {
-        oldInitialShapeColor = newInitialShapeInfo.HeadColor;
-        newInitialShapeInfo.HeadColor = Color.LightGreen;
+        oldInitialShapeColor = newInitialShapeInfo.Color;
+        newInitialShapeInfo.Color = Color.LightGreen;
       }
 
@@ -80 +90 @@
     }
 
-    private IShapeInfo oldInitialShape;
+    [Storable]
+    private IOperatorShapeInfo oldInitialShape;
+    [Storable]
     private Color oldInitialShapeColor;
-    public IShapeInfo InitialShape {
+    public IOperatorShapeInfo InitialShape {
       get {
         IOperator op = this.operatorGraph.InitialOperator;
         if (op == null)
           return null;
-        return this.shapeInfoMapping.GetByFirst(op);
+        return this.operatorShapeInfoMapping.GetByFirst(op);
       }
       set {
@@ -93 +105 @@
           this.OperatorGraph.InitialOperator = null;
         else
-          this.OperatorGraph.InitialOperator = this.shapeInfoMapping.GetBySecond(value);
-      }
-    }
-
+          this.OperatorGraph.InitialOperator = this.operatorShapeInfoMapping.GetBySecond(value);
+      }
+    }
+
+    [Storable]
     private OperatorGraph operatorGraph;
     public OperatorGraph OperatorGraph {
@@ -102 +115 @@
     }
 
-    private ObservableSet<IShapeInfo> shapeInfos;
-    public INotifyObservableCollectionItemsChanged<IShapeInfo> ObserveableShapeInfos {
+    private ObservableSet<IOperatorShapeInfo> shapeInfos;
+    public INotifyObservableCollectionItemsChanged<IOperatorShapeInfo> ObserveableShapeInfos {
       get { return this.shapeInfos; }
     }
-    public IEnumerable<IShapeInfo> ShapeInfos {
+    public IEnumerable<IOperatorShapeInfo> OperatorShapeInfos {
       get { return this.shapeInfos; }
     }
-    public IOperator GetOperatorForShapeInfo(IShapeInfo shapeInfo) {
-      return this.shapeInfoMapping.GetBySecond(shapeInfo);
-    }
-
-    private ObservableDictionary<KeyValuePair<IShapeInfo, string>, IShapeInfo> connections;
-    public INotifyObservableDictionaryItemsChanged<KeyValuePair<IShapeInfo, string>, IShapeInfo> ObservableConnections {
+    public IOperator GetOperatorForShapeInfo(IOperatorShapeInfo shapeInfo) {
+      return this.operatorShapeInfoMapping.GetBySecond(shapeInfo);
+    }
+
+    [Storable]
+    private ObservableDictionary<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> connections;
+    public INotifyObservableDictionaryItemsChanged<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo> ObservableConnections {
       get { return this.connections; }
     }
-    public IEnumerable<KeyValuePair<KeyValuePair<IShapeInfo, string>, IShapeInfo>> Connections {
+    public IEnumerable<KeyValuePair<KeyValuePair<IOperatorShapeInfo, string>, IOperatorShapeInfo>> Connections {
       get { return this.connections; }
     }
 
     #region methods to manipulate operatorgraph by the shape info
-    internal void AddShapeInfo(IOperator op, IShapeInfo shapeInfo) {
+    internal void AddShapeInfo(IOperator op, IOperatorShapeInfo shapeInfo) {
       this.RegisterOperatorEvents(op);
       this.operatorParameterCollectionMapping.Add(op, op.Parameters);
-      this.shapeInfoMapping.Add(op, shapeInfo);
+      this.operatorShapeInfoMapping.Add(op, shapeInfo);
       this.shapeInfos.Add(shapeInfo);
 
@@ -131 +145 @@
         this.AddParameter(op, param);
 
-      this.operatorGraph.Operators.Add(op);
-    }
-
-    internal void RemoveShapeInfo(IShapeInfo shapeInfo) {
-      IOperator op = this.shapeInfoMapping.GetBySecond(shapeInfo);
+      if (!this.operatorGraph.Operators.Contains(op))
+        this.operatorGraph.Operators.Add(op);
+    }
+
+    internal void RemoveShapeInfo(IOperatorShapeInfo shapeInfo) {
+      IOperator op = this.operatorShapeInfoMapping.GetBySecond(shapeInfo);
       this.operatorGraph.Operators.Remove(op);
     }
 
-    internal void AddConnection(IShapeInfo shapeInfoFrom, string connectorName, IShapeInfo shapeInfoTo) {
-      IOperator opFrom = this.shapeInfoMapping.GetBySecond(shapeInfoFrom);
-      IOperator opTo = this.shapeInfoMapping.GetBySecond(shapeInfoTo);
+    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];
@@ -147 +162 @@
     }
 
-    internal void ChangeConnection(IShapeInfo shapeInfoFrom, string connectorName, IShapeInfo shapeInfoTo) {
-      IOperator opFrom = this.shapeInfoMapping.GetBySecond(shapeInfoFrom);
-      IOperator opTo = this.shapeInfoMapping.GetBySecond(shapeInfoTo);
+    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];
@@ -155 +170 @@
     }
 
-    internal void RemoveConnection(IShapeInfo shapeInfoFrom, string connectorName) {
-      IOperator opFrom = this.shapeInfoMapping.GetBySecond(shapeInfoFrom);
+    internal void RemoveConnection(IOperatorShapeInfo shapeInfoFrom, string connectorName) {
+      IOperator opFrom = this.operatorShapeInfoMapping.GetBySecond(shapeInfoFrom);
       IValueParameter<IOperator> param = (IValueParameter<IOperator>)opFrom.Parameters[connectorName];
       param.Value = null;
@@ -164 +179 @@
     #region operator events
     private void AddOperator(IOperator op) {
-      if (!this.shapeInfoMapping.ContainsFirst(op)) {
+      if (!this.operatorShapeInfoMapping.ContainsFirst(op)) {
         this.RegisterOperatorEvents(op);
-        IShapeInfo shapeInfo = Factory.CreateShapeInfo(op);
+        IOperatorShapeInfo shapeInfo = Factory.CreateOperatorShapeInfo(op);
         this.operatorParameterCollectionMapping.Add(op, op.Parameters);
-        this.shapeInfoMapping.Add(op, shapeInfo);
+        this.operatorShapeInfoMapping.Add(op, shapeInfo);
         foreach (IParameter param in op.Parameters)
           this.AddParameter(op, param);
@@ -181 +196 @@
         this.RemoveParameter(op, param);
 
-      IShapeInfo shapeInfo = this.shapeInfoMapping.GetByFirst(op);
+      IOperatorShapeInfo shapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
       this.operatorParameterCollectionMapping.RemoveByFirst(op);
-      this.shapeInfoMapping.RemoveByFirst(op);
+      this.operatorShapeInfoMapping.RemoveByFirst(op);
       this.shapeInfos.Remove(shapeInfo);
     }
@@ -189 +204 @@
     private void OperatorNameChanged(object sender, EventArgs e) {
       IOperator op = (IOperator)sender;
-      IShapeInfo shapeInfo = this.shapeInfoMapping.GetByFirst(op);
-      OperatorShapeInfo operatorShapeInfo = shapeInfo as OperatorShapeInfo;
-      if (operatorShapeInfo != null)
-        operatorShapeInfo.Title = op.Name;
+      IOperatorShapeInfo operatorShapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
+      operatorShapeInfo.Title = op.Name;
     }
 
@@ -229 +242 @@
     #region parameter events
     private void AddParameter(IOperator op, IParameter param) {
+      this.parameterOperatorMapping.Add(param, op);
       IValueParameter<IOperator> opParam = param as IValueParameter<IOperator>;
       if (opParam != null) {
         this.RegisterOperatorParameterEvents(opParam);
-        this.parameterOperatorMapping.Add(opParam, op);
-        IShapeInfo shapeInfo = this.shapeInfoMapping.GetByFirst(op);
+        IOperatorShapeInfo shapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
         shapeInfo.AddConnector(param.Name);
 
         if (opParam.Value != null) {
-          if (!this.shapeInfoMapping.ContainsFirst(opParam.Value))
+          if (!this.operatorShapeInfoMapping.ContainsFirst(opParam.Value))
             this.AddOperator(opParam.Value);
-          this.connections.Add(new KeyValuePair<IShapeInfo, string>(shapeInfo, param.Name), this.shapeInfoMapping.GetByFirst(opParam.Value));
+          this.connections.Add(new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, param.Name), this.operatorShapeInfoMapping.GetByFirst(opParam.Value));
         }
-      }
+      } else
+        this.RegisterParameterEvents(param);
     }
 
@@ -248 +262 @@
       if (opParam != null) {
         this.DeregisterOperatorParameterEvents(opParam);
-        this.parameterOperatorMapping.Remove(opParam);
-        IShapeInfo shapeInfo = this.shapeInfoMapping.GetByFirst(op);
-
-        this.connections.Remove(new KeyValuePair<IShapeInfo, string>(shapeInfo, param.Name));
+        IOperatorShapeInfo shapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
+        this.connections.Remove(new KeyValuePair<IOperatorShapeInfo, string>(shapeInfo, param.Name));
         shapeInfo.RemoveConnector(param.Name);
-      }
+      } else
+        this.DeregisterParameterEvents(param);
+
+      this.parameterOperatorMapping.Remove(param);
     }
 
@@ -260 +275 @@
       if (opParam != null) {
         IOperator op = this.parameterOperatorMapping[opParam];
-        IShapeInfo shapeInfo = this.shapeInfoMapping.GetByFirst(op);
-        KeyValuePair<IShapeInfo, string> connectionFrom = new KeyValuePair<IShapeInfo, string>(shapeInfo, opParam.Name);
+        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.shapeInfoMapping.ContainsFirst(opParam.Value))
+          if (!this.operatorShapeInfoMapping.ContainsFirst(opParam.Value))
             this.AddOperator(opParam.Value);
-          this.connections[connectionFrom] = this.shapeInfoMapping.GetByFirst(opParam.Value);
+          this.connections[connectionFrom] = this.operatorShapeInfoMapping.GetByFirst(opParam.Value);
         }
       }
@@ -278 +293 @@
       foreach (IParameter param in e.Items)
         AddParameter(op, param);
+      this.UpdateParameterLabels(op);
     }
     private void Parameters_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
@@ -284 +300 @@
       foreach (IParameter param in e.Items)
         RemoveParameter(op, param);
+      this.UpdateParameterLabels(op);
     }
     private void Parameters_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
@@ -292 +309 @@
       foreach (IParameter param in e.Items)
         AddParameter(op, param);
+      this.UpdateParameterLabels(op);
     }
     private void Parameters_CollectionReset(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
@@ -300 +318 @@
       foreach (IParameter param in e.Items)
         AddParameter(op, param);
+      this.UpdateParameterLabels(op);
     }
 
@@ -307 +326 @@
     private void DeregisterOperatorParameterEvents(IValueParameter<IOperator> opParam) {
       opParam.ValueChanged -= new EventHandler(opParam_ValueChanged);
+    }
+    private void RegisterParameterEvents(IParameter param) {
+      param.ToStringChanged += new EventHandler(param_ToStringChanged);
+      param.NameChanged += new EventHandler(param_NameChanged);
+    }
+    private void DeregisterParameterEvents(IParameter param) {
+      param.ToStringChanged -= new EventHandler(param_ToStringChanged);
+      param.NameChanged -= new EventHandler(param_NameChanged);
+    }
+
+    private void param_NameChanged(object sender, EventArgs e) {
+      IParameter param = (IParameter)sender;
+      IOperator op = this.parameterOperatorMapping[param];
+      this.UpdateParameterLabels(op);
+    }
+    private void param_ToStringChanged(object sender, EventArgs e) {
+      IParameter param = (IParameter)sender;
+      IOperator op = this.parameterOperatorMapping[param];
+      this.UpdateParameterLabels(op);
+    }
+
+    private void UpdateParameterLabels(IOperator op) {
+      IEnumerable<IParameter> parameters = op.Parameters.Where(p => !(p is IValueParameter<IOperator>));
+      IOperatorShapeInfo operatorShapeInfo = this.operatorShapeInfoMapping.GetByFirst(op);
+      if (parameters.Count() > 0)
+        operatorShapeInfo.UpdateLabels(parameters.Select(p => p.ToString()));
+      else
+        operatorShapeInfo.UpdateLabels(new List<string>());
     }
     #endregion

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/IShapeInfo.cs

@@ -33 +33 @@
     Type ShapeType { get; }
     Point Location { get; set; }
-    Size Size { get; set; }
-
-    void AddConnector(string connectorName);
-    void RemoveConnector(string connectorName);
 
     IShape CreateShape();
     void UpdateShape(IShape shape);
+
+    event EventHandler Changed;
   }
 }

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/OperatorShape.cs

@@ -26 +26 @@
 using Netron.Diagramming.Core;
 using System.Drawing;
+using System.Drawing.Drawing2D;
+using HeuristicLab.Netron;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
-  public class OperatorShape : ClassShape {
-
+  public class OperatorShape : ComplexShapeBase {
+    private static int LABEL_HEIGHT = 16;
+    private static int LABEL_WIDTH = 180;
+    private static int LABEL_SPACING = 3;
+    private static int HEADER_HEIGHT = 30;
+
+    private ExpandableIconMaterial expandIconMaterial;
     public OperatorShape()
       : base() {
+      this.Resizable = false;
       this.additionalConnectors = new List<IConnector>();
-    }
-
+      this.labels = new List<string>();
+    }
+
+    public override string EntityName {
+      get { return "Operator Shape"; }
+    }
+
+    public bool Collapsed {
+      get { return this.expandIconMaterial.Collapsed; }
+      set {
+        if (this.expandIconMaterial.Collapsed != value)
+          this.expandIconMaterial.Collapsed = value;
+      }
+    }
+
+    private Color color;
+    public Color Color {
+      get { return this.color; }
+      set { this.color = value; }
+    }
+
+    private string title;
+    public string Title {
+      get { return title; }
+      set { title = value; }
+    }
+
+    private IconMaterial iconMaterial;
+    public Bitmap Icon {
+      get { return this.iconMaterial.Icon; }
+      set {
+        this.iconMaterial.Icon = value;
+        this.iconMaterial.Transform(new Rectangle(new Point(Rectangle.X + 5, Rectangle.Y + 5), this.iconMaterial.Icon.Size));
+      }
+    }
+
+    #region additional connectors
     private List<IConnector> additionalConnectors;
     public IEnumerable<string> AdditionalConnectorNames {
@@ -58 +101 @@
     }
 
-
-
     public void AddConnector(string connectorName) {
       IConnector connector = this.CreateConnector(connectorName, this.BottomRightCorner);
@@ -89 +130 @@
       }
     }
-
+    #endregion
+
+    #region label material
+    private List<string> labels;
+    public IEnumerable<string> Labels {
+      get { return this.labels; }
+    }
+
+    public void UpdateLabels(IEnumerable<string> labels) {
+      this.labels = new List<string>(labels);
+      this.expandIconMaterial.Visible = this.labels.Count != 0;
+      this.UpdateLabels();
+    }
+    #endregion
+
+    private void expandIconMaterial_OnExpand(object sender, EventArgs e) {
+      this.UpdateLabels();
+    }
+
+    private void expandIconMaterial_OnCollapse(object sender, EventArgs e) {
+      this.UpdateLabels();
+    }
+
+    private Size CalculateSize() {
+      int width = this.Rectangle.Width;
+      int height = HEADER_HEIGHT;
+      if (!Collapsed)
+        height += this.labels.Count * (LABEL_HEIGHT + LABEL_SPACING);
+      return new Size(width, height);
+    }
+
+    private void UpdateLabels() {
+      Size newSize = CalculateSize();
+      if (this.Rectangle.Size != newSize) {
+        foreach (IConnector connector in this.additionalConnectors)
+          connector.MoveBy(new Point(0, newSize.Height - this.Rectangle.Height));
+        this.mRectangle = new Rectangle(this.Rectangle.Location, newSize);
+        this.Invalidate();
+        this.RaiseOnChange(this, new EntityEventArgs(this));
+      }
+    }
 
     protected override void Initialize() {
       base.Initialize();
 
-      #region Connectors
-      this.Connectors.Clear();
-
-      predecessor = this.CreateConnector("Predecessor", new Point(Rectangle.Left, Center.Y));
-      Connectors.Add(predecessor);
-
-      successor = this.CreateConnector("Successor", (new Point(Rectangle.Right, Center.Y)));
-      Connectors.Add(successor);
-      #endregion
+      //the initial size
+      this.Transform(0, 0, 200, HEADER_HEIGHT);
+      this.color = Color.LightBlue;
+
+      this.iconMaterial = new IconMaterial();
+      this.iconMaterial.Gliding = false;
+      this.Children.Add(iconMaterial);
+
+      Bitmap expandBitmap = new Bitmap(HeuristicLab.Common.Resources.VS2008ImageLibrary.Redo);
+      Bitmap collapseBitmap = new Bitmap(HeuristicLab.Common.Resources.VS2008ImageLibrary.Undo);
+      this.expandIconMaterial = new ExpandableIconMaterial(expandBitmap, collapseBitmap);
+      this.expandIconMaterial.Gliding = false;
+      this.expandIconMaterial.Transform(new Rectangle(new Point(Rectangle.Right - 20, Rectangle.Y + 7), expandIconMaterial.Icon.Size));
+      this.expandIconMaterial.Visible = false;
+      this.expandIconMaterial.OnExpand += new EventHandler(expandIconMaterial_OnExpand);
+      this.expandIconMaterial.OnCollapse += new EventHandler(expandIconMaterial_OnCollapse);
+      this.Children.Add(expandIconMaterial);
+
+      this.predecessor = this.CreateConnector("Predecessor", new Point(Rectangle.Left, Center.Y));
+      this.Connectors.Add(predecessor);
+
+      this.successor = this.CreateConnector("Successor", (new Point(Rectangle.Right, Center.Y)));
+      this.Connectors.Add(successor);
+    }
+
+    public override void Paint(Graphics g) {
+      base.Paint(g);
+
+      g.SmoothingMode = SmoothingMode.HighQuality;
+
+      Pen pen;
+      if (Hovered)
+        pen = ArtPalette.HighlightPen;
+      else
+        pen = mPenStyle.DrawingPen();
+
+      GraphicsPath path = new GraphicsPath();
+      path.AddArc(Rectangle.X, Rectangle.Y, 20, 20, -180, 90);
+      path.AddLine(Rectangle.X + 10, Rectangle.Y, Rectangle.X + Rectangle.Width - 10, Rectangle.Y);
+      path.AddArc(Rectangle.X + Rectangle.Width - 20, Rectangle.Y, 20, 20, -90, 90);
+      path.AddLine(Rectangle.X + Rectangle.Width, Rectangle.Y + 10, Rectangle.X + Rectangle.Width, Rectangle.Y + Rectangle.Height - 10);
+      path.AddArc(Rectangle.X + Rectangle.Width - 20, Rectangle.Y + Rectangle.Height - 20, 20, 20, 0, 90);
+      path.AddLine(Rectangle.X + Rectangle.Width - 10, Rectangle.Y + Rectangle.Height, Rectangle.X + 10, Rectangle.Y + Rectangle.Height);
+      path.AddArc(Rectangle.X, Rectangle.Y + Rectangle.Height - 20, 20, 20, 90, 90);
+      path.AddLine(Rectangle.X, Rectangle.Y + Rectangle.Height - 10, Rectangle.X, Rectangle.Y + 10);
+      //shadow
+      if (ArtPalette.EnableShadows) {
+        Region darkRegion = new Region(path);
+        darkRegion.Translate(5, 5);
+        g.FillRegion(ArtPalette.ShadowBrush, darkRegion);
+      }
+      //background
+      g.FillPath(Brush, path);
+
+      using (LinearGradientBrush gradientBrush = new LinearGradientBrush(Rectangle.Location, new Point(Rectangle.X + Rectangle.Width, Rectangle.Y), this.Color, Color.White)) {
+        Region gradientRegion = new Region(path);
+        g.FillRegion(gradientBrush, gradientRegion);
+      }
+
+      if (!this.Collapsed) {
+        TextStyle textStyle = new TextStyle(Color.Black, new Font("Arial", 7), StringAlignment.Near, StringAlignment.Near);
+        StringFormat stringFormat = textStyle.StringFormat;
+        stringFormat.Trimming = StringTrimming.EllipsisWord;
+        stringFormat.FormatFlags = StringFormatFlags.LineLimit;
+        Rectangle rect;
+
+        for (int i = 0; i < this.labels.Count; i++) {
+          rect = new Rectangle(Rectangle.X + 25, Rectangle.Y + HEADER_HEIGHT + i * (LABEL_HEIGHT + LABEL_SPACING), LABEL_WIDTH, LABEL_HEIGHT);
+          g.DrawString(textStyle.GetFormattedText(this.labels[i]), textStyle.Font, textStyle.GetBrush(), rect, stringFormat);
+        }
+      }
+
+      //the border
+      g.DrawPath(pen, path);
+
+      //the title
+      g.DrawString(this.Title, ArtPalette.DefaultBoldFont, Brushes.Black, new Rectangle(Rectangle.X + 25, Rectangle.Y + 5, Rectangle.Width - 45, 27));
+
+      //the material
+      foreach (IPaintable material in Children)
+        material.Paint(g);
+
+      //the connectors
+      if (this.ShowConnectors) {
+        for (int k = 0; k < Connectors.Count; k++)
+          Connectors[k].Paint(g);
+      }
     }
   }

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

@@ -28 +28 @@
 using Netron.Diagramming.Core;
 using System.Windows.Forms;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
-  internal class OperatorShapeInfo : ShapeInfo {
+  internal class OperatorShapeInfo : ShapeInfo, IOperatorShapeInfo {
+    [Storable]
+    private List<string> connectorNames;
+    [Storable]
+    private List<string> labels;
 
-    private List<string> connectorNames;
     public OperatorShapeInfo()
       : base(typeof(OperatorShape)) {
       this.connectorNames = new List<string>();
+      this.labels = new List<string>();
     }
 
@@ -44 +49 @@
     }
 
-    public override void AddConnector(string connectorName) {
+    public OperatorShapeInfo(IEnumerable<string> connectorNames, IEnumerable<string> labels)
+      : this(connectorNames) {
+      foreach (string label in labels)
+        this.labels.Add(label);
+    }
+
+    public void AddConnector(string connectorName) {
       if (!this.connectorNames.Contains(connectorName) && connectorName != "Successor") {
         this.connectorNames.Add(connectorName);
@@ -51 +62 @@
     }
 
-    public override void RemoveConnector(string connectorName) {
+    public void RemoveConnector(string connectorName) {
       if (this.connectorNames.Contains(connectorName)) {
         this.connectorNames.Remove(connectorName);
@@ -58 +69 @@
     }
 
+    public void UpdateLabels(IEnumerable<string> labels) {
+      this.labels = new List<string>(labels);
+      this.OnChanged();
+    }
+
+    [Storable]
+    private bool collapsed;
+    public bool Collapsed {
+      get { return this.collapsed; }
+      set {
+        if (this.collapsed != value) {
+          this.collapsed = value;
+          this.OnChanged();
+        }
+      }
+    }
+
+    [Storable]
     private string title;
     public string Title {
@@ -69 +98 @@
     }
 
-    private string text;
-    public string Text {
-      get { return this.text; }
+    [Storable]
+    private Color color;
+    public Color Color {
+      get { return this.color; }
       set {
-        if (this.text != value) {
-          this.text = value;
+        if (this.color != value) {
+          this.color = value;
           this.OnChanged();
         }
@@ -80 +110 @@
     }
 
-    private Color headColor;
-    public Color HeadColor {
-      get { return this.headColor; }
+    [Storable]
+    private Bitmap icon;
+    public Bitmap Icon {
+      get { return this.icon; }
       set {
-        if (this.headColor != value) {
-          this.headColor = value;
+        if (this.icon != value) {
+          this.icon = value;
           this.OnChanged();
         }
@@ -94 +125 @@
       OperatorShape shape = (OperatorShape)base.CreateShape();
       shape.Title = this.Title;
-      shape.SubTitle = this.Text;
-      shape.HeadColor = this.HeadColor;
+      shape.Color = this.Color;
+      shape.Icon = this.Icon;
+      shape.Collapsed = this.Collapsed;
       foreach (string connectorName in this.connectorNames)
         shape.AddConnector(connectorName);
+
+      shape.UpdateLabels(this.labels);
       return shape;
     }
@@ -104 +138 @@
       base.UpdateShape(shape);
       OperatorShape operatorShape = shape as OperatorShape;
-
       if (operatorShape != null) {
         operatorShape.Title = this.Title;
-        operatorShape.SubTitle = this.Text;
-        operatorShape.HeadColor = this.HeadColor;
+        operatorShape.Color = this.Color;
+        operatorShape.Collapsed = this.Collapsed;
 
         int i = 0;
@@ -121 +154 @@
           j++;
         }
-        //remove old connectors
+        //remove remaining old connectors
         for (; j < oldConnectorNames.Count; j++)
           operatorShape.RemoveConnector(oldConnectorNames[j]);
@@ -128 +161 @@
         for (; i < this.connectorNames.Count; i++)
           operatorShape.AddConnector(this.connectorNames[i]);
+
+        operatorShape.UpdateLabels(this.labels);
       }
     }

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/ShapeInfo.cs

@@ -28 +28 @@
 using Netron.Diagramming.Core;
 using HeuristicLab.Collections;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators.Views.GraphVisualization {
-  internal abstract class ShapeInfo : Item, IShapeInfo {
+  internal abstract class ShapeInfo : Item,IShapeInfo {
+    private ShapeInfo() {
+
+    }
     protected ShapeInfo(Type shapeType) {
       if (!typeof(IShape).IsAssignableFrom(shapeType))
@@ -37 +41 @@
     }
 
+    public event EventHandler Changed;
+
+    [Storable]
     private Type shapeType;
     public Type ShapeType {
@@ -42 +49 @@
     }
 
+    [Storable]
     private Point location;
     public Point Location {
@@ -53 +61 @@
     }
 
-    private Size size;
-    public Size Size {
-      get { return this.size; }
-      set {
-        if (this.size != value) {
-          this.size = value;
-          this.OnChanged();
-        }
-      }
+    protected void OnChanged() {
+      if (this.Changed != null)
+        this.Changed(this, EventArgs.Empty);
     }
-
-    public abstract void AddConnector(string connectorName);
-    public abstract void RemoveConnector(string connectorName);
 
     public virtual IShape CreateShape() {
@@ -71 +70 @@
       shape.Tag = this;
       shape.Location = this.Location;
-      shape.Height = this.Size.Height;
-      shape.Width = this.Size.Width;
       return shape;
     }
@@ -78 +75 @@
     public virtual void UpdateShape(IShape shape) {
       shape.Location = this.Location;
-      shape.Height = this.Size.Height;
-      shape.Width = this.Size.Width;
     }
   }

trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model/ShapeInfoFactory.cs

@@ -38 +38 @@
     }
 
-    public static IShapeInfo CreateShapeInfo(IOperator op) {
-      IEnumerable<string> paramterNames = op.Parameters.Where(p => p is IValueParameter<IOperator> && p.Name != "Successor").Select(p => p.Name);
-      OperatorShapeInfo operatorShapeInfo = new OperatorShapeInfo(paramterNames);
+    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> paramaterNameValues = op.Parameters.Where(p => !(p is IValueParameter<IOperator>)).Select(p => p.ToString());
+
+      OperatorShapeInfo operatorShapeInfo = new OperatorShapeInfo(operatorParameterNames,paramaterNameValues);
+      operatorShapeInfo.Collapsed = true;
       operatorShapeInfo.Title = op.Name;
-      operatorShapeInfo.Text = op.GetType().ToString();
-      operatorShapeInfo.HeadColor = Color.LightBlue;
+      operatorShapeInfo.Color = Color.LightBlue;
+      operatorShapeInfo.Icon = new Bitmap(op.ItemImage);
 
       return operatorShapeInfo;

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

@@ -40 +40 @@
       this.zoomInButton = new System.Windows.Forms.Button();
       this.zoomOutButton = new System.Windows.Forms.Button();
+      this.screenshotButton = new System.Windows.Forms.Button();
       this.buttonToolTip = new System.Windows.Forms.ToolTip();
       this.shapeContextMenu.SuspendLayout();
@@ -100 +101 @@
       // splitContainer.Panel1
       // 
+      this.splitContainer.Panel1.Controls.Add(this.screenshotButton);
       this.splitContainer.Panel1.Controls.Add(this.zoomOutButton);
       this.splitContainer.Panel1.Controls.Add(this.zoomInButton);
@@ -213 +215 @@
       this.zoomOutButton.Click += new System.EventHandler(zoomOutButton_Click);
       this.buttonToolTip.SetToolTip(this.zoomOutButton, "Zoom Out");
+      // 
+      // screenshotButton
+      // 
+      this.screenshotButton.Image = HeuristicLab.Common.Resources.VS2008ImageLibrary.Copy;
+      this.screenshotButton.Location = new System.Drawing.Point(243, 3);
+      this.screenshotButton.Name = "screenshotButton";
+      this.screenshotButton.Size = new System.Drawing.Size(24, 24);
+      this.screenshotButton.TabIndex = 8;
+      this.screenshotButton.UseVisualStyleBackColor = true;
+      this.screenshotButton.Click += new System.EventHandler(screenshotButton_Click);
+      this.buttonToolTip.SetToolTip(this.screenshotButton, "Screenshot");
       // 
       // OperatorGraphView
@@ -249 +262 @@
     private System.Windows.Forms.Button connectButton;
     private System.Windows.Forms.Button panButton;
+    private System.Windows.Forms.Button screenshotButton;
     private System.Windows.Forms.ToolTip buttonToolTip;
   }

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

@@ -78 +78 @@
     }
 
-
-    #region connector tooltips
-
-    #endregion
-
     private void Controller_SelectionChanged(object sender, EventArgs e) {
       CollectionBase<IDiagramEntity> selectedObjects = this.graphVisualizationInfoView.Controller.Model.Selection.SelectedItems;
@@ -89 +84 @@
         IShape shape = selectedObjects[0] as IShape;
         if (shape != null) {
-          IShapeInfo shapeInfo = shape.Tag as ShapeInfo;
+          IOperatorShapeInfo shapeInfo = shape.Tag as IOperatorShapeInfo;
           IOperator op = this.VisualizationInfo.GetOperatorForShapeInfo(shapeInfo);
           this.detailsViewHost.Content = op;
@@ -104 +99 @@
         }
         if (shape != null) {
-          IShapeInfo shapeInfo = shape.Tag as ShapeInfo;
+          IOperatorShapeInfo shapeInfo = shape.Tag as IOperatorShapeInfo;
           IOperator op = this.VisualizationInfo.GetOperatorForShapeInfo(shapeInfo);
           if (connectorName != "Predecessor") {
@@ -129 +124 @@
 
     private void shapeContextMenu_Opening(object sender, System.ComponentModel.CancelEventArgs e) {
-      IShapeInfo shapeInfo = this.shapeContextMenu.Tag as ShapeInfo;
+      IOperatorShapeInfo shapeInfo = this.shapeContextMenu.Tag as IOperatorShapeInfo;
       if (shapeInfo != null) {
         IOperator op = this.VisualizationInfo.GetOperatorForShapeInfo(shapeInfo);
@@ -138 +133 @@
 
     private void openViewToolStripMenuItem_Click(object sender, EventArgs e) {
-      IShapeInfo shapeInfo = this.shapeContextMenu.Tag as ShapeInfo;
+      IOperatorShapeInfo shapeInfo = this.shapeContextMenu.Tag as IOperatorShapeInfo;
       if (shapeInfo != null) {
         IOperator op = this.VisualizationInfo.GetOperatorForShapeInfo(shapeInfo);
@@ -146 +141 @@
 
     private void initialOperatorToolStripMenuItem_Click(object sender, EventArgs e) {
-      IShapeInfo shapeInfo = this.shapeContextMenu.Tag as ShapeInfo;
+      IOperatorShapeInfo shapeInfo = this.shapeContextMenu.Tag as IOperatorShapeInfo;
       if (this.VisualizationInfo.InitialShape == shapeInfo)
         this.VisualizationInfo.InitialShape = null;
@@ -154 +149 @@
 
     private void breakPointToolStripMenuItem_Click(object sender, EventArgs e) {
-      IShapeInfo shapeInfo = this.shapeContextMenu.Tag as ShapeInfo;
+      IOperatorShapeInfo shapeInfo = this.shapeContextMenu.Tag as IOperatorShapeInfo;
       if (shapeInfo != null) {
         IOperator op = this.VisualizationInfo.GetOperatorForShapeInfo(shapeInfo);
@@ -174 +169 @@
       if (e.Effect != DragDropEffects.None) {
         IOperator op = e.Data.GetData("Value") as IOperator;
-        IShapeInfo shapeInfo = Factory.CreateShapeInfo(op);
+        IOperatorShapeInfo shapeInfo = Factory.CreateOperatorShapeInfo(op);
         Point mouse = new Point(MousePosition.X, MousePosition.Y);
-        Point p = new Point(e.X, e.Y);
-        Point screen = this.PointToScreen(new Point(0, 0));
-        PointF worldPoint = this.graphVisualizationInfoView.Controller.View.WorldToView(new Point(mouse.X - screen.X, mouse.Y - screen.Y));
+        Point screen = this.graphVisualizationInfoView.PointToScreen(new Point(0, 0));
+        Point control = new Point(mouse.X - screen.X, mouse.Y - screen.Y);
+        PointF worldPoint = this.graphVisualizationInfoView.Controller.View.ViewToWorld(control);
+
+        if (worldPoint.X < 0)
+          worldPoint.X = 0;
+        if (worldPoint.Y < 0)
+          worldPoint.Y = 0;
 
         shapeInfo.Location = Point.Round(worldPoint);
@@ -184 +184 @@
       }
     }
-
     #endregion
 
@@ -237 +236 @@
 
     private void zoomAreaButton_Click(object sender, EventArgs e) {
-      this.graphVisualizationInfoView.Controller.ActivateTool(ControllerBase.ZoomAreaToolName);
+      this.graphVisualizationInfoView.Controller.View.ZoomFit();
     }
 
@@ -247 +246 @@
       this.graphVisualizationInfoView.Controller.ActivateTool(ControllerBase.ZoomOutToolName);
     }
+
+    private void screenshotButton_Click(object sender, EventArgs e) {
+      Bitmap bitmap = ImageExporter.FromBundle(new Bundle(this.graphVisualizationInfoView.Controller.Model.Paintables),this.graphVisualizationInfoView.Controller.View.Graphics);
+      SaveFileDialog saveFileDialog = new SaveFileDialog();
+      saveFileDialog.Title = "Save Screenshot";
+      saveFileDialog.DefaultExt = "bmp";
+      saveFileDialog.Filter = "Bitmap|*.bmp|All Files|*.*";
+      saveFileDialog.FilterIndex = 1;
+
+      if (saveFileDialog.ShowDialog() == DialogResult.OK) {
+        bitmap.Save(saveFileDialog.FileName);
+      }
+    }
+
   }
 }