source: branches/SimulationCore/HeuristicLab.SimulationCore.Dsl/Dsl/GeneratedCode/ConnectionBuilders.cs @ 10525

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using DslModeling = global::Microsoft.VisualStudio.Modeling;
using DslDiagrams = global::Microsoft.VisualStudio.Modeling.Diagrams;

namespace HeuristicLab.SimulationCore
{
  /// <summary>
  /// ConnectionBuilder class to provide logic for constructing connections between elements.
  /// </summary>
  public static partial class ActivityReferencesTriggersBuilder
  {
    #region Accept Connection Methods
    /// <summary>
    /// Test whether a given model element is acceptable to this ConnectionBuilder as the source of a connection.
    /// </summary>
    /// <param name="candidate">The model element to test.</param>
    /// <returns>Whether the element can be used as the source of a connection.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    public static bool CanAcceptSource(DslModeling::ModelElement candidate)
    {
      if (candidate == null) return false;
      else if (candidate is global::HeuristicLab.SimulationCore.Activity)
      { 
        return true;
      }
      else
        return false;
    }

    /// <summary>
    /// Test whether a given model element is acceptable to this ConnectionBuilder as the target of a connection.
    /// </summary>
    /// <param name="candidate">The model element to test.</param>
    /// <returns>Whether the element can be used as the target of a connection.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    public static bool CanAcceptTarget(DslModeling::ModelElement candidate)
    {
      if (candidate == null) return false;
      else if (candidate is global::HeuristicLab.SimulationCore.Action)
      { 
        return true;
      }
      else
        return false;
    }
    
    /// <summary>
    /// Test whether a given pair of model elements are acceptable to this ConnectionBuilder as the source and target of a connection
    /// </summary>
    /// <param name="candidateSource">The model element to test as a source</param>
    /// <param name="candidateTarget">The model element to test as a target</param>
    /// <returns>Whether the elements can be used as the source and target of a connection</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Generated code.")]
    public static bool CanAcceptSourceAndTarget(DslModeling::ModelElement candidateSource, DslModeling::ModelElement candidateTarget)
    {
      // Accepts null, null; source, null; source, target but NOT null, target
      if (candidateSource == null)
      {
        if (candidateTarget != null)
        {
          throw new global::System.ArgumentNullException("candidateSource");
        }
        else // Both null
        {
          return false;
        }
      }
      bool acceptSource = CanAcceptSource(candidateSource);
      // If the source wasn't accepted then there's no point checking targets.
      // If there is no target then the source controls the accept.
      if (!acceptSource || candidateTarget == null)
      {
        return acceptSource;
      }
      else // Check combinations
      {
        if (candidateSource is global::HeuristicLab.SimulationCore.Activity)
        {
          if (candidateTarget is global::HeuristicLab.SimulationCore.Action)
          {
            global::HeuristicLab.SimulationCore.Activity sourceActivity = (global::HeuristicLab.SimulationCore.Activity)candidateSource;
            global::HeuristicLab.SimulationCore.Action targetAction = (global::HeuristicLab.SimulationCore.Action)candidateTarget;
            if(targetAction == null || sourceActivity == null || global::HeuristicLab.SimulationCore.ActivityReferencesTriggers.GetLinks(sourceActivity, targetAction).Count > 0) return false;
            return true;
          }
        }
        
      }
      return false;
    }
    #endregion

