/// <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>
/// 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);
}
void input_Connected(object sender, STNodeOptionEventArgs e)
{
STNodeOption op = sender as STNodeOption;
int nIndex = this.InputOptions.IndexOf(op);
var t = typeof(object);
if (op.DataType == t)
{
op.DataType = e.TargetOption.DataType;
this.OutputOptions[nIndex].DataType = op.DataType;
foreach (STNodeOption v in this.InputOptions)
{
if (v.DataType == t)
{
return;
}
}
this.Addhub();
}
else
{
//this.OutputOptions[nIndex].Data = e.TargetOption.Data;
this.OutputOptions[nIndex].TransferData(e.TargetOption.Data);
}
}
public override ConnectionStatus CanConnect(STNodeOption op)
{
if (op == STNodeOption.Empty)
{
return(ConnectionStatus.EmptyOption);
}
if (this.DataType != typeof(object))
{
return(base.CanConnect(op));
}
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 (op.DataType == typeof(object))
{
return(ConnectionStatus.ErrorType);
}
if (!this.IsInput)
{
return(ConnectionStatus.Connected);
}
foreach (STNodeOption owner_input in this.Owner.InputOptions)
{
foreach (STNodeOption o in owner_input.ConnectedOption)
{
if (o == op)
{
return(ConnectionStatus.Exists);
}
}
}
return(ConnectionStatus.Connected);;
}
public STNodeOption[] ToArray()
{
STNodeOption[] ops = new STNodeOption[this._Count];
for (int i = 0; i < ops.Length; i++)
{
ops[i] = m_options[i];
}
return(ops);
}
/// <summary>
/// Check if there is enough space to expand the capacity
/// </summary>
/// <param name="elements">Number of elements to be added</param>
private void EnsureSpace(int elements)
{
if (elements + this._Count > m_options.Length)
{
STNodeOption[] arrTemp = new STNodeOption[Math.Max(m_options.Length * 2, elements + this._Count)];
m_options.CopyTo(arrTemp, 0);
m_options = arrTemp;
}
}
public void Remove(STNodeOption option)
{
int nIndex = this.IndexOf(option);
if (nIndex != -1)
{
this.RemoveAt(nIndex);
}
}
void input_DataTransfer(object sender, STNodeOptionEventArgs e)
{
STNodeOption op = sender as STNodeOption;
int nIndex = this.InputOptions.IndexOf(op);
if (e.Status != ConnectionStatus.Connected)
{
this.OutputOptions[nIndex].Data = null;
}
else
{
this.OutputOptions[nIndex].Data = e.TargetOption.Data;
}
this.OutputOptions[nIndex].TransferData();
}
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);
}
public override ConnectionStatus ConnectOption(STNodeOption op)
{
var t = typeof(object);
if (this.DataType != t)
{
return(base.ConnectOption(op));
}
this.DataType = op.DataType;
var ret = base.ConnectOption(op);
if (ret != ConnectionStatus.Connected)
{
this.DataType = t;
}
return(ret);
}
/// <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);
}
public int Add(STNodeOption option)
{
if (option == null)
{
throw new ArgumentNullException("Add object cannot be null");
}
this.EnsureSpace(1);
int nIndex = option == STNodeOption.Empty ? -1 : this.IndexOf(option);
if (-1 == nIndex)
{
nIndex = this._Count;
option.Owner = m_owner;
option.IsInput = m_isInput;
m_options[this._Count++] = option;
this.Invalidate();
}
return(nIndex);
}
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);
}
public void Insert(int index, STNodeOption option)
{
if (index < 0 || index >= this._Count)
{
throw new IndexOutOfRangeException("Index out of bounds");
}
if (option == null)
{
throw new ArgumentNullException("Insert object cannot be null");
}
this.EnsureSpace(1);
for (int i = this._Count; i > index; i--)
{
m_options[i] = m_options[i - 1];
}
option.Owner = m_owner;
m_options[index] = option;
this._Count++;
this.Invalidate();
}
/// <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);
}
void output_DisConnected(object sender, STNodeOptionEventArgs e)
{
STNodeOption op = sender as STNodeOption;
if (op.ConnectionCount != 0)
{
return;
}
int nIndex = this.OutputOptions.IndexOf(op);
if (this.InputOptions[nIndex].ConnectionCount != 0)
{
return;
}
this.InputOptions.RemoveAt(nIndex);
this.OutputOptions.RemoveAt(nIndex);
if (this.Owner != null)
{
this.Owner.BuildLinePath();
}
this.Height -= 20;
}
public bool Contains(STNodeOption option)
{
return(this.IndexOf(option) != -1);
}
public STNodeOptionEventArgs(bool isSponsor, STNodeOption opTarget, ConnectionStatus cr)
{
this._IsSponsor = isSponsor;
this._TargetOption = opTarget;
this._Status = cr;
}
public STNodeEditorOptionEventArgs(STNodeOption opTarget, STNodeOption opCurrent, ConnectionStatus cr)
: base(false, opTarget, cr)
{
this._CurrentOption = opCurrent;
}
public int IndexOf(STNodeOption option)
{
return(Array.IndexOf <STNodeOption>(m_options, option));
}
