Changeset 2934 for trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/Model

Timestamp:

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

Author:

mkommend

Message:

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

Location:

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

Files:

• GraphVisualizationInfo.cs (modified) (20 diffs)
• IOperatorShapeInfo.cs (added)
• IShapeInfo.cs (modified) (1 diff)
• OperatorShape.cs (modified) (3 diffs)
• OperatorShapeInfo.cs (modified) (10 diffs)
• ShapeInfo.cs (modified) (6 diffs)
• ShapeInfoFactory.cs (modified) (1 diff)

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;