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

#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.Collections.Generic;
using System.Linq;
using HeuristicLab.Collections;
using HeuristicLab.Core;
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 initialMode = new SelectChartMode(chartControl);
      chartControl.AddChartModes(
        initialMode,
        new PanChartMode(chartControl),
        new RulerChartMode(chartControl),
        new ZoomInChartMode(chartControl),
        new ZoomOutChartMode(chartControl),
        new AddNodesChartMode(chartControl),
        new AddPortsChartMode(chartControl),
        new ConnectPortsChartMode(chartControl)
      );
      chartControl.Mode = initialMode;
    }

    protected override void OnContentChanged() {
      base.OnContentChanged();
      UpdateContent();
      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
    #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
    #endregion

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

      chartControl.SuspendRendering();
      try {
        chartControl.Chart.Group.Clear();
        DrawNodes(Content.Nodes);
        ConnectNodes(Content.Nodes);
      } finally {
        chartControl.ResumeRendering();
      }
    }

    private void DrawNodes(IKeyedItemCollection<string, INode> nodes) {
      foreach (var node in 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(IKeyedItemCollection<string, INode> nodes) {
      var chart = chartControl.Chart;
      foreach (var node in 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(chart, leftPortRectangle, rightPortRectangle);

          chart.Group.Add(connectionShape);
        }
      }
    }
    #endregion
  }
}