protected virtual void OnConnectorAdded(ConnectorModel obj)
 {
     RegisterConnector(obj);
     var handler = ConnectorAdded;
     if (handler != null) handler(obj);
 }

 protected override void PortConnectedHandler(PortModel arg1, ConnectorModel arg2)
 {
     UpdateUpstream();
 }

 /// <summary>
 /// Checks whether the given connection is inside the node to code set or outside it. 
 /// This determines if it should be redrawn(if it is external) or if it should be 
 /// deleted (if it is internal)
 /// </summary>
 private static bool IsInternalNodeToCodeConnection(IEnumerable<NodeModel> nodes, ConnectorModel connector)
 {
     return nodes.Contains(connector.Start.Owner) && nodes.Contains(connector.End.Owner);
 }

 /// <summary>
 /// Called when a port is connected.
 /// </summary>
 /// <param name="connector"></param>
 protected virtual void OnPortConnected(ConnectorModel connector)
 {
     if (PortConnected != null)
         PortConnected(this, connector);
 }

        /// <summary>
        /// Handler for the model's ConnectorDeleted event.
        /// </summary>
        /// <param name="connector"></param>
        private void DynamoModel_ConnectorDeleted(ConnectorModel connector)
        {
            // TODO: Ian should remove this when the CBN reconnection bug is solved.
            /*if (connector.Start.Owner.GetType() == typeof(CodeBlockNodeModel))
            {
                return;
            }

            //we are given the connector that was deleted
            //if it's end node still exists, clear the package for 
            //the node and trigger an update.
            if (connector.End != null)
                connector.End.Owner.ClearRenderPackages();

            //tell the watches that they require re-binding.
            QueueRenderTask();*/
        }

 internal void OnConnectorDeleted(ConnectorModel connector)
 {
     if (ConnectorDeleted != null)
     {
         ConnectorDeleted(connector);
     }
 }

        public void Disconnect(ConnectorModel connector)
        {
            if (!connectors.Contains(connector))
                return;

            //throw the event for a connection
            OnPortDisconnected(EventArgs.Empty);

            //also trigger the model's connector deletion
            owner.Workspace.DynamoModel.OnConnectorDeleted(connector);

            connectors.Remove(connector);

            //don't set back to white if
            //there are still connectors on this port
            if (connectors.Count == 0)
            {
                IsConnected = false;
            }

            Owner.ValidateConnections();
        }

 /// <summary>
 /// Checks whether the given connection is inside the node to code set or outside it. 
 /// This determines if it should be redrawn(if it is external) or if it should be 
 /// deleted (if it is internal)
 /// </summary>
 private bool IsInternalNodeToCodeConnection(ConnectorModel connector)
 {
     return DynamoSelection.Instance.Selection.Contains(connector.Start.Owner) && DynamoSelection.Instance.Selection.Contains(connector.End.Owner);
 }

 void Connectors_ConnectorAdded(ConnectorModel c)
 {
     var viewModel = new ConnectorViewModel(this, c);
     if (_connectors.All(x => x.ConnectorModel != c))
         _connectors.Add(viewModel);
 }

        /// <summary>
        /// Construct a view and respond to property changes on the model. 
        /// </summary>
        /// <param name="model"></param>
        public ConnectorViewModel(ConnectorModel model)
        {
            _model = model;

            _model.PropertyChanged += Model_PropertyChanged;
            _model.Start.Owner.PropertyChanged += StartOwner_PropertyChanged;
            _model.End.Owner.PropertyChanged += EndOwner_PropertyChanged;

            dynSettings.Controller.DynamoViewModel.PropertyChanged += DynamoViewModel_PropertyChanged;

            Redraw();
        }

        /// <summary>
        /// Construct a view and respond to property changes on the model. 
        /// </summary>
        /// <param name="model"></param>
        public ConnectorViewModel(WorkspaceViewModel workspace, ConnectorModel model)
        {
            this.workspaceViewModel = workspace;
            _model = model;

            _model.PropertyChanged += Model_PropertyChanged;
            _model.Start.Owner.PropertyChanged += StartOwner_PropertyChanged;
            _model.End.Owner.PropertyChanged += EndOwner_PropertyChanged;

            workspaceViewModel.DynamoViewModel.PropertyChanged += DynamoViewModel_PropertyChanged;

            Redraw();
        }

        /// <summary>
        /// Handler for the model's ConnectorDeleted event. Clears the visualization for
        /// the node at the 'end' of the connector.
        /// </summary>
        /// <param name="connector"></param>
        void DynamoModel_ConnectorDeleted(ConnectorModel connector)
        {
            if (Visualizations.ContainsKey(connector.End.Owner.GUID.ToString()))
            {
                Visualizations.Remove(connector.End.Owner.GUID.ToString());

                //tell the watches that they require re-binding.
                //OnVisualizationUpdateComplete(this, new VisualizationEventArgs(AggregateRenderDescriptions()));
                OnVisualizationUpdateComplete(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Handler for the model's ConnectorDeleted event.
        /// </summary>
        /// <param name="connector"></param>
        void DynamoModel_ConnectorDeleted(ConnectorModel connector)
        {
            //we are given the connector that was deleted
            //if it's end node still exists, clear the package for
            //the node and trigger an update.
            if (connector.End != null)
                connector.End.Owner.ClearRenderPackages();

            //tell the watches that they require re-binding.
            OnVisualizationUpdateComplete(this, EventArgs.Empty);
        }

 /// <summary>
 /// Called when a connector is added.
 /// </summary>
 /// <param name="connector"></param>
 private void OnConnectorAdded(ConnectorModel connector)
 {
     if (ConnectorAdded != null)
     {
         ConnectorAdded(connector);
     }
 }

 private void RegisterConnector(ConnectorModel connector)
 {
     connector.Deleted += () => OnConnectorDeleted(connector);
 }

 void Connectors_ConnectorDeleted(ConnectorModel c)
 {
     var connector = _connectors.FirstOrDefault(x => x.ConnectorModel == c);
     if (connector != null)
         _connectors.Remove(connector);
 }

 protected virtual void OnConnectorDeleted(ConnectorModel obj)
 {
     var handler = ConnectorDeleted;
     if (handler != null) handler(obj);
 }

        private void PortConnected(PortModel port, ConnectorModel connector)
        {
            ValidateConnections();

            if (port.PortType != PortType.Input) return;

            var data = InPorts.IndexOf(port);
            var startPort = connector.Start;
            var outData = startPort.Owner.OutPorts.IndexOf(startPort);
            ConnectInput(data, outData, startPort.Owner);
            startPort.Owner.ConnectOutput(outData, data, this);
            OnConnectorAdded(connector);

            OnNodeModified();
        }

        public void Connect(ConnectorModel connector)
        {
            connectors.Add(connector);

            //throw the event for a connection
            OnPortConnected(EventArgs.Empty);

            IsConnected = true;
        }

        protected virtual void OnConnectorDeleted(ConnectorModel obj)
        {
            if (hasNodeInSyncWithDefinition)
            {
                undoRecorder.RecordModelAsOffTrack(obj.GUID);
            }

            var handler = ConnectorDeleted;
            if (handler != null) handler(obj);
        }