source: branches/OptimizationNetworks/HeuristicLab.Networks.Views.NetworkVisualization.Views/3.3/ChartModes/ConnectPortsChartMode.cs @ 13757

#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.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Common.Resources;
using HeuristicLab.Core.Networks;
using HeuristicLab.Networks.Programmable;
using HeuristicLab.Visualization;

namespace HeuristicLab.Networks.Views.NetworkVisualization.Views.ChartModes {
  public class ConnectPortsChartMode : ChartMode {
    protected PortRectangle startPortRectangle, endPortRectangle;

    public override Image Image { get { return VSImageLibrary.OrgChart; } }
    public override string Text { get { return "&Connect Ports"; } }
    public override string ToolTipText { get { return "Connect Ports"; } }

    public ConnectPortsChartMode(ChartControl control) : base(control) { }

    public override void HandleOnMouseMove(object sender, MouseEventArgs e) {
      try {
        if (!(chartControl.Tag is IUserDefinedNetwork)) return;

        chartControl.RefreshPicture();

        var worldLocation = chartControl.Chart.TransformPixelToWorld(e.Location);
        var nodeRectangles = chartControl.Chart.Group.Primitives.OfType<NodeRectangle>();
        var portRectangles = nodeRectangles.SelectMany(x => x.NetworkItem.Ports.Select(x.GetPortPrimitive));
        var currentPortRectangle = (PortRectangle)portRectangles.FirstOrDefault(x => x.ContainsPoint(worldLocation));

        // TODO: highlight allowed port connections only

        using (var graphics = chartControl.CreatePictureGraphics()) {
          Point startLocation = Point.Empty;
          if (startPortRectangle != null) {
            DrawCircleAroundPortRectangle(graphics, startPortRectangle, startPortRectangle.NetworkItem is IConnectablePort);
            startLocation = chartControl.Chart.TransformWorldToPixel(startPortRectangle.Point);
          }

          Point endLocation = e.Location;
          if (currentPortRectangle != null && (startPortRectangle != null || e.Button == MouseButtons.None)) {
            DrawCircleAroundPortRectangle(graphics, currentPortRectangle, currentPortRectangle.NetworkItem is IConnectablePort);
            endLocation = chartControl.Chart.TransformWorldToPixel(currentPortRectangle.Point);
          }

          bool connectionValid = startPortRectangle != null && startPortRectangle.NetworkItem is IConnectablePort;
          connectionValid &= currentPortRectangle == null || currentPortRectangle.NetworkItem is IConnectablePort;

          if (startPortRectangle != null)
            DrawLineBetweenLocations(graphics, startLocation, endLocation, connectionValid);
        }
      } finally {
        chartControl.UpdatePicture();
        base.HandleOnMouseMove(sender, e);
      }
    }

    public override void HandleOnMouseDown(object sender, MouseEventArgs e) {
      try {
        var network = chartControl.Tag as IUserDefinedNetwork;
        if (network == null) return;

        switch (e.Button) {
          case MouseButtons.Left:
            var worldLocation = chartControl.Chart.TransformPixelToWorld(e.Location);
            var nodeRectangles = chartControl.Chart.Group.Primitives.OfType<NodeRectangle>();
            var portRectangles = nodeRectangles.SelectMany(x => x.NetworkItem.Ports.Select(x.GetPortPrimitive));
            startPortRectangle = (PortRectangle)portRectangles.FirstOrDefault(x => x.ContainsPoint(worldLocation));
            break;
        }
      } finally {
        base.HandleOnMouseDown(sender, e);
      }
    }

    public override void HandleOnMouseUp(object sender, MouseEventArgs e) {
      try {
        var network = chartControl.Tag as IUserDefinedNetwork;
        if (network == null) return;

        switch (e.Button) {
          case MouseButtons.Left:
            var worldLocation = chartControl.Chart.TransformPixelToWorld(e.Location);
            var nodeRectangles = chartControl.Chart.Group.Primitives.OfType<NodeRectangle>();
            var portRectangles = nodeRectangles.SelectMany(x => x.NetworkItem.Ports.Select(x.GetPortPrimitive));
            endPortRectangle = (PortRectangle)portRectangles.FirstOrDefault(x => x.ContainsPoint(worldLocation));

            if (startPortRectangle == endPortRectangle || startPortRectangle == null || endPortRectangle == null) {
              startPortRectangle = null;
              endPortRectangle = null;
              return;
            }

            var startPort = (IConnectablePort)startPortRectangle.NetworkItem;
            var endPort = (IConnectablePort)endPortRectangle.NetworkItem;

            // TODO: check if port connection is allowed

            startPort.ConnectedPort = endPort;

            startPortRectangle = null;
            endPortRectangle = null;
            break;
        }
      } finally {
        base.HandleOnMouseUp(sender, e);
      }
    }

    #region Helpers
    protected virtual void DrawCircleAroundPortRectangle(Graphics graphics, PortRectangle portRectangle, bool valid) {
      var centerP = chartControl.Chart.TransformWorldToPixel(portRectangle.Point);
      int a = (int)Math.Round(portRectangle.Size.Width / 2.0 * Math.Sqrt(2));
      int b = (int)Math.Round(portRectangle.Size.Height / 2.0 * Math.Sqrt(2));

      using (var pen = new Pen(valid ? Color.Green : Color.Red) { Width = 2f }) {
        graphics.DrawEllipse(pen,
          centerP.X - a,
          centerP.Y - b,
          a * 2,
          b * 2);
      }
    }

    protected virtual void DrawLineBetweenLocations(Graphics graphics, Point startLocation, Point endLocation, bool valid) {
      using (var pen = new Pen(valid ? Color.Green : Color.Red) { DashStyle = DashStyle.Dash, Width = 2f })
        graphics.DrawLine(pen, startLocation.X, startLocation.Y, endLocation.X, endLocation.Y);
    }
    #endregion
  }
}