    #region Connection Methods
    /// <summary>
    /// Make a connection between the given pair of source and target elements
    /// </summary>
    /// <param name="source">The model element to use as the source of the connection</param>
    /// <param name="target">The model element to use as the target of the connection</param>
    /// <returns>A link representing the created connection</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Generated code.")]
    public static DslModeling::ElementLink Connect(DslModeling::ModelElement source, DslModeling::ModelElement target)
    {
      if (source == null)
      {
        throw new global::System.ArgumentNullException("source");
      }
      if (target == null)
      {
        throw new global::System.ArgumentNullException("target");
      }
      
      if (CanAcceptSourceAndTarget(source, target))
      {
        if (source is global::HeuristicLab.SimulationCore.Activity)
        {
          if (target is global::HeuristicLab.SimulationCore.Action)
          {
            global::HeuristicLab.SimulationCore.Activity sourceAccepted = (global::HeuristicLab.SimulationCore.Activity)source;
            global::HeuristicLab.SimulationCore.Action targetAccepted = (global::HeuristicLab.SimulationCore.Action)target;
            DslModeling::ElementLink result = new global::HeuristicLab.SimulationCore.ActivityReferencesTriggers(sourceAccepted, targetAccepted);
            if (DslModeling::DomainClassInfo.HasNameProperty(result))
            {
              DslModeling::DomainClassInfo.SetUniqueName(result);
            }
            return result;
          }
        }
        
      }
      global::System.Diagnostics.Debug.Fail("Having agreed that the connection can be accepted we should never fail to make one.");
      throw new global::System.InvalidOperationException();
    }
    #endregion
  }
  /// <summary>
  /// ConnectionBuilder class to provide logic for constructing connections between elements.
  /// </summary>
  public static partial class ActionReferencesListenersBuilder
  {
    #region Accept Connection Methods
    /// <summary>
    /// Test whether a given model element is acceptable to this ConnectionBuilder as the source of a connection.
    /// </summary>
    /// <param name="candidate">The model element to test.</param>
    /// <returns>Whether the element can be used as the source of a connection.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    public static bool CanAcceptSource(DslModeling::ModelElement candidate)
    {
      if (candidate == null) return false;
      else if (candidate is global::HeuristicLab.SimulationCore.Action)
      { 
        return true;
      }
      else
        return false;
    }

    /// <summary>
    /// Test whether a given model element is acceptable to this ConnectionBuilder as the target of a connection.
    /// </summary>
    /// <param name="candidate">The model element to test.</param>
    /// <returns>Whether the element can be used as the target of a connection.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    public static bool CanAcceptTarget(DslModeling::ModelElement candidate)
    {
      if (candidate == null) return false;
      else if (candidate is global::HeuristicLab.SimulationCore.Activity)
      { 
        return true;
      }
      else
        return false;
    }
    
    /// <summary>
    /// Test whether a given pair of model elements are acceptable to this ConnectionBuilder as the source and target of a connection
    /// </summary>
    /// <param name="candidateSource">The model element to test as a source</param>
    /// <param name="candidateTarget">The model element to test as a target</param>
    /// <returns>Whether the elements can be used as the source and target of a connection</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Generated code.")]
    public static bool CanAcceptSourceAndTarget(DslModeling::ModelElement candidateSource, DslModeling::ModelElement candidateTarget)
    {
      // Accepts null, null; source, null; source, target but NOT null, target
      if (candidateSource == null)
      {
        if (candidateTarget != null)
        {
          throw new global::System.ArgumentNullException("candidateSource");
        }
        else // Both null
        {
          return false;
        }
      }
      bool acceptSource = CanAcceptSource(candidateSource);
      // If the source wasn't accepted then there's no point checking targets.
      // If there is no target then the source controls the accept.
      if (!acceptSource || candidateTarget == null)
      {
        return acceptSource;
      }
      else // Check combinations
      {
        if (candidateSource is global::HeuristicLab.SimulationCore.Action)
        {
          if (candidateTarget is global::HeuristicLab.SimulationCore.Activity)
          {
            global::HeuristicLab.SimulationCore.Action sourceAction = (global::HeuristicLab.SimulationCore.Action)candidateSource;
            global::HeuristicLab.SimulationCore.Activity targetActivity = (global::HeuristicLab.SimulationCore.Activity)candidateTarget;
            if(targetActivity == null || sourceAction == null || global::HeuristicLab.SimulationCore.ActionReferencesListeners.GetLinks(sourceAction, targetActivity).Count > 0) return false;
            return true;
          }
        }
        
      }
      return false;
    }
    #endregion

    #region Connection Methods
    /// <summary>
    /// Make a connection between the given pair of source and target elements
    /// </summary>
    /// <param name="source">The model element to use as the source of the connection</param>
    /// <param name="target">The model element to use as the target of the connection</param>
    /// <returns>A link representing the created connection</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Generated code.")]
    public static DslModeling::ElementLink Connect(DslModeling::ModelElement source, DslModeling::ModelElement target)
    {
      if (source == null)
      {
        throw new global::System.ArgumentNullException("source");
      }
      if (target == null)
      {
        throw new global::System.ArgumentNullException("target");
      }
      
      if (CanAcceptSourceAndTarget(source, target))
      {
        if (source is global::HeuristicLab.SimulationCore.Action)
        {
          if (target is global::HeuristicLab.SimulationCore.Activity)
          {
            global::HeuristicLab.SimulationCore.Action sourceAccepted = (global::HeuristicLab.SimulationCore.Action)source;
            global::HeuristicLab.SimulationCore.Activity targetAccepted = (global::HeuristicLab.SimulationCore.Activity)target;
            DslModeling::ElementLink result = new global::HeuristicLab.SimulationCore.ActionReferencesListeners(sourceAccepted, targetAccepted);
            if (DslModeling::DomainClassInfo.HasNameProperty(result))
            {
              DslModeling::DomainClassInfo.SetUniqueName(result);
            }
            return result;
          }
        }
        
      }
      global::System.Diagnostics.Debug.Fail("Having agreed that the connection can be accepted we should never fail to make one.");
      throw new global::System.InvalidOperationException();
    }
    #endregion
  }
  
