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); }