Task CreateNodeAsync(byte[] newBytes, string newPath)
{
return(Task.Run(() =>
{
Solid csg;
if (newBytes.Length > 0)
{
switch (Path.GetExtension(newPath).ToLowerInvariant())
{
case ".cs":
csg = CreateCsgFromCSharp(newBytes, newPath);
break;
default:
throw new Exception($"Don't know how to open {newPath}.");
}
}
else
{
csg = new Solid();
}
var newNode = csg.ToSCNNode();
if (path == newPath && Object.ReferenceEquals(bytes, newBytes))
{
node = newNode;
NodeChanged?.Invoke();
}
}));
}
internal INode GetNodeInstance(DataNode node)
{
var ret = Nodes.FirstOrDefault(d => d.Topic == node.Topic);
var isNew = false;
if (ret == null)
{
ret = Helpers.StateHelper.Instance.CreateNodeFromData(node);
isNew = true;
}
ret.Parse(node);
if (isNew)
{
Nodes.Add(ret);
AllNodesContainer.Nodes.Add(ret);
}
NodeChanged?.Invoke(ret);
return(ret);
}
public void RaiseNodeChanged(BuildOutputNode node)
{
if (node != null)
{
NodeChanged?.Invoke(this, new TreeNodeEventArgs(node));
}
}
private void OnNodeChanged(object sender, NodeChangedEventArgs nodeChangedEventArgs)
{
if (IsLoading)
{
return;
}
NodeChanged?.Invoke(sender, nodeChangedEventArgs);
OnGraphChanged(nameof(Members));
}
/// <summary>
/// Clears all nodes without any event call.
/// </summary>
protected void ClearAllNodesSilently(bool clearCallbacks = false)
{
AllNodes.Clear();
if (clearCallbacks)
{
OnNodeChanged = null;
OnNodeAdded = null;
OnNodeRemoved = null;
}
}
////////
//
// IToolServices public API implementation
//
// - this is intended to be used only by ITools.
////////
public void SetNode(GameTreeNode node)
{
if (node == null)
{
throw new ArgumentException($"{nameof(node)} cant be null");
}
Node = node;
NodeChanged?.Invoke(this, node);
}
private void _ports_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortAdded));
}
else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortRemoved));
}
}
/// <summary>
/// Processes the specified event.
/// </summary>
/// <param name="event">the watched event.</param>
/// <returns></returns>
public override Task process(WatchedEvent @event)
{
if (@event.get_Type() == Event.EventType.None)
{
StateChanged?.Invoke(@event);
}
else
{
NodeChanged?.Invoke(@event);
}
return(Task.CompletedTask);
}
/// <summary>
/// Called when public properties changed.
/// </summary>
/// <param name="name">The name of the property.</param>
public void OnPropertyChanged([CallerMemberName] string name = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
if (name == nameof(IsSelected))
{
SelectionChanged?.Invoke(this, EventArgs.Empty);
}
else if (name == nameof(Name))
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.NodeNameChanged));
}
else if (name == nameof(Comment))
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.NodeCommentChanged));
}
}
public xTreeList(DataPersistance Dp, IUINavigator Navigator, TreeList TreeList,
string OrderField, string SqlCondition, string PostingField)
: this(Dp, TreeList, OrderField, SqlCondition, PostingField)
{
_Navigator = Navigator;
foreach (TreeListColumn tlc in TreeList.Columns)
{
tlc.Caption = BaseUtility.SplitName(tlc.Caption);
}
onNodeSelected += new NodeSelected(xTreeList_onNodeSelected);
onAfterAddNode += new NodeChanged(xTreeList_onAfterAddNode);
Navigator.onEntityAction += new EntityAction(Navigator_onEntityAction);
Navigator.onDataMoving += new DataMoving(Navigator_onDataMoving);
DrawTree(null);
}
private void _ports_PortChanged(object sender, PortChangedEventArgs e)
{
if (e.PropertyName == nameof(IPort.Text))
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortTextChanged));
}
if (e.PropertyName == nameof(IPort.Comment))
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortCommentChanged));
}
else if (e.PropertyName == nameof(IPort.Value))
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortValueChanged));
}
else if (e.PropertyName == nameof(IPort.ConnectedPorts))
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortValueChanged));
}
}
internal void RaiseNodeChanged(FileSystemEntryId id, long size, double start, double end)
{
NodeChanged?.Invoke(id, size, start, end);
}
private void OnBoardChanged()
{
NodeChanged?.Invoke(this, GameTreeNode);
}
private void _ports_PortConnected(object sender, IPort e)
{
NodeChanged?.Invoke(this, new NodeChangedEventArgs(NodeChangeEventType.PortDisconnected, e));
}
void IEventSink.NotifyNodeChanged(DataNode node, int index)
{
NodeChanged?.Invoke(this, new TreeNodeEventArgs(node, index));
}
/// <summary>
/// Called after the current node or the index of the current dialogue entry has changed.
/// </summary>
/// <remarks>
/// Trigger events according to the current game state and how it is changed
/// </remarks>
/// <param name="nodeChanged"></param>
/// <param name="dialogueChanged"></param>
/// <param name="firstEntryOfNode"></param>
/// <param name="dialogueStepped"></param>
private void UpdateGameState(bool nodeChanged, bool dialogueChanged, bool firstEntryOfNode,
bool dialogueStepped)
{
// Debug.LogFormat("UpdateGameState begin {0} {1} {2}", stepNumFromLastCheckpoint, restrainCheckpoint, forceCheckpoint);
if (nodeChanged)
{
// Debug.Log($"Nova: node changed to {currentNode.name}");
if (firstEntryOfNode)
{
EnsureCheckpoint(); // always get a checkpoint at the beginning of the node
}
NodeChanged?.Invoke(new NodeChangedData(currentNode.name));
}
if (dialogueChanged)
{
this.RuntimeAssert(currentIndex >= 0 && currentIndex < currentNode.dialogueEntryCount,
"Dialogue index out of range.");
if (!firstEntryOfNode && dialogueStepped)
{
stepNumFromLastCheckpoint++;
}
var gameStateRestoreEntry = checkpointManager.IsReached(currentNode.name, currentIndex, variables.hash);
if (gameStateRestoreEntry == null)
{
// Tell the checkpoint manager a new dialogue entry has been reached
checkpointManager.SetReached(currentNode.name, currentIndex, variables,
GetGameStateStepRestoreEntry());
}
// Change states after creating or restoring from checkpoint
if (shouldSaveRealCheckpoint)
{
stepNumFromLastCheckpoint = 0;
}
if (gameStateRestoreEntry != null)
{
this.RuntimeAssert(stepNumFromLastCheckpoint == gameStateRestoreEntry.stepNumFromLastCheckpoint,
$"StepNumFromLastCheckpoint mismatch: {stepNumFromLastCheckpoint} {gameStateRestoreEntry.stepNumFromLastCheckpoint}");
this.RuntimeAssert(restrainCheckpoint == gameStateRestoreEntry.restrainCheckpointNum,
$"RestrainCheckpointNum mismatch: {restrainCheckpoint} {gameStateRestoreEntry.restrainCheckpointNum}");
}
if (checkpointRestrained)
{
restrainCheckpoint--;
if (restrainCheckpoint == 1)
{
Debug.LogWarning($"Nova: restrainCheckpoint reaches 1");
}
}
// As the action for this dialogue will be re-run, it's fine to just reset forceCheckpoint to false
forceCheckpoint = false;
DialogueWillChange?.Invoke();
state = State.ActionRunning;
lastVariablesHashBeforeAction = variables.hash;
currentDialogueEntry = currentNode.GetDialogueEntryAt(currentIndex);
currentDialogueEntry.ExecuteAction();
StartCoroutine(WaitActionEnd(gameStateRestoreEntry != null));
}
// Debug.LogFormat("UpdateGameState end {0} {1} {2} {3}", stepNumFromLastCheckpoint, restrainCheckpoint, forceCheckpoint, currentDialogueEntry?.displayData.FormatNameDialogue());
}
protected virtual void OnNodeChanged(TreeNodeChangedEventArgs <T> eventArgs)
{
NodeChanged?.Invoke(this, eventArgs);
}
/// <summary>
/// When Collection even is generated, this method is called
/// </summary>
/// <param name="args">Simias event details</param>
private void OnCollectionEvent(SimiasEventArgs args)
{
try
{
NodeEventArgs nodeArgs = args as NodeEventArgs;
if (nodeArgs != null)
{
if (applyNodeFilter(nodeArgs))
{
EventType changeType = (EventType)Enum.Parse(typeof(EventType), (string)nodeArgs.EventData, false);
switch (changeType)
{
case EventType.NodeChanged:
if (NodeChanged != null)
{
Delegate[] cbList = NodeChanged.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeChanged -= cb;
}
}
}
break;
case EventType.NodeCreated:
if (NodeCreated != null)
{
Delegate[] cbList = NodeCreated.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeCreated -= cb;
}
}
}
break;
case EventType.NodeDeleted:
if (NodeDeleted != null)
{
Delegate[] cbList = NodeDeleted.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeDeleted -= cb;
}
}
}
break;
case EventType.NoAccess:
if (NoAccess != null)
{
Delegate[] cbList = NoAccess.GetInvocationList();
foreach (NodeEventHandler cb in cbList)
{
try
{
cb(nodeArgs);
}
catch (Exception ex)
{
logger.Debug(ex, "Delegate {0}.{1} failed", cb.Target, cb.Method);
NodeDeleted -= cb;
}
}
}
break;
}
}
}
}
catch (Exception ex)
{
new SimiasException(args.ToString(), ex);
}
}