  /// <summary>
  /// Handles interaction between the ConnectionBuilder and the corresponding ConnectionTool.
  /// </summary>
  internal partial class TriggerConnectAction : DslDiagrams::ConnectAction
  {
    private DslDiagrams::ConnectionType[] connectionTypes;
    
    /// <summary>
    /// Constructs a new TriggerConnectAction for the given Diagram.
    /// </summary>
    public TriggerConnectAction(DslDiagrams::Diagram diagram): base(diagram, true) 
    {
    }
    
    /// <summary>
    /// Gets the cursor corresponding to the given mouse position.
    /// </summary>
    /// <remarks>
    /// Changes the cursor to Cursors.No before the first mouse click if the source shape is not valid.
    /// </remarks>
    public override global::System.Windows.Forms.Cursor GetCursor(global::System.Windows.Forms.Cursor currentCursor, DslDiagrams::DiagramClientView diagramClientView, DslDiagrams::PointD mousePosition)
    {
      if (this.MouseDownHitShape == null && currentCursor != global::System.Windows.Forms.Cursors.No)
      {
        DslDiagrams::DiagramHitTestInfo hitTestInfo = new DslDiagrams::DiagramHitTestInfo(diagramClientView);
        this.Diagram.DoHitTest(mousePosition, hitTestInfo);
        DslDiagrams::ShapeElement shape = hitTestInfo.HitDiagramItem.Shape;

        DslDiagrams::ConnectionType connectionType = GetConnectionTypes(shape, null)[0];
        string warningString = string.Empty;
        if (!connectionType.CanCreateConnection(shape, null, ref warningString))
        {
          return global::System.Windows.Forms.Cursors.No;
        }
      }
      return base.GetCursor(currentCursor, diagramClientView, mousePosition);
    }
    
    
    /// <summary>
    /// Returns the TriggerConnectionType associated with this action.
    /// </summary>
    protected override DslDiagrams::ConnectionType[] GetConnectionTypes(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement)
    {
      if(this.connectionTypes == null)
      {
        this.connectionTypes = new DslDiagrams::ConnectionType[] { new TriggerConnectionType() };
      }
      
      return this.connectionTypes;
    }
    
    private partial class TriggerConnectionTypeBase : DslDiagrams::ConnectionType
    {
      /// <summary>
      /// Constructs a new the TriggerConnectionType with the given ConnectionBuilder.
      /// </summary>
      protected TriggerConnectionTypeBase() : base() {}
      
      private static DslDiagrams::ShapeElement RemovePassThroughShapes(DslDiagrams::ShapeElement shape)
      {
        if (shape is DslDiagrams::Compartment)
        {
          return shape.ParentShape;
        }
        DslDiagrams::SwimlaneShape swimlane = shape as DslDiagrams::SwimlaneShape;
        if (swimlane != null && swimlane.ForwardDragDropToParent)
        {
          return shape.ParentShape;
        }
        return shape;
      }
            
      /// <summary>
      /// Called by the base ConnectAction class to determine if the given shapes can be connected.
      /// </summary>
      /// <remarks>
      /// This implementation delegates calls to the ConnectionBuilder ActivityReferencesTriggersBuilder.
      /// </remarks>
      public override bool CanCreateConnection(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement, ref string connectionWarning)
      {
        bool canConnect = true;
        
        if(sourceShapeElement == null) throw new global::System.ArgumentNullException("sourceShapeElement");
        sourceShapeElement = RemovePassThroughShapes(sourceShapeElement);
        DslModeling::ModelElement sourceElement = sourceShapeElement.ModelElement;
        if(sourceElement == null) sourceElement = sourceShapeElement;
        
        DslModeling::ModelElement targetElement = null;
        if (targetShapeElement != null)
        {
          targetShapeElement = RemovePassThroughShapes(targetShapeElement);
          targetElement = targetShapeElement.ModelElement;
          if(targetElement == null) targetElement = targetShapeElement;
      
        }

        // base.CanCreateConnection must be called to check whether existing Locks prevent this link from getting created.  
        canConnect = base.CanCreateConnection(sourceShapeElement, targetShapeElement, ref connectionWarning);
        if (canConnect)
        {       
          if(targetShapeElement == null)
          {
            return ActivityReferencesTriggersBuilder.CanAcceptSource(sourceElement);
          }
          else
          {       
            return ActivityReferencesTriggersBuilder.CanAcceptSourceAndTarget(sourceElement, targetElement);
          }
        }
        else
        {
          //return false
          return canConnect;
        }
      }
            
