CodeWalker/CodeWalker.WinForms/STNodeEditor/STNodeOption.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Drawing;

namespace ST.Library.UI.NodeEditor
{
    public class STNodeOption
    {
        #region Properties

        public static readonly STNodeOption Empty = new STNodeOption();

        private STNode _Owner;
        /// <summary>
        /// Get the Node to which the current Option belongs
        /// </summary>
        public STNode Owner {
            get { return _Owner; }
            internal set {
                if (value == _Owner) return;
                if (_Owner != null) this.DisConnectionAll(); //Disconnect all current connections when the owner changes
                _Owner = value;
            }
        }

        private bool _IsSingle;
        /// <summary>
        /// Get whether the current Option can only be connected once
        /// </summary>
        public bool IsSingle {
            get { return _IsSingle; }
        }

        private bool _IsInput;
        /// <summary>
        /// Get whether the current Option is an input option
        /// </summary>
        public bool IsInput {
            get { return _IsInput; }
            internal set { _IsInput = value; }
        }

        private Color _TextColor = Color.White;
        /// <summary>
        /// Gets or sets the current Option text color
        /// </summary>
        public Color TextColor {
            get { return _TextColor; }
            internal set {
                if (value == _TextColor) return;
                _TextColor = value;
                this.Invalidate();
            }
        }

        private Color _DotColor = Color.Transparent;
        /// <summary>
        /// Gets or sets the color of the current Option connection point
        /// </summary>
        public Color DotColor {
            get { return _DotColor; }
            internal set {
                if (value == _DotColor) return;
                _DotColor = value;
                this.Invalidate();
            }
        }

        private string _Text;
        /// <summary>
        /// Gets or sets the current Option display text
        /// This property cannot be modified when AutoSize is set
        /// </summary>
        public string Text {
            get { return _Text; }
            internal set {
                if (value == _Text) return;
                _Text = value;
                if (this._Owner == null) return;
                this._Owner.BuildSize(true, true, true);
            }
        }

        private int _DotLeft;
        /// <summary>
        /// Get the left coordinate of the current Option connection point
        /// </summary>
        public int DotLeft {
            get { return _DotLeft; }
            internal set { _DotLeft = value; }
        }
        private int _DotTop;
        /// <summary>
        /// Get the upper coordinate of the current Option connection point
        /// </summary>
        public int DotTop {
            get { return _DotTop; }
            internal set { _DotTop = value; }
        }

        private int _DotSize;
        /// <summary>
        /// Get the width of the current Option connection point
        /// </summary>
        public int DotSize {
            get { return _DotSize; }
            protected set { _DotSize = value; }
        }

        private Rectangle _TextRectangle;
        /// <summary>
        /// Get the current Option text area
        /// </summary>
        public Rectangle TextRectangle {
            get { return _TextRectangle; }
            internal set { _TextRectangle = value; }
        }

        private object _Data;
        /// <summary>
        /// Get or set the data contained in the current Option
        /// </summary>
        public object Data {
            get { return _Data; }
            set {
                if (value != null) {
                    if (this._DataType == null) return;
                    var t = value.GetType();
                    if (t != this._DataType && !t.IsSubclassOf(this._DataType)) {
                        throw new ArgumentException("Invalid data type The data type must be the specified data type or its subclass");
                    }
                }
                _Data = value;
            }
        }

        private Type _DataType;
        /// <summary>
        /// Get the current Option data type
        /// </summary>
        public Type DataType {
            get { return _DataType; }
            internal set { _DataType = value; }
        }

        //private Rectangle _DotRectangle;
        /// <summary>
        /// Get the area of ​​the current Option connection point
        /// </summary>
        public Rectangle DotRectangle {
            get {
                return new Rectangle(this._DotLeft, this._DotTop, this._DotSize, this._DotSize);
            }
        }
        /// <summary>
        /// Get the current number of Option connected
        /// </summary>
        public int ConnectionCount {
            get { return m_hs_connected.Count; }
        }
        /// <summary>
        /// Get the Option collection that the current Option is connected to
        /// </summary>
        internal HashSet<STNodeOption> ConnectedOption {
            get { return m_hs_connected; }
        }

        #endregion Properties
        /// <summary>
        /// Save the points that have been connected
        /// </summary>
        protected HashSet<STNodeOption> m_hs_connected;

        #region Constructor

        private STNodeOption() { }

        /// <summary>
        /// Constructs an Option
        /// </summary>
        /// <param name="strText">Display text</param>
        /// <param name="dataType">Data Type</param>
        /// <param name="bSingle">Whether it is a single connection</param>
        public STNodeOption(string strText, Type dataType, bool bSingle) {
            if (dataType == null) throw new ArgumentNullException("The specified data type cannot be null");
            this._DotSize = 10;
            m_hs_connected = new HashSet<STNodeOption>();
            this._DataType = dataType;
            this._Text = strText;
            this._IsSingle = bSingle;
        }

        #endregion Builder

        #region Event

