private void CheckShown(NavigationCommand cmd) { if (!IsVisible) { Show(); } }
public void GetWxeFunctionPermanentUrlWithDefaultWxeHandlerAndAdditionalUrlParameters() { WebConfigurationMock.Current = WebConfigurationFactory.GetExecutionEngineWithDefaultWxeHandler(); string wxeHandler = Remotion.Web.Configuration.WebConfiguration.Current.ExecutionEngine.DefaultWxeHandler; NameValueCollection additionalUrlParameters = new NameValueCollection(); additionalUrlParameters.Add("Parameter2", "Value2"); string expectedUrl = wxeHandler.TrimStart('~'); NameValueCollection expectedQueryString = new NameValueCollection(); expectedQueryString.Add("Parameter1", _wxeFunctionParameter1Value); expectedQueryString.Add(WxeHandler.Parameters.WxeReturnToSelf, true.ToString()); expectedQueryString.Add(additionalUrlParameters); expectedQueryString.Add(WxeHandler.Parameters.WxeFunctionType, _functionTypeName); expectedUrl += UrlUtility.FormatQueryString(expectedQueryString); NavigationCommand command = new NavigationCommand(); command.Type = CommandType.WxeFunction; command.WxeFunctionCommand.TypeName = _functionTypeName; command.WxeFunctionCommand.Parameters = _wxeFunctionParameters; string url = command.GetWxeFunctionPermanentUrl(additionalUrlParameters); Assert.That(url, Is.Not.Null); Assert.That(url, Is.EqualTo(expectedUrl)); }
/// <summary> /// Constructor /// </summary> /// <param name="navigationManager">NavigationManager (Injected)</param> /// <param name="apiConnector">ApiConnector (Injected)</param> public DeckSearchViewModel(NavigationManager navigationManager, IApiConnector apiConnector) : base(navigationManager, apiConnector) { PracticeDeckCommand = new NavigationCommand(navigationManager) { CommandText = Messages.Practice, IsRelative = true, IsEnabledFunction = (parameter) => (parameter as Deck).CardCount > 0, ToolTip = Messages.PracticeCommandToolTip.FormatWith(EntityNameHelper.GetName <Deck>()), TargetUriFactory = (param) => $"/{(param as Deck).DeckId}/Practice" }; AddCardCommand = new NavigationCommand(navigationManager) { CommandText = Messages.NewCard, IsRelative = true, ToolTip = Components.Messages.NewCommandToolTip.FormatWith(EntityNameHelper.GetName <Card>()), TargetUriFactory = (param) => $"/{(param as Deck).DeckId}/Cards/New" }; ShowStatisticsCommand = new NavigationCommand(navigationManager) { CommandText = Messages.PracticeStatistics, IsRelative = true, ToolTip = Messages.ShowStatisticsCommandToolTip.FormatWith(EntityNameHelper.GetName <Deck>()), TargetUriFactory = (param) => $"/{(param as Deck).DeckId}/Statistics" }; }
public void Setup() { _mocks = new MockRepository(); _mockTabbedMenu = _mocks.PartialMock <TabbedMenu>(); _mockNavigationCommand1 = _mocks.PartialMock <NavigationCommand>(); _mocks.Replay(_mockNavigationCommand1); _mockNavigationCommand2 = _mocks.PartialMock <NavigationCommand>(); _mocks.Replay(_mockNavigationCommand2); _mainMenuTab = new MainMenuTab(); _mainMenuTab.ItemID = "MainMenuTab"; _mainMenuTab.Command.Type = CommandType.None; _mainMenuTab.OwnerControl = _mockTabbedMenu; _mockSubMenuTab1 = CreateSubMenuTab("SubMenuTab1", _mockNavigationCommand1); _mainMenuTab.SubMenuTabs.Add(_mockSubMenuTab1); _mockSubMenuTab2 = CreateSubMenuTab("SubMenuTab2", _mockNavigationCommand2); _mainMenuTab.SubMenuTabs.Add(_mockSubMenuTab2); _mocks.BackToRecord(_mockSubMenuTab1); _mocks.BackToRecord(_mockSubMenuTab2); _mocks.BackToRecord(_mockNavigationCommand1); _mocks.BackToRecord(_mockNavigationCommand2); }
/// <summary> /// Indicates whether a navigation would be valid if it were to be performed. /// </summary> /// <param name="command">The navigation command to test.</param> /// <param name="activity">The destination activity, if this is a choice navigation.</param> /// <returns>True if the navigation would be valid, false otherwise.</returns> /// <remarks> /// <para> /// This makes a partial copy of the activity tree for processing and attempts to /// perform a navigation on that copy. This may result in poor performance if this /// is called many times, but the alternative is to duplicate most of the sequencing /// code with lots of special cases for changes of state that should have happened but /// could not because of the temporary nature of this request. This makes it a /// maintenance nightmare, for something that should only rarely be called anyway /// except in the case of <Mth>LoadTableOfContents</Mth>. /// </para> /// <para> /// The case of <Mth>LoadTableOfContents</Mth> is tough, but steps are taken within /// that method to reduce the number of calls to this method to a bare minimum. /// </para> /// </remarks> protected bool IsNavigationValid(NavigationCommand command, Activity activity) { SeqNav seqNav; try { NavigatorData clone = CloneForNavigationTest(); Activity destination; if (activity != null) { destination = clone.Activities[activity.ActivityId]; } else { destination = null; } if (m_packageFormat == PackageFormat.V1p3) { seqNav = new Scorm2004SeqNav(clone); } else { seqNav = new Scorm12SeqNav(clone); } seqNav.OverallSequencingProcess(command, destination); } catch (SequencingException) { // if there was a sequencing exception, // this is a failure condition. return(false); } return(true); }
public void GetWxeFunctionPermanentUrlWithMappedFunctionTypeAndAdditionalUrlParameters() { string resource = "~/Test.wxe"; UrlMappingConfiguration.Current.Mappings.Add(new UrlMappingEntry(_functionType, resource)); string parameter1 = "Value1"; NameValueCollection additionalUrlParameters = new NameValueCollection(); additionalUrlParameters.Add("Parameter2", "Value2"); string expectedUrl = resource.TrimStart('~'); NameValueCollection expectedQueryString = new NameValueCollection(); expectedQueryString.Add("Parameter1", parameter1); expectedQueryString.Add(WxeHandler.Parameters.WxeReturnToSelf, true.ToString()); expectedQueryString.Add(additionalUrlParameters); expectedUrl += UrlUtility.FormatQueryString(expectedQueryString); NavigationCommand command = new NavigationCommand(); command.Type = CommandType.WxeFunction; command.WxeFunctionCommand.TypeName = _functionTypeName; command.WxeFunctionCommand.Parameters = "\"" + parameter1 + "\""; string url = command.GetWxeFunctionPermanentUrl(additionalUrlParameters); Assert.That(url, Is.Not.Null); Assert.That(url, Is.EqualTo(expectedUrl)); }
public MarsRover(int coordX, int coordY, Direction direction, Plateau plateau, NavigationCommand[] navCommands) { if (plateau == null || (plateau.BottomLeftCoordX == plateau.TopRightCoordX && plateau.BottomLeftCoordY == plateau.TopRightCoordY)) { //if Plateau initialization data is invalid/incomplete, we cannot create a rover that we can work with throw new ArgumentException("Plateau is invalid."); } if (navCommands == null || navCommands.Length == 0) { throw new ArgumentException("Invalid navigation commands"); } Plateau = plateau; Direction = direction; NavigationCommands = navCommands; if (ValidateRoverCoordinates(coordX, coordY)) { CoordX = coordX; CoordY = coordY; } else { //if initial values of Rover coordinates are not valid, place the rover in the approximate center of the plateau CoordX = Plateau.BottomLeftCoordX + (Plateau.TopRightCoordX - plateau.BottomLeftCoordY) / 2; CoordY = Plateau.BottomLeftCoordY + (Plateau.TopRightCoordY - plateau.BottomLeftCoordY) / 2; } }
public void Navigate_CommandsWithMovesOutOfBounds_ReturnSkippedMoves_AssignCorrectCoords() { var plateau = new Plateau { BottomLeftCoordX = 0, BottomLeftCoordY = 0, TopRightCoordX = 5, TopRightCoordY = 5 }; //the second move command will be out of bounds var commands = new NavigationCommand[] { NavigationCommand.M, NavigationCommand.M, NavigationCommand.R, NavigationCommand.M }; var rover = new MarsRover(4, 5, App.Enums.Direction.E, plateau, commands); var result = rover.Navigate(commands); Assert.IsNotNull(result); Assert.AreEqual(result.Count, 1); Assert.AreEqual(result[0], 1); Assert.AreEqual(rover.CoordX, 5); Assert.AreEqual(rover.CoordY, 4); Assert.AreEqual(rover.Direction, Direction.S); }
void setupRx() { if (rxObjectsSetup) { return; } NavigateBack = new ReactiveCommand( NavigationStack.CollectionCountChanged.StartWith(_NavigationStack.Count).Select(x => x > 1)); NavigateBack.Subscribe(_ => NavigationStack.RemoveAt(NavigationStack.Count - 1)); Navigate = new NavigationCommand(); Navigate.Subscribe(x => { var vm = x as IRoutableViewModel; if (vm == null) { throw new Exception("Navigate must be called on an IRoutableViewModel"); } NavigationStack.Add(vm); }); NavigateAndReset = new NavigationCommand(); NavigateAndReset.Subscribe(x => { NavigationStack.Clear(); Navigate.Execute(x); }); rxObjectsSetup = true; }
public static bool ParseCommands(Gst.Query query, out NavigationCommand[] cmds) { uint len; cmds = null; if (!QueryParseCommandsLength(query, out len)) { return(false); } cmds = new NavigationCommand[len]; for (uint i = 0; i < len; i++) { NavigationCommand cmd; if (!QueryParseCommandsNth(query, i, out cmd)) { return(false); } cmds[i] = cmd; } return(true); }
public ShoppingListVM() { // Instantiate any Commands/Objects: Item = new Item(); RefreshCommand = new RefreshCommand(this); NavCommand = new NavigationCommand(this); NewItemNavCommand = new NavigationCommand(this, 1); }
public MainWindow() { InitializeComponent(); NavigationCommand navigationCommand = App.Current.Resources["NavigationCommand"] as NavigationCommand; navigationCommand.MainWindow = this; }
private SubMenuTab CreateSubMenuTab(string itemID, NavigationCommand command) { SubMenuTab tab = _mocks.PartialMock <SubMenuTab>(); _mocks.Replay(tab); tab.ItemID = itemID; tab.Command = command; return(tab); }
public MainWindowModel(Window Window, ContentControl contentControl) { NavigateSettingsCommand = new NavigationCommand <SettingsPage>(contentControl); CloseCommand = new CloseCommand(Window); FullscreenCommand = new FullscreenCommand(Window); MinimizeCommand = new MinimizeCommand(Window); RefreshCommand = new RefreshCommand(); MenuItems.Add(new MenuItem(PackIconKind.FileReport, Resources.App_Menu_Processed, Resources.App_Menu_Processed_Description, new NavigationCommand <ProcessedPage>(contentControl))); }
/// <summary> /// Constructor /// </summary> /// <param name="navigationManager">NavigationManager (Injected)</param> public PageViewModelBase(NavigationManager navigationManager) { NavigationManager = navigationManager; CloseCommand = new NavigationCommand(navigationManager) { Icon = "oi oi-x", IsEnabled = true, TargetUri = "/", ToolTip = Messages.CloseCommandToolTip }; }
public void Part1_Example_Step1() { var command = NavigationCommand.FromString("F10"); var ship = new Ship(); ship.ProcessCommand(command); ship.Direction.Should().Be(Direction.East); ship.X.Should().Be(10); ship.Y.Should().Be(0); }
public void Part2_Example_Step1() { var ship = new Ship(); var command = NavigationCommand.FromString("F10"); ship.ProcessWaypointCommand(command); ship.X.Should().Be(100); ship.Y.Should().Be(10); ship.Waypoint.X.Should().Be(10); ship.Waypoint.Y.Should().Be(1); }
public void Setup() { _mocks = new MockRepository(); _mockWebSecurityAdapter = _mocks.StrictMock <IWebSecurityAdapter> (); _mockNavigationCommand = _mocks.StrictMock <NavigationCommand> (); var serviceLocator = DefaultServiceLocator.Create(); serviceLocator.RegisterMultiple <IWebSecurityAdapter> (() => _mockWebSecurityAdapter); serviceLocator.RegisterMultiple <IWxeSecurityAdapter>(); _serviceLocatorScope = new ServiceLocatorScope(serviceLocator); }
public void GetWxeFunctionPermanentUrlWithoutDefaultWxeHandler() { WebConfigurationMock.Current = null; string parameter1 = "Hello World!"; NavigationCommand command = new NavigationCommand(); command.Type = CommandType.WxeFunction; command.WxeFunctionCommand.TypeName = _functionTypeName; command.WxeFunctionCommand.Parameters = "\"" + parameter1 + "\""; command.GetWxeFunctionPermanentUrl(); }
public void MarsRover_InvalidPlateau_Exception() { var plateau = new Plateau { BottomLeftCoordX = 1, BottomLeftCoordY = 1, TopRightCoordX = 1, TopRightCoordY = 1 }; var commands = new NavigationCommand[] { NavigationCommand.M, NavigationCommand.M, NavigationCommand.R, NavigationCommand.M }; var rover = new MarsRover(1, 2, App.Enums.Direction.E, plateau, commands); }
public List<int> Navigate(NavigationCommand[] navCommands) { var listSkippedCommands = new List<int>(); for (var i = 0; i < navCommands.Length; i++) { if (!TryMove(navCommands[i])) { listSkippedCommands.Add(i); } } return listSkippedCommands; }
public void Part1_Example_Step5() { var command = NavigationCommand.FromString("F11"); var ship = new Ship() { X = 17, Y = 3, Direction = Direction.South }; ship.ProcessCommand(command); ship.Direction.Should().Be(Direction.South); ship.X.Should().Be(17); ship.Y.Should().Be(-8); }
/// <summary> /// Performs a full SCORM 2004 or SCORM 1.2 navigation on the current activity tree. /// </summary> /// <param name="command">The navigation command to perform.</param> /// <param name="destination">The destination activity for choice navigation.</param> /// <returns>True if the attempt is completed and should not be returned to.</returns> protected bool Navigate(NavigationCommand command, Activity destination) { if (m_seqNav == null) { if (m_packageFormat == PackageFormat.V1p2 || m_packageFormat == PackageFormat.Lrm) { m_seqNav = new Scorm12SeqNav(this); } else { m_seqNav = new Scorm2004SeqNav(this); } } return(m_seqNav.OverallSequencingProcess(command, destination)); }
public static Direction MoveCompass(Direction direction, NavigationCommand command) { var directionsRight = new Dictionary<Direction, Direction> { { Direction.N, Direction.E }, { Direction.E, Direction.S }, { Direction.S, Direction.W }, { Direction.W, Direction.N } }; var directionsLeft = new Dictionary<Direction, Direction> { { Direction.N, Direction.W }, { Direction.W, Direction.S }, { Direction.S, Direction.E }, { Direction.E, Direction.N } }; if (command == NavigationCommand.R) { return directionsRight[direction]; } else if (command == NavigationCommand.L) { return directionsLeft[direction]; } return direction; }
public void MarsRover_ValidRoverCoords_AssignRoverCoords() { var plateau = new Plateau { BottomLeftCoordX = 0, BottomLeftCoordY = 0, TopRightCoordX = 5, TopRightCoordY = 5 }; var commands = new NavigationCommand[] { NavigationCommand.M, NavigationCommand.M, NavigationCommand.R, NavigationCommand.M }; var rover = new MarsRover(2, 3, App.Enums.Direction.E, plateau, commands); Assert.AreEqual(rover.CoordX, 2); Assert.AreEqual(rover.CoordY, 3); }
public static bool ParseCommands(Gst.Query query, out NavigationCommand[] cmds) { uint len; cmds = null; if (!QueryParseCommandsLength (query, out len)) return false; cmds = new NavigationCommand[len]; for (uint i = 0; i < len; i++) { NavigationCommand cmd; if (!QueryParseCommandsNth (query, i, out cmd)) return false; cmds[i] = cmd; } return true; }
public bool TryMove(NavigationCommand navCommand) { if (navCommand == NavigationCommand.M) { var newX = CoordX; var newY = CoordY; if (Direction == Direction.N) { newY++; } else if (Direction == Direction.S) { newY--; } else if (Direction == Direction.E) { newX++; } else if (Direction == Direction.W) { newX--; } if (!ValidateRoverCoordinates(newX, newY)) { return false; } CoordX = newX; CoordY = newY; } else { Direction = Util.MoveCompass(Direction, navCommand); } return true; }
public abstract void ValidateCommand(NavigationCommand? value);
/// <summary> /// Performs the requested sequencing/navigation using SCORM 2004 sequencing/navigation rules. /// </summary> /// <param name="command">The navigation command to perform.</param> /// <param name="destination"><c>Activity</c> that is the destination of a Choice navigation command.</param> /// <returns>True if the sequencing session has ended.</returns> /// <exception cref="SequencingException">Occurs when there is an invalid navigation performed.</exception> public abstract bool OverallSequencingProcess(NavigationCommand command, Activity destination);
/// <summary> /// Performs the requested sequencing/navigation using SCORM 2004 sequencing/navigation rules. /// </summary> /// <param name="command">The navigation command to perform.</param> /// <param name="destination"><c>Activity</c> that is the destination of a Choice navigation command.</param> /// <returns>True if the sequencing session has ended.</returns> /// <remarks>Corresponds to OP.1 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks> /// <exception cref="SequencingException">Occurs when there is an invalid navigation performed.</exception> public override bool OverallSequencingProcess(NavigationCommand command, Activity destination) { SequencingRequest? seqRequest; TerminationRequest? termRequest; Activity deliveryRequest = null; bool exitSession; Resources.Culture = LocalizationManager.GetCurrentCulture(); m_command = command; ProcessNavigationRequest(destination, out seqRequest, out termRequest); if(termRequest != null) { SequencingRequest? newSeqRequest; newSeqRequest = ProcessTerminationRequest(termRequest.Value); if(newSeqRequest != null) { seqRequest = newSeqRequest; } } if(seqRequest != null) { ProcessSequencingRequest(seqRequest.Value, destination, out deliveryRequest, out exitSession); if(exitSession) { m_navigator.CurrentActivity = null; m_navigator.LogSequencing(SequencingEventType.FinalNavigation, m_command, Resources.NavigationFinishedDone); return true; } } if(deliveryRequest != null) { ProcessDeliveryRequest(deliveryRequest); ContentDeliveryEnvironment(deliveryRequest); m_navigator.LogSequencing(SequencingEventType.FinalNavigation, m_command, Resources.NavigationFinishedNewActivity, deliveryRequest.Key); } else { m_navigator.LogSequencing(SequencingEventType.FinalNavigation, m_command, Resources.NavigationFinishedDone); } return false; }
/// <summary> /// Provides a hook to log sequencing messages. /// </summary> /// <param name="eventType">The type of sequencing event.</param> /// <param name="command">The actual navigation command that initiated this event.</param> /// <param name="message">A string to be logged.</param> /// <param name="args">Arguments that may be supplied to the string to be logged.</param> public virtual void LogSequencing(SequencingEventType eventType, NavigationCommand command, string message, params object[] args) { }
/// <summary> /// Performs a full SCORM 2004 or SCORM 1.2 navigation on the current activity tree. /// </summary> /// <param name="command">The navigation command to perform.</param> /// <param name="destination">The destination activity for choice navigation.</param> /// <returns>True if the attempt is completed and should not be returned to.</returns> protected bool Navigate(NavigationCommand command, Activity destination) { if(m_seqNav == null) { if(m_packageFormat == PackageFormat.V1p2 || m_packageFormat == PackageFormat.Lrm) { m_seqNav = new Scorm12SeqNav(this); } else { m_seqNav = new Scorm2004SeqNav(this); } } return m_seqNav.OverallSequencingProcess(command, destination); }
public void TryMove_MoveInBounds_ReturnTrue_AssignCorrectCoords() { var plateau = new Plateau { BottomLeftCoordX = 0, BottomLeftCoordY = 0, TopRightCoordX = 5, TopRightCoordY = 5 }; var commands = new NavigationCommand[] { NavigationCommand.M, NavigationCommand.R, NavigationCommand.M, NavigationCommand.M, NavigationCommand.R }; var rover = new MarsRover(4, 5, App.Enums.Direction.W, plateau, commands); var result = rover.TryMove(NavigationCommand.M); Assert.AreEqual(rover.CoordX, 3); Assert.AreEqual(rover.CoordY, 5); Assert.AreEqual(rover.Direction, Direction.W); }
public void TryMove_Right_ReturnTrue_KeepOldCoords_ChangeDirection() { var plateau = new Plateau { BottomLeftCoordX = 0, BottomLeftCoordY = 0, TopRightCoordX = 5, TopRightCoordY = 5 }; var commands = new NavigationCommand[] { NavigationCommand.M, NavigationCommand.R, NavigationCommand.M, NavigationCommand.M, NavigationCommand.R }; var rover = new MarsRover(4, 5, App.Enums.Direction.N, plateau, commands); var result = rover.TryMove(NavigationCommand.R); Assert.AreEqual(rover.CoordX, 4); Assert.AreEqual(rover.CoordY, 5); Assert.AreEqual(rover.Direction, Direction.E); }
/// <summary> /// Indicates whether a navigation would be valid if it were to be performed. /// </summary> /// <param name="command">The navigation command to test.</param> /// <param name="activity">The destination activity, if this is a choice navigation.</param> /// <returns>True if the navigation would be valid, false otherwise.</returns> /// <remarks> /// <para> /// This makes a partial copy of the activity tree for processing and attempts to /// perform a navigation on that copy. This may result in poor performance if this /// is called many times, but the alternative is to duplicate most of the sequencing /// code with lots of special cases for changes of state that should have happened but /// could not because of the temporary nature of this request. This makes it a /// maintenance nightmare, for something that should only rarely be called anyway /// except in the case of <Mth>LoadTableOfContents</Mth>. /// </para> /// <para> /// The case of <Mth>LoadTableOfContents</Mth> is tough, but steps are taken within /// that method to reduce the number of calls to this method to a bare minimum. /// </para> /// </remarks> protected bool IsNavigationValid(NavigationCommand command, Activity activity) { SeqNav seqNav; try { NavigatorData clone = CloneForNavigationTest(); Activity destination; if(activity != null) { destination = clone.Activities[activity.ActivityId]; } else { destination = null; } if(m_packageFormat == PackageFormat.V1p3) { seqNav = new Scorm2004SeqNav(clone); } else { seqNav = new Scorm12SeqNav(clone); } seqNav.OverallSequencingProcess(command, destination); } catch(SequencingException) { // if there was a sequencing exception, // this is a failure condition. return false; } return true; }
/// <summary> /// Any valid enum value is valid. /// </summary> /// <param name="value">The value to validate.</param> public override void ValidateCommand(NavigationCommand? value) { switch(value) { // these are all valid values case null: case NavigationCommand.Abandon: case NavigationCommand.AbandonAll: case NavigationCommand.ChoiceStart: case NavigationCommand.Choose: case NavigationCommand.Continue: case NavigationCommand.ExitAll: case NavigationCommand.None: case NavigationCommand.Previous: case NavigationCommand.ResumeAll: case NavigationCommand.Start: case NavigationCommand.SuspendAll: case NavigationCommand.UnqualifiedExit: break; default: throw new ArgumentOutOfRangeException("value"); } }
/// <summary> /// Determines if the passed navigation command is valid to execute or not. /// </summary> /// <param name="command">The navigation command to test.</param> /// <returns>True if the navigation would succeed, false otherwise.</returns> /// <exception cref="ArgumentOutOfRangeException">The command passed is not a valid enumeration value, or is equal to NavigationCommand.Choose.</exception> public abstract bool IsNavigationValid(NavigationCommand command);
/// <summary> /// Performs any navigation request, except for Choice navigation. /// </summary> /// <param name="command">Navigation command to execute.</param> /// <exception cref="SequencingException">Thrown if the navigation fails because a sequencing rule failed.</exception> /// <exception cref="ArgumentOutOfRangeException">The command passed is not a valid enumeration value, or is equal to NavigationCommand.Choose.</exception> public abstract void Navigate(NavigationCommand command);
/// <summary> /// This is invalid for SCORM 1.2 /// </summary> /// <param name="value">The value to validate</param> public override void ValidateCommand(NavigationCommand? value) { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.OnlyValidForSCORMV1p3, "Command")); }
/// <summary> /// Performs the requested sequencing/navigation using SCORM 1.2 sequencing/navigation rules. /// </summary> /// <param name="command">The navigation command to perform.</param> /// <param name="destination"><c>Activity</c> that is the destination of a Choice navigation command.</param> /// <returns>True if the sequencing session has ended.</returns> /// <exception cref="SequencingException">Occurs when there is an invalid navigation performed.</exception> public override bool OverallSequencingProcess(NavigationCommand command, Activity destination) { switch(command) { case NavigationCommand.Abandon: Abandon(); break; case NavigationCommand.AbandonAll: AbandonAll(); return true; case NavigationCommand.Choose: Choose(destination); break; case NavigationCommand.Continue: Continue(); break; case NavigationCommand.ExitAll: ExitAll(); return true; case NavigationCommand.Previous: Previous(); break; case NavigationCommand.ResumeAll: ResumeAll(); break; case NavigationCommand.Start: Start(); break; case NavigationCommand.SuspendAll: SuspendAll(); return true; case NavigationCommand.UnqualifiedExit: UnqualifiedExit(); break; default: throw new LearningComponentsInternalException("SSN0001"); } return false; }