      /// <summary>
      /// Called by the base ConnectAction class to ask whether the given source and target are valid.
      /// </summary>
      /// <remarks>
      /// Always return true here, to give CanCreateConnection a chance to decide.
      /// </remarks>
      public override bool IsValidSourceAndTarget(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement)
      {
        return true;
      }
      
      /// <summary>
      /// Called by the base ConnectAction class to create the underlying relationship.
      /// </summary>
      /// <remarks>
      /// This implementation delegates calls to the ConnectionBuilder ActivityReferencesTriggersBuilder.
      /// </remarks>
      public override void CreateConnection(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement, DslDiagrams::PaintFeedbackArgs paintFeedbackArgs)
      {
        if(sourceShapeElement == null) throw new global::System.ArgumentNullException("sourceShapeElement");
        if(targetShapeElement == null) throw new global::System.ArgumentNullException("targetShapeElement");
        
        sourceShapeElement = RemovePassThroughShapes(sourceShapeElement);
        targetShapeElement = RemovePassThroughShapes(targetShapeElement);
        
        DslModeling::ModelElement sourceElement = sourceShapeElement.ModelElement;
        if(sourceElement == null) sourceElement = sourceShapeElement;
        DslModeling::ModelElement targetElement = targetShapeElement.ModelElement;
        if(targetElement == null) targetElement = targetShapeElement;
        ActivityReferencesTriggersBuilder.Connect(sourceElement, targetElement);
      }
    }
    
    private partial class TriggerConnectionType : TriggerConnectionTypeBase
    {
      /// <summary>
      /// Constructs a new the TriggerConnectionType with the given ConnectionBuilder.
      /// </summary>
      public TriggerConnectionType() : base() {}
    }
  }
  
  /// <summary>
  /// Handles interaction between the ConnectionBuilder and the corresponding ConnectionTool.
  /// </summary>
  internal partial class ListenerConnectAction : DslDiagrams::ConnectAction
  {
    private DslDiagrams::ConnectionType[] connectionTypes;
    
    /// <summary>
    /// Constructs a new ListenerConnectAction for the given Diagram.
    /// </summary>
    public ListenerConnectAction(DslDiagrams::Diagram diagram): base(diagram, true) 
    {
    }
    
    /// <summary>
    /// Gets the cursor corresponding to the given mouse position.
    /// </summary>
    /// <remarks>
    /// Changes the cursor to Cursors.No before the first mouse click if the source shape is not valid.
    /// </remarks>
    public override global::System.Windows.Forms.Cursor GetCursor(global::System.Windows.Forms.Cursor currentCursor, DslDiagrams::DiagramClientView diagramClientView, DslDiagrams::PointD mousePosition)
    {
      if (this.MouseDownHitShape == null && currentCursor != global::System.Windows.Forms.Cursors.No)
      {
        DslDiagrams::DiagramHitTestInfo hitTestInfo = new DslDiagrams::DiagramHitTestInfo(diagramClientView);
        this.Diagram.DoHitTest(mousePosition, hitTestInfo);
        DslDiagrams::ShapeElement shape = hitTestInfo.HitDiagramItem.Shape;

        DslDiagrams::ConnectionType connectionType = GetConnectionTypes(shape, null)[0];
        string warningString = string.Empty;
        if (!connectionType.CanCreateConnection(shape, null, ref warningString))
        {
          return global::System.Windows.Forms.Cursors.No;
        }
      }
      return base.GetCursor(currentCursor, diagramClientView, mousePosition);
    }
    
    
    /// <summary>
    /// Returns the ListenerConnectionType associated with this action.
    /// </summary>
    protected override DslDiagrams::ConnectionType[] GetConnectionTypes(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement)
    {
      if(this.connectionTypes == null)
      {
        this.connectionTypes = new DslDiagrams::ConnectionType[] { new ListenerConnectionType() };
      }
      
      return this.connectionTypes;
    }
    
