source: branches/OptimizationNetworks/HeuristicLab.Networks.Views.NetworkVisualization.Views/3.3/NetworkVisualizationView.cs @ 15802

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Collections;
using HeuristicLab.Core.Networks;
using HeuristicLab.Core.Networks.Views;
using HeuristicLab.MainForm;
using HeuristicLab.Networks.Views.NetworkVisualization.Views.ChartModes;
using HeuristicLab.Visualization;
using HeuristicLab.Visualization.ChartModes;

namespace HeuristicLab.Networks.Views.NetworkVisualization.Views {
  [View("Network Visualization View")]
  [Content(typeof(Network), false)]
  [Content(typeof(INetwork), false)]
  public partial class NetworkVisualizationView : NetworkItemView {
    private Dictionary<string, IPrimitive> primitiveDict = new Dictionary<string, IPrimitive>();

    public new INetwork Content {
      get { return (INetwork)base.Content; }
      set { base.Content = value; }
    }

    public NetworkVisualizationView() {
      InitializeComponent();

      var selectMode = new SelectChartMode(chartControl);
      selectMode.SelectedPrimitivesChanged += SelectMode_SelectedPrimitivesChanged;
      chartControl.AddChartModes(
        selectMode,
        new PanChartMode(chartControl),
        new RulerChartMode(chartControl),
        new ZoomInChartMode(chartControl),
        new ZoomOutChartMode(chartControl),
        new AddNodesChartMode(chartControl),
        new AddPortsChartMode(chartControl),
        new ConnectPortsChartMode(chartControl)
      );
      chartControl.Mode = selectMode;
    }

    protected override void OnContentChanged() {
      base.OnContentChanged();
      bool doLayout = Content != null && Content.Nodes.Any(x => x.VisualProperties == null);
      UpdateContent();
      if (doLayout) {
        LayoutNodes();
        LayoutPorts();
      }
      chartControl.Tag = Content;
    }

    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      Content.Nodes.ItemsAdded += Nodes_ItemsAdded;
      Content.Nodes.ItemsRemoved += Nodes_ItemsRemoved;
      Content.Nodes.ItemsReplaced += Nodes_ItemsReplaced;
      Content.Ports.ItemsAdded += Ports_ItemsAdded;
      Content.Ports.ItemsRemoved += Ports_ItemsRemoved;
      Content.Ports.ItemsReplaced += Ports_ItemsReplaced;
    }

    protected override void DeregisterContentEvents() {
      Content.Nodes.ItemsAdded -= Nodes_ItemsAdded;
      Content.Nodes.ItemsRemoved -= Nodes_ItemsRemoved;
      Content.Nodes.ItemsReplaced -= Nodes_ItemsReplaced;
      Content.Ports.ItemsAdded -= Ports_ItemsAdded;
      Content.Ports.ItemsRemoved -= Ports_ItemsRemoved;
      Content.Ports.ItemsReplaced -= Ports_ItemsReplaced;
      base.DeregisterContentEvents();
    }

    #region Event Handlers
    private void SelectMode_SelectedPrimitivesChanged(object sender, EventArgs e) {
      var selectedPrimitives = chartControl.Chart.Group.SelectedPrimitives;
      var nodePrimitive = selectedPrimitives.OfType<NodeRectangle>().SingleOrDefault();
      viewHost.Content = nodePrimitive != null ? nodePrimitive.NetworkItem : null;
    }

    #region Nodes Event Handlers
    private void Nodes_ItemsAdded(object sender, CollectionItemsChangedEventArgs<INode> e) {
      // TODO: don't update everything
      UpdateContent();
    }