        /// <summary>
        /// Occurs when connected
        /// </summary>
        public event STNodeOptionEventHandler Connected;
        /// <summary>
        /// Occurs when a connection starts happening
        /// </summary>
        public event STNodeOptionEventHandler Connecting;
        /// <summary>
        /// Occurs when the connection is disconnected
        /// </summary>
        public event STNodeOptionEventHandler DisConnected;
        /// <summary>
        /// Occurs when the connection starts to drop
        /// </summary>
        public event STNodeOptionEventHandler DisConnecting;
        /// <summary>
        /// Occurs when data is passed
        /// </summary>
        public event STNodeOptionEventHandler DataTransfer;

        #endregion Event

        #region protected
        /// <summary>
        /// Redraw the entire control
        /// </summary>
        protected void Invalidate() {
            if (this._Owner == null) return;
            this._Owner.Invalidate();
        }
        /*
         * At first I thought that only input type options should have events because input is passive and output is active
         * But later found that events are used for output nodes in STNodeHub, for example
         * Just in case, it is not very problematic to comment the code here. The output option does not register the event, and the same effect
         */
        protected internal virtual void OnConnected(STNodeOptionEventArgs e) {
            if (this.Connected != null/* && this._IsInput*/) this.Connected(this, e);
        }
        protected internal virtual void OnConnecting(STNodeOptionEventArgs e) {
            if (this.Connecting != null) this.Connecting(this, e);
        }
        protected internal virtual void OnDisConnected(STNodeOptionEventArgs e) {
            if (this.DisConnected != null/* && this._IsInput*/) this.DisConnected(this, e);
        }
        protected internal virtual void OnDisConnecting(STNodeOptionEventArgs e) {
            if (this.DisConnecting != null) this.DisConnecting(this, e);
        }
        protected internal virtual void OnDataTransfer(STNodeOptionEventArgs e) {
            if (this.DataTransfer != null/* && this._IsInput*/) this.DataTransfer(this, e);
        }
        protected void STNodeEidtorConnected(STNodeEditorOptionEventArgs e) {
            if (this._Owner == null) return;
            if (this._Owner.Owner == null) return;
            this._Owner.Owner.OnOptionConnected(e);
        }
        protected void STNodeEidtorDisConnected(STNodeEditorOptionEventArgs e) {
            if (this._Owner == null) return;
            if (this._Owner.Owner == null) return;
            this._Owner.Owner.OnOptionDisConnected(e);
        }
        /// <summary>
        /// The current Option starts to connect to the target Option
        /// </summary>
        /// <param name="op">Option to connect</param>
        /// <returns>Are you allowed to continue the operation?</returns>
        protected virtual bool ConnectingOption(STNodeOption op) {
            if (this._Owner == null) return false;
            if (this._Owner.Owner == null) return false;
            STNodeEditorOptionEventArgs e = new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Connecting);
            this._Owner.Owner.OnOptionConnecting(e);
            this.OnConnecting(new STNodeOptionEventArgs(true, op, ConnectionStatus.Connecting));
            op.OnConnecting(new STNodeOptionEventArgs(false, this, ConnectionStatus.Connecting));
            return e.Continue;
        }
        /// <summary>
        /// The current Option starts to disconnect the target Option
        /// </summary>
        /// <param name="op">Option to be disconnected</param>
        /// <returns>Are you allowed to continue the operation?</returns>
        protected virtual bool DisConnectingOption(STNodeOption op) {
            if (this._Owner == null) return false;
            if (this._Owner.Owner == null) return false;
            STNodeEditorOptionEventArgs e = new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.DisConnecting);
            this._Owner.Owner.OnOptionDisConnecting(e);
            this.OnDisConnecting(new STNodeOptionEventArgs(true, op, ConnectionStatus.DisConnecting));
            op.OnDisConnecting(new STNodeOptionEventArgs(false, this, ConnectionStatus.DisConnecting));
            return e.Continue;
        }

        #endregion protected

        #region public
        /// <summary>
        /// The current Option is connected to the target Option
        /// </summary>
        /// <param name="op">Option to connect</param>
        /// <returns>Connection result</returns>
        public virtual ConnectionStatus ConnectOption(STNodeOption op) {
            if (!this.ConnectingOption(op)) {
                this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Reject));
                return ConnectionStatus.Reject;
            }

            var v = this.CanConnect(op);
            if (v != ConnectionStatus.Connected) {
                this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, v));
                return v;
            }
            v = op.CanConnect(this);
            if (v != ConnectionStatus.Connected) {
                this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, v));
                return v;
            }
            op.AddConnection(this, false);
            this.AddConnection(op, true);
            this.ControlBuildLinePath();

            this.STNodeEidtorConnected(new STNodeEditorOptionEventArgs(op, this, v));
            return v;
        }
        /// <summary>
        /// Check whether the current Option can connect to the target Option
        /// </summary>
        /// <param name="op">Option to connect</param>
        /// <returns>Test results</returns>
        public virtual ConnectionStatus CanConnect(STNodeOption op) {
            if (this == STNodeOption.Empty || op == STNodeOption.Empty) return ConnectionStatus.EmptyOption;
            if (this._IsInput == op.IsInput) return ConnectionStatus.SameInputOrOutput;
            if (op.Owner == null || this._Owner == null) return ConnectionStatus.NoOwner;
            if (op.Owner == this._Owner) return ConnectionStatus.SameOwner;
            if (this._Owner.LockOption || op._Owner.LockOption) return ConnectionStatus.Locked;
            if (this._IsSingle && m_hs_connected.Count == 1) return ConnectionStatus.SingleOption;
            if (op.IsInput && STNodeEditor.CanFindNodePath(op.Owner, this._Owner)) return ConnectionStatus.Loop;
            if (m_hs_connected.Contains(op)) return ConnectionStatus.Exists;
            if (this._IsInput && op._DataType != this._DataType && !op._DataType.IsSubclassOf(this._DataType)) return ConnectionStatus.ErrorType;
            return ConnectionStatus.Connected;
        }
        /// <summary>
        /// The current Option disconnects the target Option
        /// </summary>
        /// <param name="op">Option to be disconnected</param>
        /// <returns></returns>
        public virtual ConnectionStatus DisConnectOption(STNodeOption op) {
            if (!this.DisConnectingOption(op)) {
                this.STNodeEidtorDisConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Reject));
                return ConnectionStatus.Reject;
            }

            if (op.Owner == null) return ConnectionStatus.NoOwner;
            if (this._Owner == null) return ConnectionStatus.NoOwner;
            if (op.Owner.LockOption && this._Owner.LockOption) {
                this.STNodeEidtorDisConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.Locked));
                return ConnectionStatus.Locked;
            }
            op.RemoveConnection(this, false);
            this.RemoveConnection(op, true);
            this.ControlBuildLinePath();

            this.STNodeEidtorDisConnected(new STNodeEditorOptionEventArgs(op, this, ConnectionStatus.DisConnected));
            return ConnectionStatus.DisConnected;
        }
        /// <summary>
        /// Disconnect all connections of the current Option
        /// </summary>
        public void DisConnectionAll() {
            if (this._DataType == null) return;
            var arr = m_hs_connected.ToArray();
            foreach (var v in arr) {
                this.DisConnectOption(v);
            }
        }
        /// <summary>
        /// Get the Option collection that the current Option is connected to
        /// </summary>
        /// <returns>If it is null, it means that there is no owner, otherwise it returns the collection</returns>
        public List<STNodeOption> GetConnectedOption() {
            if (this._DataType == null) return null;
            if (!this._IsInput)
                return m_hs_connected.ToList();
            List<STNodeOption> lst = new List<STNodeOption>();
            if (this._Owner == null) return null;
            if (this._Owner.Owner == null) return null;
            foreach (var v in this._Owner.Owner.GetConnectionInfo()) {
                if (v.Output == this) lst.Add(v.Input);
            }
            return lst;
        }
        /// <summary>
        /// Post data to all Option connected to the current Option
        /// </summary>
        public void TransferData() {
            if (this._DataType == null) return;
            foreach (var v in m_hs_connected) {
                v.OnDataTransfer(new STNodeOptionEventArgs(true, this, ConnectionStatus.Connected));
            }
        }
        /// <summary>
        /// Post data to all Option connected to the current Option
        /// </summary>
        /// <param name="data">Data to be delivered</param>
        public void TransferData(object data) {
            if (this._DataType == null) return;
            this.Data = data; //not this._Data
            foreach (var v in m_hs_connected) {
                v.OnDataTransfer(new STNodeOptionEventArgs(true, this, ConnectionStatus.Connected));
            }
        }
        /// <summary>
        /// Post data to all Option connected to the current Option
        /// </summary>
        /// <param name="data">Data to be delivered</param>
        /// <param name="bDisposeOld">Whether to release old data</param>
        public void TransferData(object data, bool bDisposeOld) {
            if (bDisposeOld && this._Data != null) {
                if (this._Data is IDisposable) ((IDisposable)this._Data).Dispose();
                this._Data = null;
            }
            this.TransferData(data);
        }

        #endregion public

        #region internal

        private bool AddConnection(STNodeOption op, bool bSponsor) {
            if (this._DataType == null) return false;
            bool b = m_hs_connected.Add(op);
            this.OnConnected(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.Connected));
            if (this._IsInput) this.OnDataTransfer(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.Connected));
            return b;
        }

        private bool RemoveConnection(STNodeOption op, bool bSponsor) {
            if (this._DataType == null) return false;
            bool b = false;
            if (m_hs_connected.Contains(op)) {
                b = m_hs_connected.Remove(op);
                if (this._IsInput) this.OnDataTransfer(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.DisConnected));
                this.OnDisConnected(new STNodeOptionEventArgs(bSponsor, op, ConnectionStatus.Connected));
            }
            return b;
        }

        #endregion internal

        #region private

        private void ControlBuildLinePath() {
            if (this.Owner == null) return;
            if (this.Owner.Owner == null) return;
            this.Owner.Owner.BuildLinePath();
        }

        #endregion
    }
}