    private partial class ListenerConnectionTypeBase : DslDiagrams::ConnectionType
    {
      /// <summary>
      /// Constructs a new the ListenerConnectionType with the given ConnectionBuilder.
      /// </summary>
      protected ListenerConnectionTypeBase() : base() {}
      
      private static DslDiagrams::ShapeElement RemovePassThroughShapes(DslDiagrams::ShapeElement shape)
      {
        if (shape is DslDiagrams::Compartment)
        {
          return shape.ParentShape;
        }
        DslDiagrams::SwimlaneShape swimlane = shape as DslDiagrams::SwimlaneShape;
        if (swimlane != null && swimlane.ForwardDragDropToParent)
        {
          return shape.ParentShape;
        }
        return shape;
      }
            
      /// <summary>
      /// Called by the base ConnectAction class to determine if the given shapes can be connected.
      /// </summary>
      /// <remarks>
      /// This implementation delegates calls to the ConnectionBuilder ActionReferencesListenersBuilder.
      /// </remarks>
      public override bool CanCreateConnection(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement, ref string connectionWarning)
      {
        bool canConnect = true;
        
        if(sourceShapeElement == null) throw new global::System.ArgumentNullException("sourceShapeElement");
        sourceShapeElement = RemovePassThroughShapes(sourceShapeElement);
        DslModeling::ModelElement sourceElement = sourceShapeElement.ModelElement;
        if(sourceElement == null) sourceElement = sourceShapeElement;
        
        DslModeling::ModelElement targetElement = null;
        if (targetShapeElement != null)
        {
          targetShapeElement = RemovePassThroughShapes(targetShapeElement);
          targetElement = targetShapeElement.ModelElement;
          if(targetElement == null) targetElement = targetShapeElement;
      
        }

        // base.CanCreateConnection must be called to check whether existing Locks prevent this link from getting created.  
        canConnect = base.CanCreateConnection(sourceShapeElement, targetShapeElement, ref connectionWarning);
        if (canConnect)
        {       
          if(targetShapeElement == null)
          {
            return ActionReferencesListenersBuilder.CanAcceptSource(sourceElement);
          }
          else
          {       
            return ActionReferencesListenersBuilder.CanAcceptSourceAndTarget(sourceElement, targetElement);
          }
        }
        else
        {
          //return false
          return canConnect;
        }
      }
            
      /// <summary>
      /// Called by the base ConnectAction class to ask whether the given source and target are valid.
      /// </summary>
      /// <remarks>
      /// Always return true here, to give CanCreateConnection a chance to decide.
      /// </remarks>
      public override bool IsValidSourceAndTarget(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement)
      {
        return true;
      }
      
      /// <summary>
      /// Called by the base ConnectAction class to create the underlying relationship.
      /// </summary>
      /// <remarks>
      /// This implementation delegates calls to the ConnectionBuilder ActionReferencesListenersBuilder.
      /// </remarks>
      public override void CreateConnection(DslDiagrams::ShapeElement sourceShapeElement, DslDiagrams::ShapeElement targetShapeElement, DslDiagrams::PaintFeedbackArgs paintFeedbackArgs)
      {
        if(sourceShapeElement == null) throw new global::System.ArgumentNullException("sourceShapeElement");
        if(targetShapeElement == null) throw new global::System.ArgumentNullException("targetShapeElement");
        
        sourceShapeElement = RemovePassThroughShapes(sourceShapeElement);
        targetShapeElement = RemovePassThroughShapes(targetShapeElement);
        
        DslModeling::ModelElement sourceElement = sourceShapeElement.ModelElement;
        if(sourceElement == null) sourceElement = sourceShapeElement;
        DslModeling::ModelElement targetElement = targetShapeElement.ModelElement;
        if(targetElement == null) targetElement = targetShapeElement;
        ActionReferencesListenersBuilder.Connect(sourceElement, targetElement);
      }
    }
    
    private partial class ListenerConnectionType : ListenerConnectionTypeBase
    {
      /// <summary>
      /// Constructs a new the ListenerConnectionType with the given ConnectionBuilder.
      /// </summary>
      public ListenerConnectionType() : base() {}
    }
  }
}