    private void Nodes_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<INode> e) {
      // TODO: don't update everything
      UpdateContent();
    }

    private void Nodes_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<INode> e) {
      // TODO: don't update everything
      UpdateContent();
    }
    #endregion

    #region Ports Event Handlers
    private void Ports_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IPort> e) { }

    private void Ports_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IPort> e) { }

    private void Ports_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IPort> e) { }
    #endregion

    private void detailsToggleButton_Click(object sender, EventArgs e) {
      splitContainer.Panel2Collapsed = !splitContainer.Panel2Collapsed;
      detailsToggleButton.Text = splitContainer.Panel2Collapsed ? "<" : ">";
    }
    #endregion

    #region Helpers
    private void UpdateContent() {
      if (Content == null) return;

      chartControl.SuspendRendering();
      try {
        foreach (var r in primitiveDict.Values.OfType<NodeRectangle>())
          r.NetworkItem = null;
        primitiveDict.Clear();
        chartControl.Chart.Group.Clear();
        DrawNodes();
        ConnectNodes();
      } finally {
        chartControl.ResumeRendering();
      }
    }

    private void DrawNodes() {
      foreach (var node in Content.Nodes) {
        var defaultPrimitive = PrimitiveAttribute.CreateDefaultPrimitive(node.GetType(), chartControl.Chart, node);
        if (defaultPrimitive == null) continue;
        chartControl.Chart.Group.Add(defaultPrimitive);
        primitiveDict[node.Name] = defaultPrimitive;
      }
    }

    private void ConnectNodes() {
      foreach (var node in Content.Nodes) {
        var nodeRectangle = primitiveDict[node.Name] as NodeRectangle;
        if (nodeRectangle == null) continue;

        foreach (var port in node.Ports.OfType<IConnectablePort>()) {
          var connectedPort = port.ConnectedPort as IConnectablePort;
          if (connectedPort == null) continue;

          var connectedNode = connectedPort.Parent;
          if (connectedNode == null) continue;

          var connectedRectangle = primitiveDict[connectedNode.Name] as NodeRectangle;
          if (connectedRectangle == null) continue;

          var leftPortRectangle = (PortRectangle)nodeRectangle.GetPortPrimitive(port);
          var rightPortRectangle = (PortRectangle)connectedRectangle.GetPortPrimitive(connectedPort);

          var connectionShape = new ConnectionLine(chartControl.Chart, leftPortRectangle, rightPortRectangle);

          chartControl.Chart.Group.Add(connectionShape);
        }
      }
    }

    private void LayoutNodes() {
      var layout = new Layout();
      var layoutNodes = new Dictionary<string, Layout.LayoutNode>();

      foreach (var node in Content.Nodes) {
        var nodeRectangle = primitiveDict[node.Name] as NodeRectangle;
        if (nodeRectangle == null) continue;

        var nodeSize = chartControl.Chart.TransformWorldToPixel(nodeRectangle.Size);
        Layout.LayoutNode layoutNode;
        if (!layoutNodes.TryGetValue(node.Name, out layoutNode)) {
          layoutNodes.Add(node.Name, layoutNode = new Layout.LayoutNode(nodeSize));
          layout.AddNode(layoutNode);
        }

        foreach (var port in node.Ports.OfType<IConnectablePort>()) {
          var connectedPort = port.ConnectedPort as IConnectablePort;
          if (connectedPort == null) continue;

          var connectedNode = connectedPort.Parent;
          if (connectedNode == null) continue;

          var connectedRectangle = primitiveDict[connectedNode.Name] as NodeRectangle;
          if (connectedRectangle == null) continue;

          nodeSize = chartControl.Chart.TransformWorldToPixel(connectedRectangle.Size);
          if (!layoutNodes.ContainsKey(connectedNode.Name)) {
            layoutNodes.Add(connectedNode.Name, new Layout.LayoutNode(nodeSize));
            layout.AddNode(layoutNodes[connectedNode.Name]);
          }

          layoutNode.AddNode(layoutNodes[connectedNode.Name]);
        }
      }

      var bounds = chartControl.GetPictureBounds();
      bounds.Offset((int)chartControl.Chart.LowerLeft.X, -(int)chartControl.Chart.UpperRight.Y);

      layout.Arrange(bounds);

      foreach (var entry in layoutNodes) {
        var nodeRectangle = primitiveDict[entry.Key] as NodeRectangle;
        if (nodeRectangle == null) continue;
        var rectangleNode = entry.Value;
        nodeRectangle.Move(rectangleNode.Location - nodeRectangle.Center());
      }
    }

    private void LayoutPorts() {
      foreach (var node in Content.Nodes) {
        var nodeRectangle = primitiveDict[node.Name] as NodeRectangle;
        if (nodeRectangle == null) continue;

        foreach (var port in node.Ports.OfType<IConnectablePort>()) {
          var connectedPort = port.ConnectedPort as IConnectablePort;
          if (connectedPort == null) continue;

          var connectedNode = connectedPort.Parent;
          if (connectedNode == null) continue;

          var connectedRectangle = primitiveDict[connectedNode.Name] as NodeRectangle;
          if (connectedRectangle == null) continue;

          var leftCenter = nodeRectangle.Center();
          var rightCenter = connectedRectangle.Center();
          var line = new Line(null, rightCenter, leftCenter);

          var leftIntersection = nodeRectangle.ComputeIntersect(line).Single();
          var rightIntersection = connectedRectangle.ComputeIntersect(line).Single();

          var leftPortRectangle = (PortRectangle)nodeRectangle.GetPortPrimitive(port);
          leftPortRectangle.SetPosition(leftIntersection);
          var rightPortRectangle = (PortRectangle)connectedRectangle.GetPortPrimitive(connectedPort);
          rightPortRectangle.SetPosition(rightIntersection);
        }
      }
    }
    #endregion
  }
}