void CreateNeighbors()
{
Debug.Log("creating");
var neighbors = Grid.GetNeighbors(currentNode.tile);
neighbors.ForEach((neighbor) =>
{
if (neighbor.tile.IsBlocked)
{
return;
}
if (visited.ContainsKey(neighbor.tile))
{
return;
}
StepNode node;
if (storage.ContainsKey(neighbor.tile))
{
node = storage[neighbor.tile];
}
else
{
node = new StepNode(neighbor.tile, targetTile);
storage[node.tile] = node;
node.tile.SetPriority(node.priority.ToString("n1"));
node.tile.SetCrowDist(node.crowDist.ToString("n1"));
node.tile.SetTraveled(node.traveled.ToString("n1"));
}
node.tile.ChangeColor(tooVisitColor);
});
}
public static TreeNode GetAllTypeNode()
{
TypesB1Node nodeType = new TypesB1Node();
nodeType.Text = nodeType.KNXMainNumber + "." + nodeType.KNXSubNumber + " " + nodeType.Name;
nodeType.Nodes.Add(SwitchNode.GetTypeNode());
nodeType.Nodes.Add(BoolNode.GetTypeNoe());
nodeType.Nodes.Add(EnableNode.GetTypeNode());
nodeType.Nodes.Add(RampNode.GetTypeNode());
nodeType.Nodes.Add(AlarmNode.GetTypeNode());
nodeType.Nodes.Add(BinaryValueNode.GetTypeNode());
nodeType.Nodes.Add(StepNode.GetTypeNode());
nodeType.Nodes.Add(UpDownNode.GetTypeNode());
nodeType.Nodes.Add(OpenCloseNode.GetTypeNode());
nodeType.Nodes.Add(StartNode.GetTypeNode());
nodeType.Nodes.Add(StateNode.GetTypeNode());
nodeType.Nodes.Add(InvertNode.GetTypeNode());
nodeType.Nodes.Add(DimSendStyleNode.GetTypeNode());
nodeType.Nodes.Add(InputSourceNode.GetTypeNode());
nodeType.Nodes.Add(ResetNode.GetTypeNode());
nodeType.Nodes.Add(AckNode.GetTypeNode());
nodeType.Nodes.Add(TriggerNode.GetTypeNode());
nodeType.Nodes.Add(OccupancyNode.GetTypeNode());
nodeType.Nodes.Add(WindowDoorNode.GetTypeNode());
nodeType.Nodes.Add(LogicalFunctionNode.GetTypeNode());
nodeType.Nodes.Add(SceneABNode.GetTypeNode());
nodeType.Nodes.Add(ShutterBlindsModeNode.GetTypeNode());
nodeType.Nodes.Add(HeatCoolNode.GetTypeNode());
return(nodeType);
}
private void UserSelectStepNode(StepNode stepNode)
{
SelectStepNode(stepNode);
if (stepNode != null)
{
StepWindow.ShowInspector();
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Z))
{
drawLines = !drawLines;
Debug.Log(drawLines);
StepNode.ToggleLines();
}
}
private bool CutStep(IStep step, StepNode owner)
{
if (CopyStep(step))
{
DeleteStepWithUndo(step, owner);
return(true);
}
return(false);
}
void PathfindLoop()
{
int count = 0;
while (count < stepsPerFrame)
{
cycles++;
count++;
currentNode = distHeap.Remove();
visited[currentNode.tile] = true;
if (currentNode.tile == targetTile)
{
isPathfinding = false;
FoundTarget();
return;
}
var neighbors = Grid.GetNeighbors(currentNode.tile);
neighbors.ForEach((neighbor) =>
{
if (neighbor.tile.IsBlocked)
{
return;
}
if (visited.ContainsKey(neighbor.tile))
{
return;
}
bool alreadyVisited = false;
StepNode node;
if (storage.ContainsKey(neighbor.tile))
{
alreadyVisited = true;
node = storage[neighbor.tile];
}
else
{
node = new StepNode(neighbor.tile, targetTile, currentMethod);
storage[node.tile] = node;
}
if (node.traveled > currentNode.traveled + neighbor.distance)
{
if (alreadyVisited)
{
distHeap.Remove(node);
}
var distance = currentNode.traveled + neighbor.distance;
node.traveled = currentNode.traveled + neighbor.distance;
node.Prev = currentNode;
distHeap.Insert(node);
node.tile.ChangeColor(distGrad.Evaluate(distance / maxDist));
}
});
}
}
private bool SetStep(StepNode nextStep, bool includeUnloaded = false)
{
if (nextStep == null)
{
Log.Debug("SetStep: nextStep is null");
return(false);
}
Log.Debug("SetStep: '" + nextStep.Step.ID + "'");
if (myCurrentStepNode != nextStep)
{
FeatureTour.OnStepLeaved(myCurrentStepNode.Step);
myCurrentStepNode = nextStep;
}
var step = myCurrentStepNode.Step;
FeatureTour.OnStepEntering(step);
var app = Application.Current;
VisualElement element;
if (app == null)
{
element = myVisualElementManager.GetVisualElement(step.ElementID, includeUnloaded);
}
else
{
element = app.Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, new Func <object>(() => myVisualElementManager.GetVisualElement(step.ElementID, includeUnloaded))) as VisualElement;
}
if (element == null)
{
LogWarningCouldNotFindElementFor(step);
return(false);
}
using (myPopupNavigator.MovePopupTo(element))
{
InitializeViewModel(step, element);
// required to ensure that the view is updated before the popup is shown
// otherwise the update is visible in the popup (which looks ugly)
Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new Action(() => { }));
FeatureTour.OnStepEntered(step);
}
return(true);
}
public override bool Equals(object other)
{
var otherNode = other as RangeExprNode;
if (null == otherNode)
{
return(false);
}
return(FromNode.Equals(otherNode.FromNode) &&
ToNode.Equals(otherNode.ToNode) &&
stepoperator.Equals(otherNode.stepoperator) &&
((StepNode == otherNode.StepNode) || (StepNode != null && StepNode.Equals(otherNode.StepNode))) &&
HasRangeAmountOperator == otherNode.HasRangeAmountOperator);
}
private void SelectStepNode(StepNode stepNode)
{
IStep step = stepNode == null ? null : stepNode.Step;
if (lastSelectedStepNode != null)
{
lastSelectedStepNode.IsLastSelectedStep = false;
}
lastSelectedStepNode = stepNode;
chapter.ChapterMetadata.LastSelectedStep = step;
if (stepNode != null)
{
stepNode.IsLastSelectedStep = true;
}
}
void PickNode()
{
Debug.Log("Picking");
if (currentNode != null)
{
currentNode.tile.ChangeColor(visitedColor);
}
currentNode = distHeap.Remove();
visited[currentNode.tile] = true;
currentNode.tile.ChangeColor(currentNodeColor);
if (currentNode.tile == targetTile)
{
isPathfinding = false;
FoundTarget();
return;
}
;
}
private void SelectStepNode(StepNode stepNode)
{
IStep step = stepNode == null ? null : stepNode.Step;
if (lastSelectedStepNode != null)
{
lastSelectedStepNode.IsLastSelectedStep = false;
}
lastSelectedStepNode = stepNode;
CurrentChapter.ChapterMetadata.LastSelectedStep = step;
if (stepNode != null)
{
stepNode.IsLastSelectedStep = true;
}
GlobalEditorHandler.ChangeCurrentStep(step);
}
// Check if this can be unified associative range expr
public override string ToString()
{
StringBuilder buf = new StringBuilder();
string postfix = base.ToString();
if (!string.IsNullOrEmpty(postfix))
{
buf.Append("(");
}
buf.Append(FromNode.ToString());
buf.Append("..");
if (HasRangeAmountOperator)
{
buf.Append("#");
}
buf.Append(ToNode.ToString());
if (StepNode != null)
{
buf.Append("..");
if (DSASM.RangeStepOperator.approxsize == stepoperator)
{
buf.Append("~");
}
else if (DSASM.RangeStepOperator.num == stepoperator)
{
buf.Append("#");
}
buf.Append(StepNode.ToString());
}
if (!string.IsNullOrEmpty(postfix))
{
buf.Append(")");
}
buf.Append(postfix);
return(buf.ToString());
}
void UpdateNeighbors()
{
var neighbors = Grid.GetNeighbors(currentNode.tile);
neighbors.ForEach((neighbor) =>
{
if (neighbor.tile.IsBlocked)
{
return;
}
if (visited.ContainsKey(neighbor.tile))
{
return;
}
bool alreadyVisited = false;
StepNode node;
if (storage.ContainsKey(neighbor.tile))
{
alreadyVisited = true;
node = storage[neighbor.tile];
}
else
{
node = new StepNode(neighbor.tile, targetTile);
storage[node.tile] = node;
}
node.tile.ChangeColor(creatingNodeColor);
if (node.traveled > currentNode.traveled + neighbor.distance)
{
if (alreadyVisited)
{
distHeap.Remove(node);
}
var distance = currentNode.traveled + neighbor.distance;
node.traveled = currentNode.traveled + neighbor.distance;
node.Prev = currentNode;
node.tile.SetTraveled(node.traveled.ToString("n1"));
node.tile.SetPriority(node.priority.ToString("n2"));
distHeap.Insert(node);
}
});
}
public void Pathfind()
{
if (startingObj.Tile.IsBlocked || targetObj.Tile.IsBlocked)
{
return;
}
cycles = 0;
maxDist = Vector3.Distance(targetObj.Tile.transform.position, startingObj.Tile.transform.position) * distMult;
isPathfinding = true;
distHeap = new Heap <StepNode>();
storage = new Dictionary <Tile, StepNode>();
visited = new Dictionary <Tile, bool>();
targetTile = targetObj.Tile;
StepNode.ClearAllLines();
var node = new StepNode(startingObj.Tile, targetTile);
node.traveled = 0;
storage[node.tile] = node;
distHeap.Insert(node);
Grid.ResetGridColor();
}
public void Pathfind()
{
if (startingObj.Tile.IsBlocked || targetObj.Tile.IsBlocked)
{
return;
}
isPathfinding = true;
distHeap = new Heap <StepNode>();
storage = new Dictionary <Tile, StepNode>();
visited = new Dictionary <Tile, bool>();
targetTile = targetObj.Tile;
var node = new StepNode(startingObj.Tile, targetTile);
node.traveled = 0;
storage[node.tile] = node;
distHeap.Insert(node);
Grid.ResetGridColor();
node.tile.SetPriority(node.priority.ToString("n2"));
node.tile.SetCrowDist(node.crowDist.ToString("n1"));
node.tile.SetTraveled(node.traveled.ToString("n1"));
}
private void DeleteStepWithUndo(IStep step, StepNode ownerNode)
{
IList <ITransition> incomingTransitions = CurrentChapter.Data.Steps.SelectMany(s => s.Data.Transitions.Data.Transitions).Where(transition => transition.Data.TargetStep == step).ToList();
bool wasFirstStep = step == CurrentChapter.Data.FirstStep;
RevertableChangesHandler.Do(new CourseCommand(
() =>
{
foreach (ITransition transition in incomingTransitions)
{
transition.Data.TargetStep = null;
}
DeleteStep(step);
if (wasFirstStep)
{
CurrentChapter.Data.FirstStep = null;
}
},
() =>
{
AddStep(step);
if (wasFirstStep)
{
CurrentChapter.Data.FirstStep = step;
}
foreach (ITransition transition in incomingTransitions)
{
transition.Data.TargetStep = step;
}
SelectStepNode(ownerNode);
}
));
}
// Methods
// //////////////////////////////////////////////////////////////////////
private void InitStepNodes()
{
StepNode prevStepNode = null;
var counter = 1;
foreach (var step in myTour.Steps)
{
var stepNode = new StepNode(step)
{
Previous = prevStepNode,
StepNo = counter++
};
if (prevStepNode == null)
{
myCurrentStepNode = stepNode;
}
else
{
prevStepNode.Next = stepNode;
}
prevStepNode = stepNode;
}
}
public bool SetPendingWorkflowData(string pendingWorkflowData, bool bShowErr)
{
if (pendingWorkflowData == string.Empty)
{
return(false);
}
try
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(pendingWorkflowData);
XmlNode root = doc.DocumentElement;
if (root.ChildNodes.Count == 0)
{
// No steps in this workflow.
return(false);
}
XmlNodeList Steps = root.SelectNodes(XML_STEP);
if (Steps.Count == 0)
{
return(false);
}
if (wfSteps == null || wfSteps.Count == 0)
{
Logging.Warn(this.ToString(), localizeWF.WORKFLOW_DATA_STRUCTURES_WORKFLOW_DATA_SET_PENDING_WORKFLOW_DATA);
return(false);
}
//parse through the xml to get to each of the steps.
foreach (XmlNode StepNode in Steps)
{
foreach (WorkflowStep Step in wfSteps)
{
if (Convert.ToInt32(StepNode.Attributes[XML_STEP_ID].InnerText, 10) == Step.Workflowstepid)
{
//step found. set the value, complete or not.
if (StepNode.SelectSingleNode(XML_STEP_COMPLETE).InnerText == STEP_COMPLETE_VAL)
{
Step.IsStepComplete = true;
}
else
{
//set the active step.
activeStepId = Step.Workflowstepid;
}
}
}
}
// Check if the active step was set in the previous iterations
if (activeStepId == -1)
{
if (bShowErr)
{
Logging.Error(this.ToString(), localizeWF.WORKFLOW_DATA_STRUCTURES_WORKFLOW_DATA_SET_PENDING_WORKFLOW_DATA_SET_TO_FIRST_STEP);
}
// Active step of the pending workflow was removed.
// set the active step to the first step in the workflow.
WorkflowStep firstStep = wfSteps[0] as WorkflowStep;
activeStepId = firstStep.Workflowstepid;
}
}
catch (Exception exp)
{
if (bShowErr)
{
Logging.Error(this.ToString(), localizeWF.WORKFLOW_DATA_STRUCTURES_WORKFLOW_DATA_SET_PENDING_WORKFLOW_DATA, exp);
throw exp;
}
}
return(true);
}
private StepNode CreateNewStepNode(IStep step)
{
StepNode node = new StepNode(Graphics, CurrentChapter, step);
node.GraphicalEventHandler.ContextClick += (sender, args) =>
{
TestableEditorElements.DisplayContextMenu(new List <TestableEditorElements.MenuOption>
{
new TestableEditorElements.MenuItem(new GUIContent("Copy"), false, () =>
{
CopyStep(step);
}),
new TestableEditorElements.MenuItem(new GUIContent("Cut"), false, () =>
{
CutStep(step, node);
}),
new TestableEditorElements.MenuItem(new GUIContent("Delete"), false, () =>
{
DeleteStepWithUndo(step, node);
})
});
};
node.GraphicalEventHandler.PointerDown += (sender, args) =>
{
UserSelectStepNode(node);
};
node.RelativePositionChanged += (sender, args) =>
{
node.Step.StepMetadata.Position = node.Position;
};
node.GraphicalEventHandler.PointerUp += (sender, args) =>
{
Graphics.CalculateBoundingBox();
};
// ReSharper disable once ImplicitlyCapturedClosure
node.GraphicalEventHandler.PointerDown += (sender, args) => UserSelectStepNode(node);
node.CreateTransitionButton.GraphicalEventHandler.PointerClick += (sender, args) =>
{
ITransition transition = EntityFactory.CreateTransition();
RevertableChangesHandler.Do(new CourseCommand(
() =>
{
step.Data.Transitions.Data.Transitions.Add(transition);
MarkToRefresh();
},
() =>
{
step.Data.Transitions.Data.Transitions.Remove(transition);
MarkToRefresh();
}
));
};
if (CurrentChapter.ChapterMetadata.LastSelectedStep == step)
{
SelectStepNode(node);
}
SetupNode(node, position => node.Step.StepMetadata.Position = position);
return(node);
}
private StepNode CreateNewStepNode(IStep step)
{
StepNode node = new StepNode(Graphics, step);
node.GraphicalEventHandler.ContextClick += (sender, args) =>
{
TestableEditorElements.DisplayContextMenu(new List <TestableEditorElements.MenuOption>
{
new TestableEditorElements.MenuItem(new GUIContent("Delete step"), false, () =>
{
IList <ITransition> incomingTransitions = chapter.Data.Steps.SelectMany(s => s.Data.Transitions.Data.Transitions).Where(transition => transition.Data.TargetStep == step).ToList();
bool wasFirstStep = step == chapter.Data.FirstStep;
RevertableChangesHandler.Do(new TrainingCommand(
() =>
{
foreach (ITransition transition in incomingTransitions)
{
transition.Data.TargetStep = null;
}
DeleteStep(step);
if (wasFirstStep)
{
chapter.Data.FirstStep = null;
}
},
() =>
{
AddStep(step);
if (wasFirstStep)
{
chapter.Data.FirstStep = step;
}
foreach (ITransition transition in incomingTransitions)
{
transition.Data.TargetStep = step;
}
UserSelectStepNode(node);
}
));
})
});
};
node.GraphicalEventHandler.PointerDown += (sender, args) =>
{
UserSelectStepNode(node);
};
node.RelativePositionChanged += (sender, args) =>
{
node.Step.StepMetadata.Position = node.Position;
};
node.GraphicalEventHandler.PointerUp += (sender, args) =>
{
Graphics.CalculateBoundingBox();
};
// ReSharper disable once ImplicitlyCapturedClosure
node.GraphicalEventHandler.PointerDown += (sender, args) => UserSelectStepNode(node);
node.CreateTransitionButton.GraphicalEventHandler.PointerClick += (sender, args) =>
{
ITransition transition = new Transition();
RevertableChangesHandler.Do(new TrainingCommand(
() =>
{
step.Data.Transitions.Data.Transitions.Add(transition);
MarkToRefresh();
},
() =>
{
step.Data.Transitions.Data.Transitions.Remove(transition);
MarkToRefresh();
}
));
};
if (chapter.ChapterMetadata.LastSelectedStep == step)
{
SelectStepNode(node);
}
SetupNode(node, position => node.Step.StepMetadata.Position = position);
return(node);
}
private void SetupTransitions(IChapter chapter, EntryNode entryNode, IDictionary <IStep, StepNode> stepNodes)
{
if (chapter.Data.FirstStep != null)
{
CreateNewTransition(entryNode.ExitJoints.First(), stepNodes[chapter.Data.FirstStep].EntryJoints.First());
}
foreach (IStep step in stepNodes.Keys)
{
foreach (ITransition transition in step.Data.Transitions.Data.Transitions)
{
ExitJoint joint = stepNodes[step].AddExitJoint();
if (transition.Data.TargetStep != null)
{
StepNode target = stepNodes[transition.Data.TargetStep];
CreateNewTransition(joint, target.EntryJoints.First());
}
IStep closuredStep = step;
ITransition closuredTransition = transition;
int transitionIndex = step.Data.Transitions.Data.Transitions.IndexOf(closuredTransition);
joint.GraphicalEventHandler.PointerDrag += (sender, args) =>
{
joint.DragDelta = args.PointerPosition - joint.Position;
};
joint.GraphicalEventHandler.PointerUp += (sender, args) =>
{
GraphicalElement elementUnderCursor = Graphics.GetGraphicalElementWithHandlerAtPoint(args.PointerPosition).FirstOrDefault();
EntryJoint endJoint = elementUnderCursor as EntryJoint;
if (endJoint == null)
{
joint.DragDelta = Vector2.zero;
if (elementUnderCursor != null)
{
return;
}
}
StepNode endJointStepNode = endJoint == null ? null : endJoint.Parent as StepNode;
IStep targetStep = null;
IStep oldStep = closuredTransition.Data.TargetStep;
if (endJointStepNode != null)
{
targetStep = endJointStepNode.Step;
}
RevertableChangesHandler.Do(new TrainingCommand(() =>
{
closuredTransition.Data.TargetStep = targetStep;
SelectStepNode(stepNodes[closuredStep]);
MarkToRefresh();
},
() =>
{
closuredTransition.Data.TargetStep = oldStep;
SelectStepNode(stepNodes[closuredStep]);
MarkToRefresh();
}
));
joint.DragDelta = Vector2.zero;
};
joint.GraphicalEventHandler.ContextClick += (sender, args) =>
{
TestableEditorElements.DisplayContextMenu(new List <TestableEditorElements.MenuOption>
{
new TestableEditorElements.MenuItem(new GUIContent("Delete transition"), false, () =>
{
RevertableChangesHandler.Do(new TrainingCommand(() =>
{
closuredStep.Data.Transitions.Data.Transitions.Remove(closuredTransition);
MarkToRefresh();
},
() =>
{
closuredStep.Data.Transitions.Data.Transitions.Insert(transitionIndex, closuredTransition);
MarkToRefresh();
}
));
})
});
};
}
}
}
private EntryNode CreateEntryNode(IChapter chapter)
{
EntryNode entryNode = new EntryNode(Graphics);
ExitJoint joint = new ExitJoint(Graphics, entryNode)
{
RelativePosition = new Vector2(entryNode.LocalBoundingBox.xMax, entryNode.LocalBoundingBox.center.y),
};
entryNode.ExitJoints.Add(joint);
entryNode.Position = chapter.ChapterMetadata.EntryNodePosition;
entryNode.RelativePositionChanged += (sender, args) =>
{
chapter.ChapterMetadata.EntryNodePosition = entryNode.Position;
};
entryNode.GraphicalEventHandler.PointerUp += (sender, args) =>
{
Graphics.CalculateBoundingBox();
};
entryNode.GraphicalEventHandler.ContextClick += (sender, args) =>
{
if (chapter.Data.FirstStep == null)
{
return;
}
TestableEditorElements.DisplayContextMenu(new List <TestableEditorElements.MenuOption>
{
new TestableEditorElements.MenuItem(new GUIContent("Delete transition"), false, () =>
{
IStep firstStep = chapter.Data.FirstStep;
RevertableChangesHandler.Do(new TrainingCommand(() =>
{
chapter.Data.FirstStep = null;
MarkToRefresh();
},
() =>
{
chapter.Data.FirstStep = firstStep;
MarkToRefresh();
}
));
})
});
};
joint.GraphicalEventHandler.PointerDrag += (sender, args) =>
{
joint.DragDelta = args.PointerPosition - joint.Position;
};
joint.GraphicalEventHandler.PointerUp += (sender, args) =>
{
EntryJoint endJoint = Graphics.GetGraphicalElementWithHandlerAtPoint(args.PointerPosition).FirstOrDefault() as EntryJoint;
if (endJoint == null)
{
joint.DragDelta = Vector2.zero;
return;
}
StepNode endJointStepNode = endJoint.Parent as StepNode;
IStep targetStep = null;
IStep oldStep = chapter.Data.FirstStep;
if (endJointStepNode != null)
{
targetStep = endJointStepNode.Step;
}
RevertableChangesHandler.Do(new TrainingCommand(() =>
{
chapter.Data.FirstStep = targetStep;
MarkToRefresh();
},
() =>
{
chapter.Data.FirstStep = oldStep;
MarkToRefresh();
}
));
joint.DragDelta = Vector2.zero;
};
SetupNode(entryNode, position => chapter.ChapterMetadata.EntryNodePosition = position);
return(entryNode);
}
private void UserSelectStepNode(StepNode stepNode)
{
SelectStepNode(stepNode);
Graphics.BringToTop(stepNode);
GlobalEditorHandler.StartEditingStep();
}
private void SetupTransitions(IChapter chapter, EntryNode entryNode, IDictionary <IStep, StepNode> stepNodes)
{
if (chapter.Data.FirstStep != null)
{
CreateNewTransition(entryNode.ExitJoints.First(), stepNodes[chapter.Data.FirstStep].EntryJoints.First());
}
foreach (IStep step in stepNodes.Keys)
{
foreach (ITransition transition in step.Data.Transitions.Data.Transitions)
{
ExitJoint joint = stepNodes[step].AddExitJoint();
if (transition.Data.TargetStep != null)
{
StepNode target = stepNodes[transition.Data.TargetStep];
CreateNewTransition(joint, target.EntryJoints.First());
}
IStep closuredStep = step;
ITransition closuredTransition = transition;
int transitionIndex = step.Data.Transitions.Data.Transitions.IndexOf(closuredTransition);
joint.GraphicalEventHandler.PointerDrag += (sender, args) =>
{
joint.DragDelta = args.PointerPosition - joint.Position;
};
joint.GraphicalEventHandler.PointerUp += (sender, args) =>
{
joint.DragDelta = Vector2.zero;
IStep oldStep = closuredTransition.Data.TargetStep;
if (TryGetStepForTransitionDrag(args.PointerPosition, out IStep targetStep) == false)
{
return;
}
RevertableChangesHandler.Do(new CourseCommand(() =>
{
closuredTransition.Data.TargetStep = targetStep;
SelectStepNode(stepNodes[closuredStep]);
MarkToRefresh();
},
() =>
{
closuredTransition.Data.TargetStep = oldStep;
SelectStepNode(stepNodes[closuredStep]);
MarkToRefresh();
}
));
};
joint.GraphicalEventHandler.ContextClick += (sender, args) =>
{
TestableEditorElements.DisplayContextMenu(new List <TestableEditorElements.MenuOption>
{
new TestableEditorElements.MenuItem(new GUIContent("Delete transition"), false, () =>
{
bool isLast = closuredStep.Data.Transitions.Data.Transitions.Count == 1;
RevertableChangesHandler.Do(new CourseCommand(() =>
{
closuredStep.Data.Transitions.Data.Transitions.Remove(closuredTransition);
if (isLast)
{
closuredStep.Data.Transitions.Data.Transitions.Add(EntityFactory.CreateTransition());
}
MarkToRefresh();
},
() =>
{
if (isLast)
{
closuredStep.Data.Transitions.Data.Transitions.RemoveAt(0);
}
closuredStep.Data.Transitions.Data.Transitions.Insert(transitionIndex, closuredTransition);
MarkToRefresh();
}
));
})
});
};
}
}
}
private HandleWindowTransitionResult HandleWindowTransitionChange(Guid previousWindowID)
{
// If current element is already on the new window, we don't need to go.
// CASE: Window is just reactivated
var currentElement = myVisualElementManager.GetVisualElement(myCurrentStepNode.Step.ElementID, false);
if (currentElement == null)
{
Log.Warn("Could not find visual element with ElementID '" + myCurrentStepNode.Step.ElementID + "'");
return(HandleWindowTransitionResult.DoNothing);
}
if (currentElement.WindowID == myCurrentWindowID)
{
return(HandleWindowTransitionResult.ShowPopup);
}
var behavior = currentElement.WindowTransisionBehavior;
if (behavior == WindowTransisionBehavior.None)
{
return(HandleWindowTransitionResult.DoNothing);
}
if (behavior == WindowTransisionBehavior.Automatic)
{
var wasPreviousParent = myWindowManager.IsParentWindow(previousWindowID, myCurrentWindowID);
behavior = wasPreviousParent ? WindowTransisionBehavior.NextHide : WindowTransisionBehavior.NextPreviousHide;
}
if (behavior == WindowTransisionBehavior.NextHide ||
behavior == WindowTransisionBehavior.NextPreviousHide)
{
// otherwise, we will try to to the next element on the new window
// CASE: Open modal dialog with elements
var nextStep = myCurrentStepNode.NextStep;
if (nextStep != null)
{
var nextElement = myVisualElementManager.GetVisualElement(nextStep.ElementID, true);
// next element belongs to the new window
if (nextElement != null && nextElement.WindowID == myCurrentWindowID)
{
NextStep(true);
return(HandleWindowTransitionResult.ShowPopup);
}
}
}
if (behavior == WindowTransisionBehavior.PreviousHide ||
behavior == WindowTransisionBehavior.NextPreviousHide)
{
// otherwise we will try to go to the nears previous step for the current window
// CASE: Open modal dialog but do not pass all steps on that dialog and close the dialog
StepNode prevStepNode = myCurrentStepNode;
while ((prevStepNode = prevStepNode.Previous) != null)
{
var prevElement = myVisualElementManager.GetVisualElement(prevStepNode.Step.ElementID, true);
if (prevElement == null || prevElement.WindowID != myCurrentWindowID)
{
continue;
}
SetStep(prevStepNode);
return(HandleWindowTransitionResult.ShowPopup);
}
}
// Otherwise do not show the popup because we have no meaningful content for the current window.
return(HandleWindowTransitionResult.HidePopup);
}
